Merge pull request #754 from camthesaxman/emerald_diff

resolve more emerald differences

39 files changed, 1103 insertions, 1101 deletions

diff --git a/src/battle/anim/fight.c b/src/battle/anim/fight.c
index 8d045c42d..450844453 100644
--- a/src/battle/anim/fight.c
+++ b/src/battle/anim/fight.c
@@ -12,7 +12,7 @@ extern u8 gBattlerAttacker;
 extern u8 gBattleAnimAttacker;
 extern u8 gBattleAnimTarget;
 extern u8 gBattlerSpriteIds[];
-extern u8 gBanksBySide[];
+extern u8 gBattlerPositions[];
 extern u16 gBattle_BG1_X;
 extern u16 gBattle_BG1_Y;
 extern u16 gBattle_BG2_X;
@@ -516,7 +516,7 @@ void sub_80D90F4(struct Sprite *sprite)
     if (Random() & 1)
         y *= -1;
 
-    if ((gBanksBySide[bank] & 1) == 0)
+    if ((gBattlerPositions[bank] & 1) == 0)
         y += 0xFFF0;
 
     sprite->pos1.x += x;
diff --git a/src/battle/anim/flying.c b/src/battle/anim/flying.c
index 1f36c933a..407c9a08f 100644
--- a/src/battle/anim/flying.c
+++ b/src/battle/anim/flying.c
@@ -12,7 +12,7 @@ extern u8 gBattleAnimAttacker;
 extern u8 gBattleAnimTarget;
 extern u8 gAnimVisualTaskCount;
 extern struct OamMatrix gOamMatrices[];
-extern u8 gBanksBySide[];
+extern u8 gBattlerPositions[];
 extern const struct SpriteTemplate gBattleAnimSpriteTemplate_83DB538;
 
 void sub_80785E4(struct Sprite *sprite);
@@ -1899,7 +1899,7 @@ void sub_80DAD84(struct Sprite * sprite)
 
     if (gMain.inBattle)
     {
-        if (gBanksBySide[gBattleAnimTarget] & 1)
+        if (gBattlerPositions[gBattleAnimTarget] & 1)
         {
             sprite->data[7] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) + gBattleAnimArgs[3];
         }
diff --git a/src/battle/anim/ice.c b/src/battle/anim/ice.c
index 4002ceec1..e41057d72 100644
--- a/src/battle/anim/ice.c
+++ b/src/battle/anim/ice.c
@@ -14,7 +14,7 @@ extern s16 gBattleAnimArgs[];
 extern u8  gBattleAnimAttacker;
 extern u8  gBattleAnimTarget;
 extern u8  gAnimVisualTaskCount;
-extern u8  gBanksBySide[];
+extern u8  gBattlerPositions[];
 extern u8  gBattlerSpriteIds[];
 
 extern u16 gBattle_BG1_X;
@@ -1419,12 +1419,12 @@ static void InitPoisonGasCloudAnim(struct Sprite *sprite)
     if (GetBattlerSpriteCoord(gBattleAnimAttacker, 2) < GetBattlerSpriteCoord(gBattleAnimTarget, 2))
         sprite->data[7] = 0x8000;
 
-    if (!(gBanksBySide[gBattleAnimTarget] & 1))
+    if (!(gBattlerPositions[gBattleAnimTarget] & 1))
     {
         gBattleAnimArgs[1] = -gBattleAnimArgs[1];
         gBattleAnimArgs[3] = -gBattleAnimArgs[3];
 
-        if ((sprite->data[7] & 0x8000) && !(gBanksBySide[gBattleAnimAttacker] & 1))
+        if ((sprite->data[7] & 0x8000) && !(gBattlerPositions[gBattleAnimAttacker] & 1))
             sprite->subpriority = gSprites[GetAnimBattlerSpriteId(1)].subpriority + 1;
 
         sprite->data[6] = 1; 
@@ -1490,7 +1490,7 @@ static void sub_80D8874(struct Sprite *sprite)
             sprite->data[3] = sprite->pos1.y;
             sprite->data[4] = sprite->pos1.y + 29;
             sprite->data[7]++;
-            if (gMain.inBattle && gBanksBySide[gBattleAnimTarget] & 1)
+            if (gMain.inBattle && gBattlerPositions[gBattleAnimTarget] & 1)
                 sprite->data[5] = 204;
             else
                 sprite->data[5] = value2;
@@ -1535,7 +1535,7 @@ static void sub_80D8874(struct Sprite *sprite)
             sprite->data[1] = sprite->pos1.x += sprite->pos2.x;
             sprite->data[3] = sprite->pos1.y += sprite->pos2.y;
             sprite->data[4] = sprite->pos1.y + 4;
-            if (gMain.inBattle && gBanksBySide[gBattleAnimTarget] & 1)
+            if (gMain.inBattle && gBattlerPositions[gBattleAnimTarget] & 1)
                 sprite->data[2] = 0x100;
             else
                 sprite->data[2] = -0x10;
@@ -1646,7 +1646,7 @@ NAKED static void sub_80D8874(struct Sprite *sprite)
                 "\tands r0, r1\n"
                 "\tcmp r0, 0\n"
                 "\tbeq _080D8938\n"
-                "\tldr r1, _080D8934 @ =gBanksBySide\n"
+                "\tldr r1, _080D8934 @ =gBattlerPositions\n"
                 "\tldrb r0, [r6]\n"
                 "\tadds r0, r1\n"
                 "\tldrb r1, [r0]\n"
@@ -1661,7 +1661,7 @@ NAKED static void sub_80D8874(struct Sprite *sprite)
                 "_080D8928: .4byte gBattleAnimTarget\n"
                 "_080D892C: .4byte gMain\n"
                 "_080D8930: .4byte 0x0000043d\n"
-                "_080D8934: .4byte gBanksBySide\n"
+                "_080D8934: .4byte gBattlerPositions\n"
                 "_080D8938:\n"
                 "\tstrh r5, [r4, 0x38]\n"
                 "_080D893A:\n"
@@ -1806,7 +1806,7 @@ NAKED static void sub_80D8874(struct Sprite *sprite)
                 "\tands r0, r1\n"
                 "\tcmp r0, 0\n"
                 "\tbeq _080D8A78\n"
-                "\tldr r1, _080D8A70 @ =gBanksBySide\n"
+                "\tldr r1, _080D8A70 @ =gBattlerPositions\n"
                 "\tldr r0, _080D8A74 @ =gBattleAnimTarget\n"
                 "\tldrb r0, [r0]\n"
                 "\tadds r0, r1\n"
@@ -1821,7 +1821,7 @@ NAKED static void sub_80D8874(struct Sprite *sprite)
                 "\t.align 2, 0\n"
                 "_080D8A68: .4byte gMain\n"
                 "_080D8A6C: .4byte 0x0000043d\n"
-                "_080D8A70: .4byte gBanksBySide\n"
+                "_080D8A70: .4byte gBattlerPositions\n"
                 "_080D8A74: .4byte gBattleAnimTarget\n"
                 "_080D8A78:\n"
                 "\tldr r0, _080D8A90 @ =0x0000fff0\n"
diff --git a/src/battle/anim/sonic.c b/src/battle/anim/sonic.c
index 9cdda992f..cef255eda 100644
--- a/src/battle/anim/sonic.c
+++ b/src/battle/anim/sonic.c
@@ -9,7 +9,7 @@
 extern s16 gBattleAnimArgs[];
 extern u8 gBattleAnimAttacker;
 extern u8 gBattleAnimTarget;
-extern u8 gBanksBySide[];
+extern u8 gBattlerPositions[];
 extern u16 gBattleTypeFlags;
 
 extern void sub_80D4CA4(struct Sprite *sprite);
@@ -296,7 +296,7 @@ void sub_80CFB04(u8 taskId)
     }
     else
     {
-        if ((gBanksBySide[gBattleAnimTarget] & 1) == 0)
+        if ((gBattlerPositions[gBattleAnimTarget] & 1) == 0)
         {
             gTasks[taskId].data[4] = 1;
             gBattleAnimArgs[0] = -gBattleAnimArgs[0];
diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c
index 0c8b8fb1b..405776db6 100644
--- a/src/battle_ai_script_commands.c
+++ b/src/battle_ai_script_commands.c
@@ -26,9 +26,9 @@ extern u8 gBattlerTarget;
 extern u8 gAbsentBattlerFlags;
 extern u8 gMoveResultFlags;
 extern u16 gDynamicBasePower;
-extern u16 gLastUsedMove[MAX_BATTLERS_COUNT];
+extern u16 gLastMoves[MAX_BATTLERS_COUNT];
 extern u32 gStatuses3[MAX_BATTLERS_COUNT];
-extern u16 gSideAffecting[2];
+extern u16 gSideStatuses[2];
 extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
 extern u8 gCritMultiplier;
 extern u16 gTrainerBattleOpponent;
@@ -448,7 +448,7 @@ void sub_810745C(void)
     {
         if (AI_BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] == 0)
         {
-            AI_BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] = gLastUsedMove[gBattlerTarget];
+            AI_BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] = gLastMoves[gBattlerTarget];
             return;
         }
     }
@@ -468,7 +468,7 @@ void RecordAbilityBattle(u8 a, u8 b)
         AI_BATTLE_HISTORY->abilities[GetBattlerPosition(a) & 1] = b;
 }
 
-void RecordItemBattle(u8 a, u8 b)
+void RecordItemEffectBattle(u8 a, u8 b)
 {
     if (GetBattlerSide(a) == 0)
         AI_BATTLE_HISTORY->itemEffects[GetBattlerPosition(a) & 1] = b;
@@ -697,7 +697,7 @@ static void BattleAICmd_if_status4(void)
     arg1 = GetBattlerPosition(index) & 1;
     arg2 = T1_READ_32(gAIScriptPtr + 2);
 
-    if ((gSideAffecting[arg1] & arg2) != 0)
+    if ((gSideStatuses[arg1] & arg2) != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
     else
         gAIScriptPtr += 10;
@@ -716,7 +716,7 @@ static void BattleAICmd_if_not_status4(void)
     arg1 = GetBattlerPosition(index) & 1;
     arg2 = T1_READ_32(gAIScriptPtr + 2);
 
-    if ((gSideAffecting[arg1] & arg2) == 0)
+    if ((gSideStatuses[arg1] & arg2) == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
     else
         gAIScriptPtr += 10;
@@ -1256,9 +1256,9 @@ _081083D0: .4byte gAIScriptPtr\n\
 static void BattleAICmd_get_move(void)
 {
     if (gAIScriptPtr[1] == USER)
-        AI_THINKING_STRUCT->funcResult = gLastUsedMove[gBattlerAttacker];
+        AI_THINKING_STRUCT->funcResult = gLastMoves[gBattlerAttacker];
     else
-        AI_THINKING_STRUCT->funcResult = gLastUsedMove[gBattlerTarget];
+        AI_THINKING_STRUCT->funcResult = gLastMoves[gBattlerTarget];
 
     gAIScriptPtr += 2;
 }
diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c
index 9da56a220..b4b2841e0 100644
--- a/src/battle_ai_switch_items.c
+++ b/src/battle_ai_switch_items.c
@@ -1,13 +1,13 @@
 #include "global.h"
 #include "battle.h"
 #include "battle_ai_switch_items.h"
+#include "battle_controllers.h"
 #include "battle_script_commands.h"
 #include "data2.h"
 #include "ewram.h"
 #include "pokemon.h"
 #include "random.h"
 #include "rom_8077ABC.h"
-#include "rom3.h"
 #include "util.h"
 #include "constants/abilities.h"
 #include "constants/items.h"
@@ -386,7 +386,7 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void)
 
 static bool8 ShouldSwitchIfNaturalCure(void)
 {
-    if (!(gBattleMons[gActiveBattler].status1 & STATUS_SLEEP))
+    if (!(gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP))
         return FALSE;
     if (gBattleMons[gActiveBattler].ability != ABILITY_NATURAL_CURE)
         return FALSE;
@@ -936,27 +936,27 @@ static bool8 ShouldUseItem(void)
             break;
         case AI_ITEM_CURE_CONDITION:
             ewram160DA(gActiveBattler) = 0;
-            if (itemEffects[3] & 0x20 && gBattleMons[gActiveBattler].status1 & STATUS_SLEEP)
+            if (itemEffects[3] & 0x20 && gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP)
             {
                ewram160DA(gActiveBattler) |= 0x20;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x10 && (gBattleMons[gActiveBattler].status1 & STATUS_POISON || gBattleMons[gActiveBattler].status1 & STATUS_TOXIC_POISON))
+            if (itemEffects[3] & 0x10 && (gBattleMons[gActiveBattler].status1 & STATUS1_POISON || gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_POISON))
             {
                ewram160DA(gActiveBattler) |= 0x10;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x8 && gBattleMons[gActiveBattler].status1 & STATUS_BURN)
+            if (itemEffects[3] & 0x8 && gBattleMons[gActiveBattler].status1 & STATUS1_BURN)
             {
                ewram160DA(gActiveBattler) |= 0x8;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x4 && gBattleMons[gActiveBattler].status1 & STATUS_FREEZE)
+            if (itemEffects[3] & 0x4 && gBattleMons[gActiveBattler].status1 & STATUS1_FREEZE)
             {
                ewram160DA(gActiveBattler) |= 0x4;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x2 && gBattleMons[gActiveBattler].status1 & STATUS_PARALYSIS)
+            if (itemEffects[3] & 0x2 && gBattleMons[gActiveBattler].status1 & STATUS1_PARALYSIS)
             {
                ewram160DA(gActiveBattler) |= 0x2;
                 shouldUse = TRUE;
diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c
index d99b4fe27..a1d07eb50 100644
--- a/src/battle_controller_link_opponent.c
+++ b/src/battle_controller_link_opponent.c
@@ -2,6 +2,7 @@
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_anim_special.h"
+#include "battle_controllers.h"
 #include "battle_interface.h"
 #include "data2.h"
 #include "link.h"
@@ -9,7 +10,6 @@
 #include "main.h"
 #include "palette.h"
 #include "rom_8077ABC.h"
-#include "rom3.h"
 #include "constants/songs.h"
 #include "sound.h"
 #include "sprite.h"
diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c
index a5b24815f..3ea5bd624 100644
--- a/src/battle_controller_link_partner.c
+++ b/src/battle_controller_link_partner.c
@@ -2,6 +2,7 @@
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_anim_special.h"
+#include "battle_controllers.h"
 #include "battle_interface.h"
 #include "data2.h"
 #include "battle_811DA74.h"
@@ -12,7 +13,6 @@
 #include "palette.h"
 #include "pokeball.h"
 #include "pokemon.h"
-#include "rom3.h"
 #include "rom_8077ABC.h"
 #include "sound.h"
 #include "constants/songs.h"
diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c
index 2faaf5fea..da11c3aa9 100644
--- a/src/battle_controller_opponent.c
+++ b/src/battle_controller_opponent.c
@@ -3,6 +3,7 @@
 #include "battle_ai_script_commands.h"
 #include "battle_ai_switch_items.h"
 #include "battle_anim.h"
+#include "battle_controllers.h"
 #include "battle_interface.h"
 #include "data2.h"
 #include "battle_811DA74.h"
@@ -15,7 +16,6 @@
 #include "pokeball.h"
 #include "pokemon.h"
 #include "random.h"
-#include "rom3.h"
 #include "rom_8077ABC.h"
 #include "sound.h"
 #include "constants/songs.h"
diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c
index 7de3ada41..361eb8ef8 100644
--- a/src/battle_controller_player.c
+++ b/src/battle_controller_player.c
@@ -3,6 +3,7 @@
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_anim_special.h"
+#include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
 #include "item.h"
@@ -14,7 +15,6 @@
 #include "constants/moves.h"
 #include "palette.h"
 #include "pokemon.h"
-#include "rom3.h"
 #include "constants/songs.h"
 #include "sound.h"
 #include "string_util.h"
@@ -819,10 +819,10 @@ void sub_802CA60(void)
             r9->unkC[gMoveSelectionCursor[gActiveBattler]] = r9->unkC[gUnknown_03004344];
             r9->unkC[gUnknown_03004344] = i;
 
-            if (gDisableStructs[gActiveBattler].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBattler]])
+            if (gDisableStructs[gActiveBattler].mimickedMoves & gBitTable[gMoveSelectionCursor[gActiveBattler]])
             {
-                gDisableStructs[gActiveBattler].unk18_b &= ~gBitTable[gMoveSelectionCursor[gActiveBattler]];
-                gDisableStructs[gActiveBattler].unk18_b |= gBitTable[gUnknown_03004344];
+                gDisableStructs[gActiveBattler].mimickedMoves &= ~gBitTable[gMoveSelectionCursor[gActiveBattler]];
+                gDisableStructs[gActiveBattler].mimickedMoves |= gBitTable[gUnknown_03004344];
             }
 
             sub_802E1B0();
diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c
index 28418531f..5cf06796f 100644
--- a/src/battle_controller_safari.c
+++ b/src/battle_controller_safari.c
@@ -1,6 +1,7 @@
 #include "global.h"
 #include "battle_anim_81258BC.h"
 #include "battle.h"
+#include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
 #include "data2.h"
@@ -8,7 +9,6 @@
 #include "main.h"
 #include "menu_cursor.h"
 #include "palette.h"
-#include "rom3.h"
 #include "constants/songs.h"
 #include "sound.h"
 #include "text.h"
diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c
index a16fe26cc..ac71aabaf 100644
--- a/src/battle_controller_wally.c
+++ b/src/battle_controller_wally.c
@@ -2,6 +2,7 @@
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_anim_special.h"
+#include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
 #include "data2.h"
@@ -10,7 +11,6 @@
 #include "menu_cursor.h"
 #include "palette.h"
 #include "pokemon.h"
-#include "rom3.h"
 #include "constants/songs.h"
 #include "sound.h"
 #include "sprite.h"
@@ -58,7 +58,6 @@ extern u8 gUnknown_0300434C[];
 extern const u8 BattleText_WallyMenu[];
 extern const u8 BattleText_MenuOptions[];
 
-// TODO: include rom3.h when my other PR gets merged
 extern void BtlController_EmitTwoReturnValues(u8, u8, u16);
 extern void BtlController_EmitOneReturnValue(u8, u16);
 
diff --git a/src/rom3.c b/src/battle_controllers.c
index c4a6ffec0..02cb59cc4 100644
--- a/src/rom3.c
+++ b/src/battle_controllers.c
@@ -1,5 +1,6 @@
 #include "global.h"
 #include "battle.h"
+#include "battle_controllers.h"
 #include "battle_811DA74.h"
 #include "battle_ai_script_commands.h"
 #include "battle_anim.h"
@@ -10,7 +11,6 @@
 #include "constants/items.h"
 #include "link.h"
 #include "pokemon.h"
-#include "rom3.h"
 #include "rom_8094928.h"
 #include "constants/species.h"
 #include "task.h"
@@ -18,6 +18,7 @@
 #include "battle_message.h"
 #include "data2.h"
 #include "ewram.h"
+#include "constants/abilities.h"
 
 extern u16 gBattleTypeFlags;
 extern u16 gBattleWeather;
@@ -34,7 +35,7 @@ extern u8 gActiveBattler;
 extern u32 gBattleControllerExecFlags;
 extern u8 gBattlersCount;
 extern u16 gBattlerPartyIndexes[];
-extern u8 gBanksBySide[];
+extern u8 gBattlerPositions[];
 extern u16 gCurrentMove;
 extern u16 gChosenMove;
 extern u16 gLastUsedItem;
@@ -57,7 +58,14 @@ extern void (*gBattlerControllerFuncs[])(void);
 
 u8 gBattleBuffersTransferData[0x170];
 
-void sub_800B858(void)
+// this file's funcionts
+static void CreateTasksForSendRecvLinkBuffers(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)
     {
@@ -76,14 +84,16 @@ void SetUpBattleVarsAndBirchPoochyena(void)
     s32 i;
 
     gBattleMainFunc = nullsub_41;
-    for (i = 0; i < 4; i++)
+
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
         gBattlerControllerFuncs[i] = nullsub_91;
-        gBanksBySide[i] = 0xFF;
+        gBattlerPositions[i] = 0xFF;
         gActionSelectionCursor[i] = 0;
         gMoveSelectionCursor[i] = 0;
     }
-    sub_800B858();
+
+    HandleLinkBattleSetup();
     gBattleControllerExecFlags = 0;
     ClearBattleAnimationVars();
     ClearBattleMonForms();
@@ -114,10 +124,12 @@ void sub_800B950(void)
     s32 i;
 
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
-        sub_800BA78();
+        InitLinkBtlControllers();
     else
-        sub_800B9A8();
-    sub_800BD54();
+        InitSinglePlayerBtlControllers();
+
+    SetBattlePartyIds();
+
     if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
     {
         for (i = 0; i < gBattlersCount; i++)
@@ -125,7 +137,7 @@ void sub_800B950(void)
     }
 }
 
-void sub_800B9A8(void)
+static void InitSinglePlayerBtlControllers(void)
 {
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
     {
@@ -136,27 +148,27 @@ void sub_800B9A8(void)
             gBattlerControllerFuncs[0] = SetBankFuncToWallyBufferRunCommand;
         else
             gBattlerControllerFuncs[0] = SetBankFuncToPlayerBufferRunCommand;
-        gBanksBySide[0] = 0;
+        gBattlerPositions[0] = 0;
         gBattlerControllerFuncs[1] = SetBankFuncToOpponentBufferRunCommand;
-        gBanksBySide[1] = 1;
+        gBattlerPositions[1] = 1;
         gBattlersCount = 2;
     }
     else
     {
         gBattleMainFunc = sub_8010800;
         gBattlerControllerFuncs[0] = SetBankFuncToPlayerBufferRunCommand;
-        gBanksBySide[0] = 0;
+        gBattlerPositions[0] = 0;
         gBattlerControllerFuncs[1] = SetBankFuncToOpponentBufferRunCommand;
-        gBanksBySide[1] = 1;
+        gBattlerPositions[1] = 1;
         gBattlerControllerFuncs[2] = SetBankFuncToPlayerBufferRunCommand;
-        gBanksBySide[2] = 2;
+        gBattlerPositions[2] = 2;
         gBattlerControllerFuncs[3] = SetBankFuncToOpponentBufferRunCommand;
-        gBanksBySide[3] = 3;
+        gBattlerPositions[3] = 3;
         gBattlersCount = 4;
     }
 }
 
-void sub_800BA78(void)
+void InitLinkBtlControllers(void)
 {
     u8 multiplayerId;
     int i;
@@ -167,17 +179,17 @@ void sub_800BA78(void)
         {
             gBattleMainFunc = sub_8010800;
             gBattlerControllerFuncs[0] = SetBankFuncToPlayerBufferRunCommand;
-            gBanksBySide[0] = 0;
+            gBattlerPositions[0] = 0;
             gBattlerControllerFuncs[1] = SetBankFuncToLinkOpponentBufferRunCommand;
-            gBanksBySide[1] = 1;
+            gBattlerPositions[1] = 1;
             gBattlersCount = 2;
         }
         else
         {
             gBattlerControllerFuncs[1] = SetBankFuncToPlayerBufferRunCommand;
-            gBanksBySide[1] = 0;
+            gBattlerPositions[1] = 0;
             gBattlerControllerFuncs[0] = SetBankFuncToLinkOpponentBufferRunCommand;
-            gBanksBySide[0] = 1;
+            gBattlerPositions[0] = 1;
             gBattlersCount = 2;
         }
         return;
@@ -188,25 +200,25 @@ void sub_800BA78(void)
         {
             gBattleMainFunc = sub_8010800;
             gBattlerControllerFuncs[0] = SetBankFuncToPlayerBufferRunCommand;
-            gBanksBySide[0] = 0;
+            gBattlerPositions[0] = 0;
             gBattlerControllerFuncs[1] = SetBankFuncToLinkOpponentBufferRunCommand;
-            gBanksBySide[1] = 1;
+            gBattlerPositions[1] = 1;
             gBattlerControllerFuncs[2] = SetBankFuncToPlayerBufferRunCommand;
-            gBanksBySide[2] = 2;
+            gBattlerPositions[2] = 2;
             gBattlerControllerFuncs[3] = SetBankFuncToLinkOpponentBufferRunCommand;
-            gBanksBySide[3] = 3;
+            gBattlerPositions[3] = 3;
             gBattlersCount = 4;
         }
         else
         {
             gBattlerControllerFuncs[1] = SetBankFuncToPlayerBufferRunCommand;
-            gBanksBySide[1] = 0;
+            gBattlerPositions[1] = 0;
             gBattlerControllerFuncs[0] = SetBankFuncToLinkOpponentBufferRunCommand;
-            gBanksBySide[0] = 1;
+            gBattlerPositions[0] = 1;
             gBattlerControllerFuncs[3] = SetBankFuncToPlayerBufferRunCommand;
-            gBanksBySide[3] = 2;
+            gBattlerPositions[3] = 2;
             gBattlerControllerFuncs[2] = SetBankFuncToLinkOpponentBufferRunCommand;
-            gBanksBySide[2] = 3;
+            gBattlerPositions[2] = 3;
             gBattlersCount = 4;
 
         }
@@ -236,12 +248,12 @@ void sub_800BA78(void)
             {
             case 0:
             case 3:
-                gBanksBySide[gLinkPlayers[i].id] = 0;
+                gBattlerPositions[gLinkPlayers[i].id] = 0;
                 gBattlerPartyIndexes[gLinkPlayers[i].id] = 0;
                 break;
             case 1:
             case 2:
-                gBanksBySide[gLinkPlayers[i].id] = 2;
+                gBattlerPositions[gLinkPlayers[i].id] = 2;
                 gBattlerPartyIndexes[gLinkPlayers[i].id] = 3;
                 break;
             }
@@ -256,12 +268,12 @@ void sub_800BA78(void)
                 {
                 case 0:
                 case 3:
-                    gBanksBySide[gLinkPlayers[i].id] = 0;
+                    gBattlerPositions[gLinkPlayers[i].id] = 0;
                     gBattlerPartyIndexes[gLinkPlayers[i].id] = 0;
                     break;
                 case 1:
                 case 2:
-                    gBanksBySide[gLinkPlayers[i].id] = 2;
+                    gBattlerPositions[gLinkPlayers[i].id] = 2;
                     gBattlerPartyIndexes[gLinkPlayers[i].id] = 3;
                     break;
                 }
@@ -273,12 +285,12 @@ void sub_800BA78(void)
                 {
                 case 0:
                 case 3:
-                    gBanksBySide[gLinkPlayers[i].id] = 1;
+                    gBattlerPositions[gLinkPlayers[i].id] = 1;
                     gBattlerPartyIndexes[gLinkPlayers[i].id] = 0;
                     break;
                 case 1:
                 case 2:
-                    gBanksBySide[gLinkPlayers[i].id] = 3;
+                    gBattlerPositions[gLinkPlayers[i].id] = 3;
                     gBattlerPartyIndexes[gLinkPlayers[i].id] = 3;
                     break;
                 }
@@ -288,23 +300,22 @@ void sub_800BA78(void)
     gBattlersCount = 4;
 }
 
-void sub_800BD54(void)
+static void SetBattlePartyIds(void)
 {
-    int i;
-    int j;
+    s32 i, j;
 
     if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
     {
         for (i = 0; i < gBattlersCount; i++)
         {
-            for (j = 0; j < 6; j++)
+            for (j = 0; j < PARTY_SIZE; j++)
             {
                 if (i < 2)
                 {
-                    if (!(gBanksBySide[i] & 1))
+                    if (GET_BATTLER_SIDE2(i) == B_SIDE_PLAYER)
                     {
                         if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
-                         && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != 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)
                         {
@@ -315,7 +326,7 @@ void sub_800BD54(void)
                     else
                     {
                         if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
-                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != 0
+                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
                          && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
                          && GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG) == 0)
                         {
@@ -326,10 +337,10 @@ void sub_800BD54(void)
                 }
                 else
                 {
-                    if (!(gBanksBySide[i] & 1))
+                    if (GET_BATTLER_SIDE2(i) == B_SIDE_PLAYER)
                     {
                         if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
-                         && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES) != 0  //Probably a typo by Game Freak. The rest use SPECIES2
+                         && 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
                          && gBattlerPartyIndexes[i - 2] != j)
@@ -341,7 +352,7 @@ void sub_800BD54(void)
                     else
                     {
                         if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
-                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != 0
+                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
                          && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
                          && GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG) == 0
                          && gBattlerPartyIndexes[i - 2] != j)
@@ -356,17 +367,17 @@ void sub_800BD54(void)
     }
 }
 
-void PrepareBufferDataTransfer(u8 a, u8 *data, u16 size)
+static void PrepareBufferDataTransfer(u8 bufferId, u8 *data, u16 size)
 {
-    int i;
+    s32 i;
 
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
     {
-        PrepareBufferDataTransferLink(a, size, data);
+        PrepareBufferDataTransferLink(bufferId, size, data);
     }
     else
     {
-        switch (a)
+        switch (bufferId)
         {
         case 0:
             for (i = 0; i < size; i++)
@@ -386,7 +397,7 @@ void PrepareBufferDataTransfer(u8 a, u8 *data, u16 size)
     }
 }
 
-void CreateTasksForSendRecvLinkBuffers(void)
+static void CreateTasksForSendRecvLinkBuffers(void)
 {
     sLinkSendTaskId = CreateTask(Task_HandleSendLinkBuffersData, 0);
     gTasks[sLinkSendTaskId].data[11] = 0;
@@ -538,10 +549,10 @@ void sub_800C35C(void)
     }
 }
 
-void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
+static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
 {
-    u16 r7;
-    u8 r4;
+    u16 blockSize;
+    u8 battlerId;
     u8 r2;
 
     if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
@@ -552,15 +563,15 @@ void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
             gTasks[taskId].data[12] = 0;
             gTasks[taskId].data[15] = 0;
         }
-        r4 = ewram15000arr(1, gTasks[taskId].data[15]);
-        r7 = ewram15000arr(4, gTasks[taskId].data[15]) | (ewram15000arr(5, gTasks[taskId].data[15]) << 8);
+        battlerId = ewram15000arr(1, gTasks[taskId].data[15]);
+        blockSize = ewram15000arr(4, gTasks[taskId].data[15]) | (ewram15000arr(5, gTasks[taskId].data[15]) << 8);
         switch (ewram15000arr(0, gTasks[taskId].data[15]))
         {
         case 0:
-            if (gBattleControllerExecFlags & gBitTable[r4])
+            if (gBattleControllerExecFlags & gBitTable[battlerId])
                 return;
-            memcpy(gBattleBufferA[r4], &ewram15000arr(8, gTasks[taskId].data[15]), r7);
-            sub_80155A4(r4);
+            memcpy(gBattleBufferA[battlerId], &ewram15000arr(8, gTasks[taskId].data[15]), blockSize);
+            sub_80155A4(battlerId);
             if (!(gBattleTypeFlags & BATTLE_TYPE_WILD))
             {
                 gBattlerAttacker = ewram15000arr(2, gTasks[taskId].data[15]);
@@ -570,172 +581,172 @@ void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
             }
             break;
         case 1:
-            memcpy(gBattleBufferB[r4], &ewram15000arr(8, gTasks[taskId].data[15]), r7);
+            memcpy(gBattleBufferB[battlerId], &ewram15000arr(8, gTasks[taskId].data[15]), blockSize);
             break;
         case 2:
             r2 = ewram15000arr(8, gTasks[taskId].data[15]);
-            gBattleControllerExecFlags &= ~(gBitTable[r4] << (r2 * 4));
+            gBattleControllerExecFlags &= ~(gBitTable[battlerId] << (r2 * 4));
             break;
         }
 
-        gTasks[taskId].data[15] = gTasks[taskId].data[15] + r7 + 8;
+        gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + 8;
     }
 }
 
-void BtlController_EmitGetMonData(u8 bufferId, u8 b, u8 c)
+void BtlController_EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck)
 {
-    gBattleBuffersTransferData[0] = 0;
-    gBattleBuffersTransferData[1] = b;
-    gBattleBuffersTransferData[2] = c;
+    gBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA;
+    gBattleBuffersTransferData[1] = requestId;
+    gBattleBuffersTransferData[2] = monToCheck;
     gBattleBuffersTransferData[3] = 0;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitGetRawMonData(u8 bufferId, u8 b, u8 c)
+void BtlController_EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes)
 {
-    gBattleBuffersTransferData[0] = 1;
-    gBattleBuffersTransferData[1] = b;
-    gBattleBuffersTransferData[2] = c;
+    gBattleBuffersTransferData[0] = CONTROLLER_GETRAWMONDATA;
+    gBattleBuffersTransferData[1] = monId;
+    gBattleBuffersTransferData[2] = bytes;
     gBattleBuffersTransferData[3] = 0;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitSetMonData(u8 bufferId, u8 b, u8 c, u8 d, void *e)
+void BtlController_EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data)
 {
-    int i;
+    s32 i;
 
-    gBattleBuffersTransferData[0] = 2;
-    gBattleBuffersTransferData[1] = b;
-    gBattleBuffersTransferData[2] = c;
-    for (i = 0; i < d; i++)
-        gBattleBuffersTransferData[3 + i] = *(u8*)(e++);
-    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, d + 3);
+    gBattleBuffersTransferData[0] = CONTROLLER_SETMONDATA;
+    gBattleBuffersTransferData[1] = requestId;
+    gBattleBuffersTransferData[2] = monToCheck;
+    for (i = 0; i < bytes; i++)
+        gBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 3 + bytes);
 }
 
-void BtlController_EmitSetRawMonData(u8 bufferId, u8 b, u8 c, u8 *d)
+void BtlController_EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data)
 {
-    int i;
+    s32 i;
 
-    gBattleBuffersTransferData[0] = 3;
-    gBattleBuffersTransferData[1] = b;
-    gBattleBuffersTransferData[2] = c;
-    for (i = 0; i < c; i++)
-        gBattleBuffersTransferData[3 + i] = *(d++);
-    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, c + 3);
+    gBattleBuffersTransferData[0] = CONTROLLER_SETRAWMONDATA;
+    gBattleBuffersTransferData[1] = monId;
+    gBattleBuffersTransferData[2] = bytes;
+    for (i = 0; i < bytes; i++)
+        gBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, bytes + 3);
 }
 
 void BtlController_EmitLoadMonSprite(u8 bufferId)
 {
-    gBattleBuffersTransferData[0] = 4;
-    gBattleBuffersTransferData[1] = 4;
-    gBattleBuffersTransferData[2] = 4;
-    gBattleBuffersTransferData[3] = 4;
+    gBattleBuffersTransferData[0] = CONTROLLER_LOADMONSPRITE;
+    gBattleBuffersTransferData[1] = CONTROLLER_LOADMONSPRITE;
+    gBattleBuffersTransferData[2] = CONTROLLER_LOADMONSPRITE;
+    gBattleBuffersTransferData[3] = CONTROLLER_LOADMONSPRITE;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitSwitchInAnim(u8 bufferId, u8 b, u8 c)
+void BtlController_EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit)
 {
-    gBattleBuffersTransferData[0] = 5;
-    gBattleBuffersTransferData[1] = b;
-    gBattleBuffersTransferData[2] = c;
+    gBattleBuffersTransferData[0] = CONTROLLER_SWITCHINANIM;
+    gBattleBuffersTransferData[1] = partyId;
+    gBattleBuffersTransferData[2] = dontClearSubstituteBit;
     gBattleBuffersTransferData[3] = 5;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitReturnMonToBall(u8 bufferId, u8 b)
+void BtlController_EmitReturnMonToBall(u8 bufferId, u8 arg1)
 {
-    gBattleBuffersTransferData[0] = 6;
-    gBattleBuffersTransferData[1] = b;
+    gBattleBuffersTransferData[0] = CONTROLLER_RETURNMONTOBALL;
+    gBattleBuffersTransferData[1] = arg1;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void BtlController_EmitDrawTrainerPic(u8 a)
+void BtlController_EmitDrawTrainerPic(u8 bufferId)
 {
-    gBattleBuffersTransferData[0] = 7;
-    gBattleBuffersTransferData[1] = 7;
-    gBattleBuffersTransferData[2] = 7;
-    gBattleBuffersTransferData[3] = 7;
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4);
+    gBattleBuffersTransferData[0] = CONTROLLER_DRAWTRAINERPIC;
+    gBattleBuffersTransferData[1] = CONTROLLER_DRAWTRAINERPIC;
+    gBattleBuffersTransferData[2] = CONTROLLER_DRAWTRAINERPIC;
+    gBattleBuffersTransferData[3] = CONTROLLER_DRAWTRAINERPIC;
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitTrainerSlide(u8 a)
+void BtlController_EmitTrainerSlide(u8 bufferId)
 {
-    gBattleBuffersTransferData[0] = 8;
-    gBattleBuffersTransferData[1] = 8;
-    gBattleBuffersTransferData[2] = 8;
-    gBattleBuffersTransferData[3] = 8;
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4);
+    gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDE;
+    gBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDE;
+    gBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDE;
+    gBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDE;
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitTrainerSlideBack(u8 a)
+void BtlController_EmitTrainerSlideBack(u8 bufferId)
 {
-    gBattleBuffersTransferData[0] = 9;
-    gBattleBuffersTransferData[1] = 9;
-    gBattleBuffersTransferData[2] = 9;
-    gBattleBuffersTransferData[3] = 9;
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4);
+    gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDEBACK;
+    gBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDEBACK;
+    gBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDEBACK;
+    gBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDEBACK;
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitFaintAnimation(u8 a)
+void BtlController_EmitFaintAnimation(u8 bufferId)
 {
-    gBattleBuffersTransferData[0] = 10;
-    gBattleBuffersTransferData[1] = 10;
-    gBattleBuffersTransferData[2] = 10;
-    gBattleBuffersTransferData[3] = 10;
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4);
+    gBattleBuffersTransferData[0] = CONTROLLER_FAINTANIMATION;
+    gBattleBuffersTransferData[1] = CONTROLLER_FAINTANIMATION;
+    gBattleBuffersTransferData[2] = CONTROLLER_FAINTANIMATION;
+    gBattleBuffersTransferData[3] = CONTROLLER_FAINTANIMATION;
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitPaletteFade(u8 a)
+void BtlController_EmitPaletteFade(u8 bufferId)
 {
-    gBattleBuffersTransferData[0] = 11;
-    gBattleBuffersTransferData[1] = 11;
-    gBattleBuffersTransferData[2] = 11;
-    gBattleBuffersTransferData[3] = 11;
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4);
+    gBattleBuffersTransferData[0] = CONTROLLER_PALETTEFADE;
+    gBattleBuffersTransferData[1] = CONTROLLER_PALETTEFADE;
+    gBattleBuffersTransferData[2] = CONTROLLER_PALETTEFADE;
+    gBattleBuffersTransferData[3] = CONTROLLER_PALETTEFADE;
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitSuccessBallThrowAnim(u8 a)
+void BtlController_EmitSuccessBallThrowAnim(u8 bufferId)
 {
-    gBattleBuffersTransferData[0] = 12;
-    gBattleBuffersTransferData[1] = 12;
-    gBattleBuffersTransferData[2] = 12;
-    gBattleBuffersTransferData[3] = 12;
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4);
+    gBattleBuffersTransferData[0] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    gBattleBuffersTransferData[1] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    gBattleBuffersTransferData[2] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    gBattleBuffersTransferData[3] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void BtlController_EmitBallThrowAnim(u8 a, u8 b)
+void BtlController_EmitBallThrowAnim(u8 bufferId, u8 caseId)
 {
-    gBattleBuffersTransferData[0] = 13;
-    gBattleBuffersTransferData[1] = b;
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2);
+    gBattleBuffersTransferData[0] = CONTROLLER_BALLTHROWANIM;
+    gBattleBuffersTransferData[1] = caseId;
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void BtlController_EmitPause(u8 a, u8 b, u8 *c)
+void BtlController_EmitPause(u8 bufferId, u8 toWait, void *data)
 {
-    int i;
-
-    gBattleBuffersTransferData[0] = 14;
-    gBattleBuffersTransferData[1] = b;
-    for (i = 0; i < b * 3; i++)
-        gBattleBuffersTransferData[2 + i] = *(c++);
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, b * 3 + 2);
-}
+    s32 i;
 
-void BtlController_EmitMoveAnimation(u8 a, u16 b, u8 c, u16 d, s32 e, u8 f, struct DisableStruct *g)
-{
-    gBattleBuffersTransferData[0] = 15;
-    gBattleBuffersTransferData[1] = b;
-    gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8;
-    gBattleBuffersTransferData[3] = c;
-    gBattleBuffersTransferData[4] = d;
-    gBattleBuffersTransferData[5] = (d & 0xFF00) >> 8;
-    gBattleBuffersTransferData[6] = e;
-    gBattleBuffersTransferData[7] = (e & 0x0000FF00) >> 8;
-    gBattleBuffersTransferData[8] = (e & 0x00FF0000) >> 16;
-    gBattleBuffersTransferData[9] = (e & 0xFF000000) >> 24;
-    gBattleBuffersTransferData[10] = f;
+    gBattleBuffersTransferData[0] = CONTROLLER_PAUSE;
+    gBattleBuffersTransferData[1] = toWait;
+    for (i = 0; i < toWait * 3; i++)
+        gBattleBuffersTransferData[2 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, toWait * 3 + 2);
+}
+
+void BtlController_EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr)
+{
+    gBattleBuffersTransferData[0] = CONTROLLER_MOVEANIMATION;
+    gBattleBuffersTransferData[1] = move;
+    gBattleBuffersTransferData[2] = (move & 0xFF00) >> 8;
+    gBattleBuffersTransferData[3] = turnOfMove;
+    gBattleBuffersTransferData[4] = movePower;
+    gBattleBuffersTransferData[5] = (movePower & 0xFF00) >> 8;
+    gBattleBuffersTransferData[6] = dmg;
+    gBattleBuffersTransferData[7] = (dmg & 0x0000FF00) >> 8;
+    gBattleBuffersTransferData[8] = (dmg & 0x00FF0000) >> 16;
+    gBattleBuffersTransferData[9] = (dmg & 0xFF000000) >> 24;
+    gBattleBuffersTransferData[10] = friendship;
     gBattleBuffersTransferData[11] = gMultiHitCounter;
-    if (AbilityBattleEffects(14, 0, 13, 0, 0) == 0 && AbilityBattleEffects(14, 0, 0x4D, 0, 0) == 0)
+    if (WEATHER_HAS_EFFECT2)
     {
         gBattleBuffersTransferData[12] = gBattleWeather;
         gBattleBuffersTransferData[13] = (gBattleWeather & 0xFF00) >> 8;
@@ -747,8 +758,8 @@ void BtlController_EmitMoveAnimation(u8 a, u16 b, u8 c, u16 d, s32 e, u8 f, stru
     }
     gBattleBuffersTransferData[14] = 0;
     gBattleBuffersTransferData[15] = 0;
-    memcpy(&gBattleBuffersTransferData[16], g, sizeof(*g));
-    PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 0x2C);
+    memcpy(&gBattleBuffersTransferData[16], disableStructPtr, sizeof(struct DisableStruct));
+    PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 16 + sizeof(struct DisableStruct));
 }
 
 void BtlController_EmitPrintString(u8 a, u16 stringID)
diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c
index 45f2c30c0..ee4b4b100 100644
--- a/src/battle_gfx_sfx_util.c
+++ b/src/battle_gfx_sfx_util.c
@@ -27,7 +27,7 @@ extern u8 gBattleBufferA[][0x200];
 extern u8 gActiveBattler;
 extern u8 gBattlersCount;
 extern u16 gBattlerPartyIndexes[];
-extern u8 gBanksBySide[];
+extern u8 gBattlerPositions[];
 extern u8 gBattlerSpriteIds[];
 extern u16 gUnknown_02024DE8;
 extern u8 gDoingBattleAnim;
@@ -466,7 +466,7 @@ void unref_sub_8031BA0(void)
         count = 4;
     }
     for (i = 0; i < count; i++)
-        LoadCompressedObjectPic(&gUnknown_0820A4B4[gBanksBySide[i]]);
+        LoadCompressedObjectPic(&gUnknown_0820A4B4[gBattlerPositions[i]]);
 }
 
 bool8 sub_8031C30(u8 a)
@@ -492,9 +492,9 @@ bool8 sub_8031C30(u8 a)
             else if (a == 3)
                 LoadCompressedObjectPic(&gUnknown_0820A484);
             else if (a == 4)
-                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBanksBySide[0]]);
+                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBattlerPositions[0]]);
             else if (a == 5)
-                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBanksBySide[1]]);
+                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBattlerPositions[1]]);
             else
                 retVal = TRUE;
         }
@@ -509,13 +509,13 @@ bool8 sub_8031C30(u8 a)
             else if (a == 5)
                 LoadCompressedObjectPic(&gUnknown_0820A49C[1]);
             else if (a == 6)
-                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBanksBySide[0]]);
+                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBattlerPositions[0]]);
             else if (a == 7)
-                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBanksBySide[1]]);
+                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBattlerPositions[1]]);
             else if (a == 8)
-                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBanksBySide[2]]);
+                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBattlerPositions[2]]);
             else if (a == 9)
-                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBanksBySide[3]]);
+                LoadCompressedObjectPic(&gUnknown_0820A4B4[gBattlerPositions[3]]);
             else
                 retVal = TRUE;
         }
@@ -566,7 +566,7 @@ u8 battle_load_something(u8 *pState, u8 *b)
         break;
     case 4:
         sub_8043F44(*b);
-        if (gBanksBySide[*b] <= 1)
+        if (gBattlerPositions[*b] <= 1)
             nullsub_11(gHealthboxSpriteIds[*b], 0);
         else
             nullsub_11(gHealthboxSpriteIds[*b], 1);
diff --git a/src/battle_interface.c b/src/battle_interface.c
index 992fcd7ae..1f08de03c 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -423,7 +423,7 @@ u8 *const gUnknown_0820A904[10] =
 extern u8 gDisplayedStringBattle[];
 extern u8 gBattlersCount;
 extern u16 gBattlerPartyIndexes[];
-extern u8 gBanksBySide[];
+extern u8 gBattlerPositions[];
 extern u8 gHealthboxSpriteIds[];
 
 extern u16 gBattleTypeFlags;
@@ -834,7 +834,7 @@ u8 battle_make_oam_normal_battle(u8 a)
     }
     //_08043B50
 
-    spriteId3 = CreateSpriteAtEnd(&gSpriteTemplates_820A56C[gBanksBySide[a]], 140, 60, 0);
+    spriteId3 = CreateSpriteAtEnd(&gSpriteTemplates_820A56C[gBattlerPositions[a]], 140, 60, 0);
     sprite = &gSprites[spriteId3];
     SetSubspriteTables(sprite, &gSubspriteTables_820A684[GetBattlerSide(a)]);
     sprite->subspriteMode = 2;
diff --git a/src/battle_main.c b/src/battle_main.c
index c0147d11d..721aa7f9f 100644
--- a/src/battle_main.c
+++ b/src/battle_main.c
@@ -9,6 +9,7 @@
 #include "gba/flash_internal.h"
 #include "battle.h"
 #include "battle_ai_script_commands.h"
+#include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
 #include "battle_setup.h"
@@ -32,7 +33,6 @@
 #include "pokemon.h"
 #include "random.h"
 #include "roamer.h"
-#include "rom3.h"
 #include "rom_8077ABC.h"
 #include "rom_8094928.h"
 #include "safari_zone.h"
@@ -83,7 +83,7 @@ extern u32 gBattleControllerExecFlags;
 extern u8 gBattlersCount;
 extern u16 gBattlerPartyIndexes[];
 extern u8 gCurrentActionFuncId;
-extern u8 gBanksByTurnOrder[];
+extern u8 gBattlerByTurnOrder[];
 extern u8 gBattlerSpriteIds[];
 extern u16 gCurrentMove;  // This is mis-named. It is a species, not a move ID.
 extern u8 gLastUsedAbility;
@@ -92,7 +92,7 @@ extern u8 gAbsentBattlerFlags;
 extern u8 gMultiHitCounter;
 extern u8 gActionForBanks[];
 extern u16 gUnknown_02024C2C[];
-extern u16 gLastUsedMove[];
+extern u16 gLastMoves[];
 extern u16 gLastLandedMoves[];
 extern u16 gLastHitByType[];
 extern u16 gUnknown_02024C4C[];
@@ -100,7 +100,7 @@ extern u16 gLockedMoves[];
 extern u16 gChosenMovesByBanks[];
 extern u32 gHitMarker;
 extern u8 gUnknown_02024C70[];
-extern u16 gSideAffecting[];
+extern u16 gSideStatuses[];
 extern u32 gStatuses3[];
 //extern u8 gDisableStructs[][0x1C];
 extern u16 gPauseCounterBattle;
@@ -208,7 +208,7 @@ void CB2_InitBattle(void)
 {
     if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
     {
-        sub_800B858();
+        HandleLinkBattleSetup();
         SetMainCallback2(sub_800F104);
         gBattleCommunication[0] = 0;
     }
@@ -3331,7 +3331,7 @@ void sub_8010874(void)
         MEMSET_ALT(&gDisableStructs[i], 0, 0x1C, j, r4);
         gDisableStructs[i].isFirstTurn= 2;
         gUnknown_02024C70[i] = 0;
-        gLastUsedMove[i] = 0;
+        gLastMoves[i] = 0;
         gLastLandedMoves[i] = 0;
         gLastHitByType[i] = 0;
         gUnknown_02024C4C[i] = 0;
@@ -3343,7 +3343,7 @@ void sub_8010874(void)
 
     for (i = 0; i < 2; i++)
     {
-        gSideAffecting[i] = 0;
+        gSideStatuses[i] = 0;
         MEMSET_ALT(&gSideTimers[i], 0, 12, j, r4);
     }
 
@@ -3401,7 +3401,7 @@ void sub_8010874(void)
     gBattleResults.unk2 = 0;
     gBattleResults.unk3 = 0;
     gBattleResults.unk4 = 0;
-    gBattleResults.unk5_0 = 0;
+    gBattleResults.playerMonWasDamaged = 0;
     gBattleResults.unk5_1 = 0;
     gBattleResults.lastOpponentSpecies = 0;
     gBattleResults.lastUsedMove = 0;
@@ -3435,23 +3435,23 @@ void SwitchInClearSetData(void)
         {
             if ((gBattleMons[i].status2 & STATUS2_ESCAPE_PREVENTION) && gDisableStructs[i].bankPreventingEscape == gActiveBattler)
                 gBattleMons[i].status2 &= ~STATUS2_ESCAPE_PREVENTION;
-            if ((gStatuses3[i] & STATUS3_ALWAYS_HITS) && gDisableStructs[i].bankWithSureHit == gActiveBattler)
+            if ((gStatuses3[i] & STATUS3_ALWAYS_HITS) && gDisableStructs[i].battlerWithSureHit == gActiveBattler)
             {
                 gStatuses3[i] &= ~STATUS3_ALWAYS_HITS;
-                gDisableStructs[i].bankWithSureHit = 0;
+                gDisableStructs[i].battlerWithSureHit = 0;
             }
         }
     }
     if (gBattleMoves[gCurrentMove].effect == EFFECT_BATON_PASS)
     {
         gBattleMons[gActiveBattler].status2 &= (STATUS2_CONFUSION | STATUS2_FOCUS_ENERGY | STATUS2_SUBSTITUTE | STATUS2_ESCAPE_PREVENTION | STATUS2_CURSED);
-        gStatuses3[gActiveBattler] &= (STATUS3_LEECHSEED_BANK | STATUS3_LEECHSEED | STATUS3_ALWAYS_HITS | STATUS3_PERISH_SONG | STATUS3_ROOTED | STATUS3_MUDSPORT | STATUS3_WATERSPORT);
+        gStatuses3[gActiveBattler] &= (STATUS3_LEECHSEED_BATTLER | STATUS3_LEECHSEED | STATUS3_ALWAYS_HITS | STATUS3_PERISH_SONG | STATUS3_ROOTED | STATUS3_MUDSPORT | STATUS3_WATERSPORT);
 
         for (i = 0; i < gBattlersCount; i++)
         {
             if (GetBattlerSide(gActiveBattler) != GetBattlerSide(i)
              && (gStatuses3[i] & STATUS3_ALWAYS_HITS) != 0
-             && (gDisableStructs[i].bankWithSureHit == gActiveBattler))
+             && (gDisableStructs[i].battlerWithSureHit == gActiveBattler))
             {
                 gStatuses3[i] &= ~STATUS3_ALWAYS_HITS;
                 gStatuses3[i] |= 0x10;
@@ -3480,13 +3480,13 @@ void SwitchInClearSetData(void)
     if (gBattleMoves[gCurrentMove].effect == EFFECT_BATON_PASS)
     {
         gDisableStructs[gActiveBattler].substituteHP = sp0.substituteHP;
-        gDisableStructs[gActiveBattler].bankWithSureHit = sp0.bankWithSureHit;
+        gDisableStructs[gActiveBattler].battlerWithSureHit = sp0.battlerWithSureHit;
         gDisableStructs[gActiveBattler].perishSongTimer1 = sp0.perishSongTimer1;
         gDisableStructs[gActiveBattler].perishSongTimer2 = sp0.perishSongTimer2;
     }
 
     gDisableStructs[gActiveBattler].isFirstTurn= 2;
-    gLastUsedMove[gActiveBattler] = 0;
+    gLastMoves[gActiveBattler] = 0;
     gLastLandedMoves[gActiveBattler] = 0;
     gLastHitByType[gActiveBattler] = 0;
     gUnknown_02024C4C[gActiveBattler] = 0;
@@ -3550,7 +3550,7 @@ void UndoEffectsAfterFainting(void)
     gProtectStructs[gActiveBattler].notFirstStrike = 0;
 
     gDisableStructs[gActiveBattler].isFirstTurn= 2;
-    gLastUsedMove[gActiveBattler] = 0;
+    gLastMoves[gActiveBattler] = 0;
     gLastLandedMoves[gActiveBattler] = 0;
     gLastHitByType[gActiveBattler] = 0;
     gUnknown_02024C4C[gActiveBattler] = 0;
@@ -3887,12 +3887,12 @@ void BattleBeginFirstTurn(void)
         if (ewram16058 == 0)
         {
             for (i = 0; i < gBattlersCount; i++)
-                gBanksByTurnOrder[i] = i;
+                gBattlerByTurnOrder[i] = i;
             for (i = 0; i < gBattlersCount - 1; i++)
             {
                 for (j = i + 1; j < gBattlersCount; j++)
                 {
-                    if (GetWhoStrikesFirst(gBanksByTurnOrder[i], gBanksByTurnOrder[j], 1) != 0)
+                    if (GetWhoStrikesFirst(gBattlerByTurnOrder[i], gBattlerByTurnOrder[j], 1) != 0)
                         SwapTurnOrder(i, j);
                 }
             }
@@ -3904,7 +3904,7 @@ void BattleBeginFirstTurn(void)
         }
         while (ewram16058 < gBattlersCount)
         {
-            if (AbilityBattleEffects(0, gBanksByTurnOrder[ewram16058], 0, 0, 0) != 0)
+            if (AbilityBattleEffects(0, gBattlerByTurnOrder[ewram16058], 0, 0, 0) != 0)
                 r9++;
             ewram16058++;
             if (r9 != 0)
@@ -3916,7 +3916,7 @@ void BattleBeginFirstTurn(void)
             return;
         while (ewram160F9 < gBattlersCount)
         {
-            if (ItemBattleEffects(0, gBanksByTurnOrder[ewram160F9], 0) != 0)
+            if (ItemBattleEffects(0, gBattlerByTurnOrder[ewram160F9], 0) != 0)
                 r9++;
             ewram160F9++;
             if (r9 != 0)
@@ -3983,7 +3983,7 @@ void BattleTurnPassed(void)
     TurnValuesCleanUp(1);
     if (gBattleOutcome == 0)
     {
-        if (UpdateTurnCounters() != 0)
+        if (DoFieldEndTurnEffects() != 0)
             return;
         if (TurnBasedEffects() != 0)
             return;
@@ -4484,9 +4484,9 @@ void SwapTurnOrder(u8 a, u8 b)
     gActionsByTurnOrder[a] = gActionsByTurnOrder[b];
     gActionsByTurnOrder[b] = temp;
 
-    temp = gBanksByTurnOrder[a];
-    gBanksByTurnOrder[a] = gBanksByTurnOrder[b];
-    gBanksByTurnOrder[b] = temp;
+    temp = gBattlerByTurnOrder[a];
+    gBattlerByTurnOrder[a] = gBattlerByTurnOrder[b];
+    gBattlerByTurnOrder[b] = temp;
 }
 
 // Determines which of the two given mons will strike first in a battle.
@@ -4547,7 +4547,7 @@ u8 GetWhoStrikesFirst(u8 bank1, u8 bank2, bool8 ignoreMovePriorities)
     if (heldItemEffect == HOLD_EFFECT_MACHO_BRACE)
         bank1AdjustedSpeed /= 2;
 
-    if (gBattleMons[bank1].status1 & STATUS_PARALYSIS)
+    if (gBattleMons[bank1].status1 & STATUS1_PARALYSIS)
         bank1AdjustedSpeed /= 4;
 
     if (heldItemEffect == HOLD_EFFECT_QUICK_CLAW && gRandomTurnNumber < (heldItemEffectParam * 0xFFFF) / 100)
@@ -4577,7 +4577,7 @@ u8 GetWhoStrikesFirst(u8 bank1, u8 bank2, bool8 ignoreMovePriorities)
     if (heldItemEffect == HOLD_EFFECT_MACHO_BRACE)
         bank2AdjustedSpeed /= 2;
 
-    if (gBattleMons[bank2].status1 & STATUS_PARALYSIS)
+    if (gBattleMons[bank2].status1 & STATUS1_PARALYSIS)
         bank2AdjustedSpeed /= 4;
 
     if (heldItemEffect == HOLD_EFFECT_QUICK_CLAW && gRandomTurnNumber < (heldItemEffectParam * 0xFFFF) / 100)
@@ -4644,7 +4644,7 @@ void SetActionsAndBanksTurnOrder(void)
         for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++)
         {
             gActionsByTurnOrder[var] = gActionForBanks[gActiveBattler];
-            gBanksByTurnOrder[var] = gActiveBattler;
+            gBattlerByTurnOrder[var] = gActiveBattler;
             var++;
         }
     }
@@ -4673,14 +4673,14 @@ void SetActionsAndBanksTurnOrder(void)
         if (var == 5)
         {
             gActionsByTurnOrder[0] = gActionForBanks[gActiveBattler];
-            gBanksByTurnOrder[0] = gActiveBattler;
+            gBattlerByTurnOrder[0] = gActiveBattler;
             var = 1;
             for (i = 0; i < gBattlersCount; i++)
             {
                 if (i != gActiveBattler)
                 {
                     gActionsByTurnOrder[var] = gActionForBanks[i];
-                    gBanksByTurnOrder[var] = i;
+                    gBattlerByTurnOrder[var] = i;
                     var++;
                 }
             }
@@ -4695,7 +4695,7 @@ void SetActionsAndBanksTurnOrder(void)
                 if (gActionForBanks[gActiveBattler] == B_ACTION_USE_ITEM || gActionForBanks[gActiveBattler] == B_ACTION_SWITCH)
                 {
                     gActionsByTurnOrder[var] = gActionForBanks[gActiveBattler];
-                    gBanksByTurnOrder[var] = gActiveBattler;
+                    gBattlerByTurnOrder[var] = gActiveBattler;
                     var++;
                 }
             }
@@ -4704,7 +4704,7 @@ void SetActionsAndBanksTurnOrder(void)
                 if (gActionForBanks[gActiveBattler] != B_ACTION_USE_ITEM && gActionForBanks[gActiveBattler] != B_ACTION_SWITCH)
                 {
                     gActionsByTurnOrder[var] = gActionForBanks[gActiveBattler];
-                    gBanksByTurnOrder[var] = gActiveBattler;
+                    gBattlerByTurnOrder[var] = gActiveBattler;
                     var++;
                 }
             }
@@ -4712,8 +4712,8 @@ void SetActionsAndBanksTurnOrder(void)
             {
                 for (j = i + 1; j < gBattlersCount; j++)
                 {
-                    u8 bank1 = gBanksByTurnOrder[i];
-                    u8 bank2 = gBanksByTurnOrder[j];
+                    u8 bank1 = gBattlerByTurnOrder[i];
+                    u8 bank2 = gBattlerByTurnOrder[j];
                     if (gActionsByTurnOrder[i] != B_ACTION_USE_ITEM
                         && gActionsByTurnOrder[j] != B_ACTION_USE_ITEM
                         && gActionsByTurnOrder[i] != B_ACTION_SWITCH
@@ -4789,7 +4789,7 @@ void CheckFocusPunch_ClearVarsBeforeTurnStarts(void)
             gActiveBattler = gBattlerAttacker = eFocusPunchBattler;
             eFocusPunchBattler++;
             if (gChosenMovesByBanks[gActiveBattler] == MOVE_FOCUS_PUNCH
-                && !(gBattleMons[gActiveBattler].status1 & STATUS_SLEEP)
+                && !(gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP)
                 && !(gDisableStructs[gBattlerAttacker].truantCounter)
                 && !(gProtectStructs[gActiveBattler].noValidMoves))
             {
@@ -4848,7 +4848,7 @@ void HandleEndTurn_BattleWon(void)
         gBattleTextBuff1[0] = gBattleOutcome;
         gBattlerAttacker = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
         gBattlescriptCurrInstr = BattleScript_LinkBattleWonOrLost;
-        gBattleOutcome &= ~(OUTCOME_LINK_BATTLE_RUN);
+        gBattleOutcome &= ~(B_OUTCOME_LINK_BATTLE_RAN);
     }
     else if (gBattleTypeFlags & (BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))
     {
@@ -4898,7 +4898,7 @@ void HandleEndTurn_BattleLost(void)
         gBattleTextBuff1[0] = gBattleOutcome;
         gBattlerAttacker = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
         gBattlescriptCurrInstr = BattleScript_LinkBattleWonOrLost;
-        gBattleOutcome &= ~(OUTCOME_LINK_BATTLE_RUN);
+        gBattleOutcome &= ~(B_OUTCOME_LINK_BATTLE_RAN);
     }
     else
     {
@@ -4985,7 +4985,7 @@ static void FreeResetData_ReturnToOvOrDoEvolutions(void)
     if (!gPaletteFade.active)
     {
         ResetSpriteData();
-        if (gLeveledUpInBattle == 0 || gBattleOutcome != BATTLE_WON)
+        if (gLeveledUpInBattle == 0 || gBattleOutcome != B_OUTCOME_WON)
         {
             gBattleMainFunc = ReturnFromBattleToOverworld;
             return;
@@ -5051,7 +5051,7 @@ static void ReturnFromBattleToOverworld(void)
     if (gBattleTypeFlags & BATTLE_TYPE_ROAMER)
     {
         UpdateRoamerHPStatus(&gEnemyParty[0]);
-        if (gBattleOutcome == BATTLE_WON || gBattleOutcome == BATTLE_CAUGHT)
+        if (gBattleOutcome == B_OUTCOME_WON || gBattleOutcome == B_OUTCOME_CAUGHT)
             SetRoamerInactive();
     }
 
@@ -5085,7 +5085,7 @@ void HandleAction_UseMove(void)
     u8 side;
     u8 var = 4;
 
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
 
     if (ewram160A6 & gBitTable[gBattlerAttacker])
     {
@@ -5169,9 +5169,9 @@ void HandleAction_UseMove(void)
             if (side != GetBattlerSide(gActiveBattler)
                 && ewram16010arr(gBattlerAttacker) != gActiveBattler
                 && gBattleMons[gActiveBattler].ability == ABILITY_LIGHTNING_ROD
-                && BankGetTurnOrder(gActiveBattler) < var)
+                && GetBattlerTurnOrderNum(gActiveBattler) < var)
             {
-                var = BankGetTurnOrder(gActiveBattler);
+                var = GetBattlerTurnOrderNum(gActiveBattler);
             }
         }
         if (var == 4)
@@ -5214,7 +5214,7 @@ void HandleAction_UseMove(void)
         }
         else
         {
-            gActiveBattler = gBanksByTurnOrder[var];
+            gActiveBattler = gBattlerByTurnOrder[var];
             RecordAbilityBattle(gActiveBattler, gBattleMons[gActiveBattler].ability);
             gSpecialStatuses[gActiveBattler].lightningRodRedirected = 1;
             gBattlerTarget = gActiveBattler;
@@ -5268,7 +5268,7 @@ void HandleAction_UseMove(void)
 
 void HandleAction_Switch(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
     gActionSelectionCursor[gBattlerAttacker] = 0;
@@ -5286,7 +5286,7 @@ void HandleAction_Switch(void)
 
 void HandleAction_UseItem(void)
 {
-    gBattlerAttacker = gBattlerTarget = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerTarget = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
     gDisableStructs[gBattlerAttacker].furyCutterCounter = 0;
@@ -5409,7 +5409,7 @@ bool8 TryRunFromBattle(u8 bank)
     if (effect)
     {
         gCurrentTurnActionNumber = gBattlersCount;
-        gBattleOutcome = BATTLE_RAN;
+        gBattleOutcome = B_OUTCOME_RAN;
     }
 
     return effect;
@@ -5417,7 +5417,7 @@ bool8 TryRunFromBattle(u8 bank)
 
 void HandleAction_Run(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
 
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
     {
@@ -5428,16 +5428,16 @@ void HandleAction_Run(void)
             if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
             {
                 if (gActionForBanks[gActiveBattler] == B_ACTION_RUN)
-                    gBattleOutcome |= BATTLE_LOST;
+                    gBattleOutcome |= B_OUTCOME_LOST;
             }
             else
             {
                 if (gActionForBanks[gActiveBattler] == B_ACTION_RUN)
-                    gBattleOutcome |= BATTLE_WON;
+                    gBattleOutcome |= B_OUTCOME_WON;
             }
         }
 
-        gBattleOutcome |= OUTCOME_LINK_BATTLE_RUN;
+        gBattleOutcome |= B_OUTCOME_LINK_BATTLE_RAN;
     }
     else
     {
@@ -5462,7 +5462,7 @@ void HandleAction_Run(void)
             else
             {
                 gCurrentTurnActionNumber = gBattlersCount;
-                gBattleOutcome = BATTLE_POKE_FLED;
+                gBattleOutcome = B_OUTCOME_MON_FLED;
             }
         }
     }
@@ -5470,7 +5470,7 @@ void HandleAction_Run(void)
 
 void HandleAction_WatchesCarefully(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
     gBattlescriptCurrInstr = gBattlescriptsForSafariActions[0];
@@ -5479,7 +5479,7 @@ void HandleAction_WatchesCarefully(void)
 
 void HandleAction_SafariZoneBallThrow(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
     gNumSafariBalls--;
@@ -5490,7 +5490,7 @@ void HandleAction_SafariZoneBallThrow(void)
 
 void HandleAction_ThrowPokeblock(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
     gBattleCommunication[MULTISTRING_CHOOSER] = gBattleBufferB[gBattlerAttacker][1] - 1;
@@ -5512,7 +5512,7 @@ void HandleAction_ThrowPokeblock(void)
 
 void HandleAction_GoNear(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
 
@@ -5539,15 +5539,15 @@ void HandleAction_GoNear(void)
 
 void HandleAction_SafriZoneRun(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     PlaySE(SE_NIGERU);
     gCurrentTurnActionNumber = gBattlersCount;
-    gBattleOutcome = BATTLE_RAN;
+    gBattleOutcome = B_OUTCOME_RAN;
 }
 
 void HandleAction_Action9(void)
 {
-    gBattlerAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber];
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
 
@@ -5575,7 +5575,7 @@ void HandleAction_NothingIsFainted(void)
                     | HITMARKER_NO_PPDEDUCT | HITMARKER_IGNORE_SAFEGUARD | HITMARKER_IGNORE_ON_AIR
                     | HITMARKER_IGNORE_UNDERGROUND | HITMARKER_IGNORE_UNDERWATER | HITMARKER_x100000
                     | HITMARKER_OBEYS | HITMARKER_x10 | HITMARKER_SYNCHRONISE_EFFECT
-                    | HITMARKER_x8000000 | HITMARKER_x4000000);
+                    | HITMARKER_CHARGING | HITMARKER_x4000000);
 }
 
 void HandleAction_ActionFinished(void)
@@ -5587,7 +5587,7 @@ void HandleAction_ActionFinished(void)
                     | HITMARKER_NO_PPDEDUCT | HITMARKER_IGNORE_SAFEGUARD | HITMARKER_IGNORE_ON_AIR
                     | HITMARKER_IGNORE_UNDERGROUND | HITMARKER_IGNORE_UNDERWATER | HITMARKER_x100000
                     | HITMARKER_OBEYS | HITMARKER_x10 | HITMARKER_SYNCHRONISE_EFFECT
-                    | HITMARKER_x8000000 | HITMARKER_x4000000);
+                    | HITMARKER_CHARGING | HITMARKER_x4000000);
 
     gBattleMoveDamage = 0;
     ewram16002 = 0;
diff --git a/src/battle_message.c b/src/battle_message.c
index b218c2b8d..ce1e63edd 100644
--- a/src/battle_message.c
+++ b/src/battle_message.c
@@ -379,7 +379,7 @@ void BufferStringBattle(u16 stringID)
             gBattleTextBuff1[0] &= ~(0x80);
             if (GetBattlerSide(gActiveBattler) == 1 && gBattleTextBuff1[0] != 3)
                 gBattleTextBuff1[0] ^= 3;
-            if (gBattleTextBuff1[0] == BATTLE_LOST || gBattleTextBuff1[0] == BATTLE_DREW)
+            if (gBattleTextBuff1[0] == B_OUTCOME_LOST || gBattleTextBuff1[0] == B_OUTCOME_DREW)
                 stringPtr = BattleText_GotAwaySafely;
             else
             {
@@ -397,13 +397,13 @@ void BufferStringBattle(u16 stringID)
             {
                 switch (gBattleTextBuff1[0])
                 {
-                case BATTLE_WON:
+                case B_OUTCOME_WON:
                     stringPtr = BattleText_PlayerDefeatedTrainers;
                     break;
-                case BATTLE_LOST:
+                case B_OUTCOME_LOST:
                     stringPtr = BattleText_PlayerLostTrainers;
                     break;
-                case BATTLE_DREW:
+                case B_OUTCOME_DREW:
                     stringPtr = BattleText_PlayerTiedTrainers;
                     break;
                 }
@@ -412,13 +412,13 @@ void BufferStringBattle(u16 stringID)
             {
                 switch (gBattleTextBuff1[0])
                 {
-                case BATTLE_WON:
+                case B_OUTCOME_WON:
                     stringPtr = BattleText_PlayerDefeatedTrainer;
                     break;
-                case BATTLE_LOST:
+                case B_OUTCOME_LOST:
                     stringPtr = BattleText_PlayerLostTrainer;
                     break;
-                case BATTLE_DREW:
+                case B_OUTCOME_DREW:
                     stringPtr = BattleText_PlayerTiedTrainer;
                     break;
                 }
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index 577a8149a..32887efc1 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -12,7 +12,7 @@
 #include "data2.h"
 #include "constants/hold_effects.h"
 #include "random.h"
-#include "rom3.h"
+#include "battle_controllers.h"
 #include "constants/species.h"
 #include "pokemon.h"
 #include "text.h"
@@ -32,69 +32,6 @@
 
 #define RET_VALUE_LEVELLED_UP   11
 
-enum
-{
-    CONTROLLER_GETMONDATA,
-    CONTROLLER_GETRAWMONDATA,
-    CONTROLLER_SETMONDATA,
-    CONTROLLER_SETRAWMONDATA,
-    CONTROLLER_LOADMONSPRITE,
-    CONTROLLER_SWITCHINANIM,
-    CONTROLLER_RETURNMONTOBALL,
-    CONTROLLER_DRAWTRAINERPIC,
-    CONTROLLER_TRAINERSLIDE,
-    CONTROLLER_TRAINERSLIDEBACK,
-    CONTROLLER_FAINTANIMATION,
-    CONTROLLER_PALETTEFADE,
-    CONTROLLER_SUCCESSBALLTHROWANIM,
-    CONTROLLER_BALLTHROWANIM,
-    CONTROLLER_PAUSE,
-    CONTROLLER_MOVEANIMATION,
-    CONTROLLER_PRINTSTRING,
-    CONTROLLER_PRINTSTRINGPLAYERONLY,
-    CONTROLLER_CHOOSEACTION,
-    CONTROLLER_UNKNOWNYESNOBOX,
-    CONTROLLER_CHOOSEMOVE,
-    CONTROLLER_OPENBAG,
-    CONTROLLER_CHOOSEPOKEMON,
-    CONTROLLER_23,
-    CONTROLLER_HEALTHBARUPDATE,
-    CONTROLLER_EXPUPDATE,
-    CONTROLLER_STATUSICONUPDATE,
-    CONTROLLER_STATUSANIMATION,
-    CONTROLLER_STATUSXOR,
-    CONTROLLER_DATATRANSFER,
-    CONTROLLER_DMA3TRANSFER,
-    CONTROLLER_31,
-    CONTROLLER_32,
-    CONTROLLER_TWORETURNVALUES,
-    CONTROLLER_CHOSENMONRETURNVALUE,
-    CONTROLLER_ONERETURNVALUE,
-    CONTROLLER_ONERETURNVALUE_DUPLICATE,
-    CONTROLLER_37,
-    CONTROLLER_38,
-    CONTROLLER_39,
-    CONTROLLER_40,
-    CONTROLLER_HITANIMATION,
-    CONTROLLER_42,
-    CONTROLLER_EFFECTIVENESSSOUND,
-    CONTROLLER_PLAYFANFAREORBGM,
-    CONTROLLER_FAINTINGCRY,
-    CONTROLLER_INTROSLIDE,
-    CONTROLLER_INTROTRAINERBALLTHROW,
-    CONTROLLER_DRAWPARTYSTATUSSUMMARY,
-    CONTROLLER_49,
-    CONTROLLER_50,
-    CONTROLLER_SPRITEINVISIBILITY,
-    CONTROLLER_BATTLEANIMATION,
-    CONTROLLER_LINKSTANDBYMSG,
-    CONTROLLER_RESETACTIONMOVESELECTION,
-    CONTROLLER_55,
-    /*new controllers should go here*/
-    CONTROLLER_TERMINATOR_NOP,
-    CONTROLLER_CMDS_COUNT
-};
-
 //extern needed variables
 extern u8 gUnknown_02023A14_50;
 extern u8 gCritMultiplier;
@@ -108,7 +45,7 @@ extern u8 gActiveBattler;
 extern u32 gBattleControllerExecFlags;
 extern u8 gBattlersCount;
 extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
-extern u8 gBanksByTurnOrder[MAX_BATTLERS_COUNT];
+extern u8 gBattlerByTurnOrder[MAX_BATTLERS_COUNT];
 extern u8 gActionsByTurnOrder[MAX_BATTLERS_COUNT];
 extern u16 gCurrentMove;
 extern u8 gLastUsedAbility;
@@ -117,10 +54,10 @@ extern u8 gPotentialItemEffectBattler;
 extern u8 gEffectBattler;
 extern u8 gAbsentBattlerFlags;
 extern u8 gMultiHitCounter;
-extern u16 gLastUsedMove[4];
+extern u16 gLastMoves[4];
 extern u16 gLockedMoves[4];
 extern u16 gChosenMovesByBanks[4];
-extern u16 gSideAffecting[2];
+extern u16 gSideStatuses[2];
 extern u16 gPauseCounterBattle;
 extern u16 gPaydayMoney;
 extern u16 gRandomTurnNumber;
@@ -144,7 +81,7 @@ extern u16 gLastUsedItem;
 extern u16 gBattleMovePower;
 extern s32 gHpDealt;
 extern s32 gTakenDmg[MAX_BATTLERS_COUNT];
-extern u8 gTakenDmgBanks[MAX_BATTLERS_COUNT];
+extern u8 gTakenDmgByBattler[MAX_BATTLERS_COUNT];
 extern const u16 gMissStringIds[];
 extern u8 gSentPokesToOpponent[2];
 extern u8 gBank1;
@@ -188,13 +125,13 @@ void CancelMultiTurnMoves(u8 bank);
 void BattleScriptPush(const u8* BS_ptr);
 void BattleScriptPushCursor(void);
 void RecordAbilityBattle(u8 bank, u8 ability);
-void RecordItemBattle(u8 bank, u8 holdEffect);
+void RecordItemEffectBattle(u8 bank, u8 holdEffect);
 static bool8 IsTwoTurnsMove(u16 move);
 static void TrySetDestinyBondToHappen(void);
 static void CheckWonderGuardAndLevitate(void);
 u8 GetBattlerPosition(u8 bank);
 u8 GetBattlerSide(u8 bank);
-u8 GetBattleBank(u8 bankValue);
+u8 GetBattlerForBattleScript(u8 bankValue);
 s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *defender, u32 move, u16 a4, u16 powerOverride, u8 typeOverride, u8 bank_atk, u8 bank_def);
 static u8 AttacksThisTurn(u8 bank, u16 move); //Note: returns 1 if it's a charging turn, otherwise 2
 void UndoEffectsAfterFainting(void);
@@ -294,7 +231,7 @@ extern u8 BattleScript_PrintPayDayMoneyString[]; //bs payday money give
 extern u8 BattleScript_FaintAttacker[];
 extern u8 BattleScript_FaintTarget[];
 extern u8 BattleScript_DestinyBondTakesLife[];
-extern u8 BattleScript_SelectingImprisionedMoveInPalace[];
+extern u8 BattleScript_GrudgeTakesPp[];
 
 // read via orr
 #define BSScriptRead32(ptr) ((ptr)[0] | (ptr)[1] << 8 | (ptr)[2] << 16 | (ptr)[3] << 24)
@@ -306,7 +243,7 @@ extern u8 BattleScript_SelectingImprisionedMoveInPalace[];
 #define BS2ScriptRead16(ptr) ((ptr)[0] + ((ptr)[1] << 8))
 #define BS2ScriptReadPtr(ptr) ((void *)BS2ScriptRead32(ptr))
 
-#define TARGET_PROTECT_AFFECTED ((gProtectStructs[gBattlerTarget].protected && gBattleMoves[gCurrentMove].flags & F_AFFECTED_BY_PROTECT))
+#define DEFENDER_IS_PROTECTED ((gProtectStructs[gBattlerTarget].protected && gBattleMoves[gCurrentMove].flags & F_AFFECTED_BY_PROTECT))
 
 //array entries for battle communication
 #define MOVE_EFFECT_BYTE    0x3
@@ -315,9 +252,9 @@ extern u8 BattleScript_SelectingImprisionedMoveInPalace[];
 
 #define TARGET_SELECTED         0x0
 #define TARGET_DEPENDS          0x1
-#define TARGET_BOTH             0x8
-#define TARGET_FOES_AND_ALLY    0x20
-#define TARGET_OPPONENTS_FIELD  0x40
+#define MOVE_TARGET_BOTH             0x8
+#define MOVE_TARGET_FOES_AND_ALLY    0x20
+#define MOVE_TARGET_OPPONENTS_FIELD  0x40
 
 #define TYPE_FORESIGHT  0xFE
 #define TYPE_ENDTABLE   0xFF
@@ -444,11 +381,11 @@ static void atk5A_yesnoboxlearnmove(void);
 static void atk5B_yesnoboxstoplearningmove(void);
 static void atk5C_hitanimation(void);
 static void atk5D_getmoneyreward(void);
-static void atk5E_8025A70(void);
-static void atk5F_8025B24(void);
+static void atk5E(void);
+static void atk5F_swapattackerwithtarget(void);
 static void atk60_incrementgamestat(void);
 static void atk61_drawpartystatussummary(void);
-static void atk62_08025C6C(void);
+static void atk62_hidepartystatussummary(void);
 static void atk63_jumptorandomattack(void);
 static void atk64_statusanimation(void);
 static void atk65_status2animation(void);
@@ -570,10 +507,10 @@ static void atkD7_setyawn(void);
 static void atkD8_setdamagetohealthdifference(void);
 static void atkD9_scaledamagebyhealthratio(void);
 static void atkDA_tryswapabilities(void);
-static void atkDB_tryimprision(void);
+static void atkDB_tryimprison(void);
 static void atkDC_trysetgrudge(void);
 static void atkDD_weightdamagecalculation(void);
-static void atkDE_asistattackselect(void);
+static void atkDE_assistattackselect(void);
 static void atkDF_trysetmagiccoat(void);
 static void atkE0_trysetsnatch(void);
 static void atkE1_trygetintimidatetarget(void);
@@ -588,7 +525,7 @@ static void atkE9_setweatherballtype(void);
 static void atkEA_tryrecycleitem(void);
 static void atkEB_settypetoterrain(void);
 static void atkEC_pursuitrelated(void);
-static void atkED_snatchsetbanks(void);
+static void atkEF_snatchsetbattlers(void);
 static void atkEE_removelightscreenreflect(void);
 void atkEF_handleballthrow(void);
 static void atkF0_givecaughtmon(void);
@@ -696,11 +633,11 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atk5B_yesnoboxstoplearningmove,
     atk5C_hitanimation,
     atk5D_getmoneyreward,
-    atk5E_8025A70,
-    atk5F_8025B24,
+    atk5E,
+    atk5F_swapattackerwithtarget,
     atk60_incrementgamestat,
     atk61_drawpartystatussummary,
-    atk62_08025C6C,
+    atk62_hidepartystatussummary,
     atk63_jumptorandomattack,
     atk64_statusanimation,
     atk65_status2animation,
@@ -821,10 +758,10 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atkD8_setdamagetohealthdifference,
     atkD9_scaledamagebyhealthratio,
     atkDA_tryswapabilities,
-    atkDB_tryimprision,
+    atkDB_tryimprison,
     atkDC_trysetgrudge,
     atkDD_weightdamagecalculation,
-    atkDE_asistattackselect,
+    atkDE_assistattackselect,
     atkDF_trysetmagiccoat,
     atkE0_trysetsnatch,
     atkE1_trygetintimidatetarget,
@@ -839,7 +776,7 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atkEA_tryrecycleitem,
     atkEB_settypetoterrain,
     atkEC_pursuitrelated,
-    atkED_snatchsetbanks,
+    atkEF_snatchsetbattlers,
     atkEE_removelightscreenreflect,
     atkEF_handleballthrow,
     atkF0_givecaughtmon,
@@ -881,12 +818,12 @@ static const u16 sCriticalHitChance[] = {16, 8, 4, 3, 2};
 static const u32 sStatusFlagsForMoveEffects[] =
 {
     0x00000000,
-    STATUS_SLEEP,
-    STATUS_POISON,
-    STATUS_BURN,
-    STATUS_FREEZE,
-    STATUS_PARALYSIS,
-    STATUS_TOXIC_POISON,
+    STATUS1_SLEEP,
+    STATUS1_POISON,
+    STATUS1_BURN,
+    STATUS1_FREEZE,
+    STATUS1_PARALYSIS,
+    STATUS1_TOXIC_POISON,
     STATUS2_CONFUSION,
     STATUS2_FLINCHED,
     0x00000000,
@@ -1001,26 +938,26 @@ static const u16 sProtectSuccessRates[] = {0xFFFF, 0x7FFF, 0x3FFF, 0x1FFF};
 
 static const u16 sMovesForbiddenToCopy[] =
 {
-     MOVE_METRONOME,
-     MOVE_STRUGGLE,
-     MOVE_SKETCH,
-     MOVE_MIMIC,
-     MIMIC_FORBIDDEN_END,
-     MOVE_COUNTER,
-     MOVE_MIRROR_COAT,
-     MOVE_PROTECT,
-     MOVE_DETECT,
-     MOVE_ENDURE,
-     MOVE_DESTINY_BOND,
-     MOVE_SLEEP_TALK,
-     MOVE_THIEF,
-     MOVE_FOLLOW_ME,
-     MOVE_SNATCH,
-     MOVE_HELPING_HAND,
-     MOVE_COVET,
-     MOVE_TRICK,
-     MOVE_FOCUS_PUNCH,
-     METRONOME_FORBIDDEN_END
+    MOVE_METRONOME,
+    MOVE_STRUGGLE,
+    MOVE_SKETCH,
+    MOVE_MIMIC,
+    MIMIC_FORBIDDEN_END,
+    MOVE_COUNTER,
+    MOVE_MIRROR_COAT,
+    MOVE_PROTECT,
+    MOVE_DETECT,
+    MOVE_ENDURE,
+    MOVE_DESTINY_BOND,
+    MOVE_SLEEP_TALK,
+    MOVE_THIEF,
+    MOVE_FOLLOW_ME,
+    MOVE_SNATCH,
+    MOVE_HELPING_HAND,
+    MOVE_COVET,
+    MOVE_TRICK,
+    MOVE_FOCUS_PUNCH,
+    METRONOME_FORBIDDEN_END
 };
 
 static const u8 sFlailHpScaleToPowerTable[] = //reversal+flail HP thresholds to power
@@ -1111,7 +1048,7 @@ static void atk00_attackcanceler(void)
         return;
     if (AbilityBattleEffects(ABILITYEFFECT_MOVES_BLOCK, gBattlerTarget, 0, 0, 0))
         return;
-    if (!gBattleMons[gBattlerAttacker].pp[gCurrMovePos] && gCurrentMove != MOVE_STRUGGLE && !(gHitMarker & 0x800200)
+    if (!gBattleMons[gBattlerAttacker].pp[gCurrMovePos] && gCurrentMove != MOVE_STRUGGLE && !(gHitMarker & (HITMARKER_x800000 | HITMARKER_NO_ATTACKSTRING))
      && !(gBattleMons[gBattlerAttacker].status2 & STATUS2_MULTIPLETURNS))
     {
         gBattlescriptCurrInstr = BattleScript_NoPPForMove;
@@ -1150,11 +1087,11 @@ static void atk00_attackcanceler(void)
 
     for (i = 0; i < gBattlersCount; i++)
     {
-        if ((gProtectStructs[gBanksByTurnOrder[i]].stealMove) && gBattleMoves[gCurrentMove].flags & F_AFFECTED_BY_SNATCH)
+        if ((gProtectStructs[gBattlerByTurnOrder[i]].stealMove) && gBattleMoves[gCurrentMove].flags & F_AFFECTED_BY_SNATCH)
         {
-            PressurePPLose(gBattlerAttacker, gBanksByTurnOrder[i], MOVE_SNATCH);
-            gProtectStructs[gBanksByTurnOrder[i]].stealMove = 0;
-            gBattleStruct->scriptingActive = gBanksByTurnOrder[i];
+            PressurePPLose(gBattlerAttacker, gBattlerByTurnOrder[i], MOVE_SNATCH);
+            gProtectStructs[gBattlerByTurnOrder[i]].stealMove = 0;
+            gBattleStruct->scriptingActive = gBattlerByTurnOrder[i];
             BattleScriptPushCursor();
             gBattlescriptCurrInstr = BattleScript_SnatchedMove;
             return;
@@ -1169,8 +1106,8 @@ static void atk00_attackcanceler(void)
         gBattlescriptCurrInstr = BattleScript_TookAttack;
         RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
-    else if (TARGET_PROTECT_AFFECTED
-     && (gCurrentMove != MOVE_CURSE || (gBattleMons[gBattlerAttacker].type1 == TYPE_GHOST || gBattleMons[gBattlerAttacker].type2 == TYPE_GHOST))
+    else if (DEFENDER_IS_PROTECTED
+     && (gCurrentMove != MOVE_CURSE || IS_BATTLER_OF_TYPE(gBattlerAttacker, TYPE_GHOST))
      && ((!IsTwoTurnsMove(gCurrentMove) || (gBattleMons[gBattlerAttacker].status2 & STATUS2_MULTIPLETURNS))))
     {
         CancelMultiTurnMoves(gBattlerAttacker);
@@ -1206,7 +1143,7 @@ static void JumpIfMoveFailed(u8 adder, u16 move)
 
 static void atk40_jumpifaffectedbyprotect(void)
 {
-    if (TARGET_PROTECT_AFFECTED)
+    if (DEFENDER_IS_PROTECTED)
     {
         gMoveResultFlags |= MOVE_RESULT_MISSED;
         JumpIfMoveFailed(5, 0);
@@ -1221,7 +1158,7 @@ static void atk40_jumpifaffectedbyprotect(void)
 static bool8 JumpIfMoveAffectedByProtect(u16 move)
 {
     bool8 affected = FALSE;
-    if (TARGET_PROTECT_AFFECTED)
+    if (DEFENDER_IS_PROTECTED)
     {
         gMoveResultFlags |= MOVE_RESULT_MISSED;
         JumpIfMoveFailed(7, move);
@@ -1233,7 +1170,7 @@ static bool8 JumpIfMoveAffectedByProtect(u16 move)
 
 static bool8 AccuracyCalcHelper(u16 move)
 {
-    if (gStatuses3[gBattlerTarget] & STATUS3_ALWAYS_HITS && gDisableStructs[gBattlerTarget].bankWithSureHit == gBattlerAttacker)
+    if (gStatuses3[gBattlerTarget] & STATUS3_ALWAYS_HITS && gDisableStructs[gBattlerTarget].battlerWithSureHit == gBattlerAttacker)
     {
         JumpIfMoveFailed(7, move);
         return TRUE;
@@ -1282,7 +1219,7 @@ static void atk01_accuracycheck(void)
 
     if (move == 0xFFFE || move == 0xFFFF)
     {
-        if (gStatuses3[gBattlerTarget] & STATUS3_ALWAYS_HITS && move == 0xFFFF && gDisableStructs[gBattlerTarget].bankWithSureHit == gBattlerAttacker)
+        if (gStatuses3[gBattlerTarget] & STATUS3_ALWAYS_HITS && move == 0xFFFF && gDisableStructs[gBattlerTarget].battlerWithSureHit == gBattlerAttacker)
             gBattlescriptCurrInstr += 7;
         else if (gStatuses3[gBattlerTarget] & (STATUS3_ON_AIR | STATUS3_UNDERGROUND | STATUS3_UNDERWATER))
             gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1);
@@ -1391,11 +1328,11 @@ static void atk03_ppreduce(void)
     {
         switch (gBattleMoves[gCurrentMove].target)
         {
-        case TARGET_FOES_AND_ALLY:
+        case MOVE_TARGET_FOES_AND_ALLY:
             ppToDeduct += AbilityBattleEffects(ABILITYEFFECT_COUNT_ON_FIELD, gBattlerAttacker, ABILITY_PRESSURE, 0, 0);
             break;
-        case TARGET_BOTH:
-        case TARGET_OPPONENTS_FIELD:
+        case MOVE_TARGET_BOTH:
+        case MOVE_TARGET_OPPONENTS_FIELD:
             ppToDeduct += AbilityBattleEffects(ABILITYEFFECT_COUNT_OTHER_SIZE, gBattlerAttacker, ABILITY_PRESSURE, 0, 0);
             break;
         default:
@@ -1415,7 +1352,7 @@ static void atk03_ppreduce(void)
             gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = 0;
 
         if (!(gBattleMons[gBattlerAttacker].status2 & STATUS2_TRANSFORMED)
-            && !((gDisableStructs[gBattlerAttacker].unk18_b) & gBitTable[gCurrMovePos]))
+            && !((gDisableStructs[gBattlerAttacker].mimickedMoves) & gBitTable[gCurrMovePos]))
         {
             gActiveBattler = gBattlerAttacker;
             BtlController_EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + gCurrMovePos, 0, 1, &gBattleMons[gBattlerAttacker].pp[gCurrMovePos]);
@@ -1450,8 +1387,8 @@ static void atk04_critcalc(void)
                 + 2 * (holdEffect == HOLD_EFFECT_LUCKY_PUNCH && gBattleMons[gBattlerAttacker].species == SPECIES_CHANSEY)
                 + 2 * (holdEffect == HOLD_EFFECT_STICK && gBattleMons[gBattlerAttacker].species == SPECIES_FARFETCHD);
 
-    if (critChance > 4)
-        critChance = 4;
+    if (critChance >= ARRAY_COUNT(sCriticalHitChance))
+        critChance = ARRAY_COUNT(sCriticalHitChance) - 1;
 
     if ((gBattleMons[gBattlerTarget].ability != ABILITY_BATTLE_ARMOR && gBattleMons[gBattlerTarget].ability != ABILITY_SHELL_ARMOR)
      && !(gStatuses3[gBattlerAttacker] & STATUS3_CANT_SCORE_A_CRIT)
@@ -1466,9 +1403,9 @@ static void atk04_critcalc(void)
 
 static void atk05_damagecalc(void)
 {
-    u16 side_hword = gSideAffecting[GetBattlerPosition(gBattlerTarget) & 1];
+    u16 sideStatus = gSideStatuses[GET_BATTLER_SIDE(gBattlerTarget)];
     gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[gBattlerAttacker], &gBattleMons[gBattlerTarget], gCurrentMove,
-                                            side_hword, gDynamicBasePower,
+                                            sideStatus, gDynamicBasePower,
                                             gBattleStruct->dynamicMoveType, gBattlerAttacker, gBattlerTarget);
     gBattleMoveDamage = gBattleMoveDamage * gCritMultiplier * gBattleStruct->dmgMultiplier;
 
@@ -1480,18 +1417,18 @@ static void atk05_damagecalc(void)
     gBattlescriptCurrInstr++;
 }
 
-void AI_CalcDmg(u8 BankAtk, u8 BankDef)
+void AI_CalcDmg(u8 attacker, u8 defender)
 {
-    u16 side_hword = gSideAffecting[GetBattlerPosition(BankDef) & 1];
-    gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[BankAtk], &gBattleMons[BankDef], gCurrentMove,
-                                            side_hword, gDynamicBasePower,
-                                            gBattleStruct->dynamicMoveType, BankAtk, BankDef);
+    u16 sideStatus = gSideStatuses[GET_BATTLER_SIDE(defender)];
+    gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[attacker], &gBattleMons[defender], gCurrentMove,
+                                            sideStatus, gDynamicBasePower,
+                                            gBattleStruct->dynamicMoveType, attacker, defender);
     gDynamicBasePower = 0;
     gBattleMoveDamage = gBattleMoveDamage * gCritMultiplier * gBattleStruct->dmgMultiplier;
 
-    if (gStatuses3[BankAtk] & STATUS3_CHARGED_UP && gBattleMoves[gCurrentMove].type == TYPE_ELECTRIC)
+    if (gStatuses3[attacker] & STATUS3_CHARGED_UP && gBattleMoves[gCurrentMove].type == TYPE_ELECTRIC)
         gBattleMoveDamage *= 2;
-    if (gProtectStructs[BankAtk].helpingHand)
+    if (gProtectStructs[attacker].helpingHand)
         gBattleMoveDamage = gBattleMoveDamage * 15 / 10;
 }
 
@@ -1503,12 +1440,12 @@ static void ModulateDmgByType(u8 multiplier)
 
     switch (multiplier)
     {
-    case 0: //no effect
+    case TYPE_MUL_NO_EFFECT:
         gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
         gMoveResultFlags &= ~MOVE_RESULT_NOT_VERY_EFFECTIVE;
         gMoveResultFlags &= ~MOVE_RESULT_SUPER_EFFECTIVE;
         break;
-    case 5: //not very effecting
+    case TYPE_MUL_NOT_EFFECTIVE:
         if (gBattleMoves[gCurrentMove].power && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
         {
             if (gMoveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE)
@@ -1517,7 +1454,7 @@ static void ModulateDmgByType(u8 multiplier)
                 gMoveResultFlags |= MOVE_RESULT_NOT_VERY_EFFECTIVE;
         }
         break;
-    case 20: //super effective
+    case TYPE_MUL_SUPER_EFFECTIVE:
         if (gBattleMoves[gCurrentMove].power && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
         {
             if (gMoveResultFlags & MOVE_RESULT_NOT_VERY_EFFECTIVE)
@@ -1532,28 +1469,28 @@ static void ModulateDmgByType(u8 multiplier)
 static void atk06_typecalc(void)
 {
     int i = 0;
-    u8 move_type;
+    u8 moveType;
     if (gCurrentMove != MOVE_STRUGGLE)
     {
         if (gBattleStruct->dynamicMoveType)
-            move_type = gBattleStruct->dynamicMoveType & 0x3F;
+            moveType = gBattleStruct->dynamicMoveType & 0x3F;
         else
-            move_type = gBattleMoves[gCurrentMove].type;
+            moveType = gBattleMoves[gCurrentMove].type;
 
         //check stab
-        if (gBattleMons[gBattlerAttacker].type1 == move_type || gBattleMons[gBattlerAttacker].type2 == move_type)
+        if (gBattleMons[gBattlerAttacker].type1 == moveType || gBattleMons[gBattlerAttacker].type2 == moveType)
         {
             gBattleMoveDamage = gBattleMoveDamage * 15;
             gBattleMoveDamage = gBattleMoveDamage / 10;
         }
 
-        if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && move_type == TYPE_GROUND)
+        if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
         {
             gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
             gMoveResultFlags |= (MOVE_RESULT_MISSED | MOVE_RESULT_DOESNT_AFFECT_FOE);
             gLastLandedMoves[gBattlerTarget] = 0;
             gLastHitByType[gBattlerTarget] = 0;
-            gBattleCommunication[6] = move_type;
+            gBattleCommunication[6] = moveType;
             RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
         }
         else
@@ -1568,7 +1505,7 @@ static void atk06_typecalc(void)
                     continue;
                 }
 
-                else if (gTypeEffectiveness[i] == move_type)
+                else if (gTypeEffectiveness[i] == moveType)
                 {
                     //check type1
                     if (gTypeEffectiveness[i + 1] == gBattleMons[gBattlerTarget].type1)
@@ -1601,24 +1538,21 @@ static void atk06_typecalc(void)
 static void CheckWonderGuardAndLevitate(void)
 {
     u8 flags = 0;
-    int i = 0;
-    u8 move_type;
+    s32 i = 0;
+    u8 moveType;
 
     if (gCurrentMove == MOVE_STRUGGLE || !gBattleMoves[gCurrentMove].power)
         return;
 
-    if (gBattleStruct->dynamicMoveType)
-        move_type = gBattleStruct->dynamicMoveType & 0x3F;
-    else
-        move_type = gBattleMoves[gCurrentMove].type;
+    GET_MOVE_TYPE(gCurrentMove, moveType);
 
-    if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && move_type == TYPE_GROUND)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
-        RecordAbilitySetField6(ABILITY_LEVITATE, move_type);
+        RecordAbilitySetField6(ABILITY_LEVITATE, moveType);
         return;
     }
 
-    while (gTypeEffectiveness[i]!= TYPE_ENDTABLE)
+    while (gTypeEffectiveness[i] != TYPE_ENDTABLE)
     {
         if (gTypeEffectiveness[i] == TYPE_FORESIGHT)
         {
@@ -1628,9 +1562,9 @@ static void CheckWonderGuardAndLevitate(void)
             continue;
         }
 
-        if (gTypeEffectiveness[i] == move_type)
+        if (gTypeEffectiveness[i] == moveType)
         {
-            //check no effect
+            // check no effect
             if (gTypeEffectiveness[i + 1] == gBattleMons[gBattlerTarget].type1 && gTypeEffectiveness[i + 2] == 0)
             {
                 gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
@@ -1644,7 +1578,7 @@ static void CheckWonderGuardAndLevitate(void)
                 gProtectStructs[gBattlerAttacker].targetNotAffected = 1;
             }
 
-            //check super effective
+            // check super effective
             if (gTypeEffectiveness[i + 1] == gBattleMons[gBattlerTarget].type1 && gTypeEffectiveness[i + 2] == 20)
                 flags |= 1;
             if (gTypeEffectiveness[i + 1] == gBattleMons[gBattlerTarget].type2
@@ -1652,7 +1586,7 @@ static void CheckWonderGuardAndLevitate(void)
              && gTypeEffectiveness[i + 2] == 20)
                 flags |= 1;
 
-            //check not very effective
+            // check not very effective
             if (gTypeEffectiveness[i + 1] == gBattleMons[gBattlerTarget].type1 && gTypeEffectiveness[i + 2] == 5)
                 flags |= 2;
             if (gTypeEffectiveness[i + 1] == gBattleMons[gBattlerTarget].type2
@@ -1672,7 +1606,7 @@ static void CheckWonderGuardAndLevitate(void)
     }
 }
 
-static void ModulateDmgByType2(u8 multiplier, u16 move, u8* flags) //a literal copy of the ModulateDmgbyType1 with different args...
+static void ModulateDmgByType2(u8 multiplier, u16 move, u8* flags) // same as ModulateDmgByType except different arguments
 {
     gBattleMoveDamage = gBattleMoveDamage * multiplier / 10;
     if (gBattleMoveDamage == 0 && multiplier != 0)
@@ -1680,12 +1614,12 @@ static void ModulateDmgByType2(u8 multiplier, u16 move, u8* flags) //a literal c
 
     switch (multiplier)
     {
-    case 0: //no effect
+    case TYPE_MUL_NO_EFFECT:
         *flags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
         *flags &= ~MOVE_RESULT_NOT_VERY_EFFECTIVE;
         *flags &= ~MOVE_RESULT_SUPER_EFFECTIVE;
         break;
-    case 5: //not very effecting
+    case TYPE_MUL_NOT_EFFECTIVE:
         if (gBattleMoves[move].power && !(*flags & MOVE_RESULT_NO_EFFECT))
         {
             if (*flags & MOVE_RESULT_SUPER_EFFECTIVE)
@@ -1694,7 +1628,7 @@ static void ModulateDmgByType2(u8 multiplier, u16 move, u8* flags) //a literal c
                 *flags |= MOVE_RESULT_NOT_VERY_EFFECTIVE;
         }
         break;
-    case 20: //super effective
+    case TYPE_MUL_SUPER_EFFECTIVE:
         if (gBattleMoves[move].power && !(*flags & MOVE_RESULT_NO_EFFECT))
         {
             if (*flags & MOVE_RESULT_NOT_VERY_EFFECTIVE)
@@ -1706,25 +1640,25 @@ static void ModulateDmgByType2(u8 multiplier, u16 move, u8* flags) //a literal c
     }
 }
 
-u8 TypeCalc(u16 move, u8 bank_atk, u8 bank_def)
+u8 TypeCalc(u16 move, u8 attacker, u8 defender)
 {
-    int i = 0;
+    s32 i = 0;
     u8 flags = 0;
-    u8 move_type;
+    u8 moveType;
 
     if (move == MOVE_STRUGGLE)
         return 0;
 
-    move_type = gBattleMoves[move].type;
+    moveType = gBattleMoves[move].type;
 
-    //check stab
-    if (gBattleMons[bank_atk].type1 == move_type || gBattleMons[bank_atk].type2 == move_type)
+    // check stab
+    if (IS_BATTLER_OF_TYPE(attacker, moveType))
     {
         gBattleMoveDamage = gBattleMoveDamage * 15;
         gBattleMoveDamage = gBattleMoveDamage / 10;
     }
 
-    if (gBattleMons[bank_def].ability == ABILITY_LEVITATE && move_type == TYPE_GROUND)
+    if (gBattleMons[defender].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
         flags |= (MOVE_RESULT_MISSED | MOVE_RESULT_DOESNT_AFFECT_FOE);
     }
@@ -1734,28 +1668,28 @@ u8 TypeCalc(u16 move, u8 bank_atk, u8 bank_def)
         {
             if (gTypeEffectiveness[i] == TYPE_FORESIGHT)
             {
-                if (gBattleMons[bank_def].status2 & STATUS2_FORESIGHT)
+                if (gBattleMons[defender].status2 & STATUS2_FORESIGHT)
                     break;
                 i += 3;
                 continue;
             }
 
-            else if (gTypeEffectiveness[i] == move_type)
+            else if (gTypeEffectiveness[i] == moveType)
             {
-                //check type1
-                if (gTypeEffectiveness[i + 1] == gBattleMons[bank_def].type1)
+                // check type1
+                if (gTypeEffectiveness[i + 1] == gBattleMons[defender].type1)
                     ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
-                //check type2
-                if (gTypeEffectiveness[i + 1] == gBattleMons[bank_def].type2 &&
-                    gBattleMons[gBattlerTarget /* what the christ */].type1 != gBattleMons[bank_def].type2)
+                // check type2
+                if (gTypeEffectiveness[i + 1] == gBattleMons[defender].type2 &&
+                    gBattleMons[gBattlerTarget /* what the christ */].type1 != gBattleMons[defender].type2)
                     ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
             }
             i += 3;
         }
     }
 
-    if (gBattleMons[bank_def].ability == ABILITY_WONDER_GUARD && !(flags & MOVE_RESULT_MISSED) &&
-        AttacksThisTurn(bank_atk, move) == 2 &&
+    if (gBattleMons[defender].ability == ABILITY_WONDER_GUARD && !(flags & MOVE_RESULT_MISSED) &&
+        AttacksThisTurn(attacker, move) == 2 &&
         (!(flags & MOVE_RESULT_SUPER_EFFECTIVE) || ((flags & (MOVE_RESULT_SUPER_EFFECTIVE | MOVE_RESULT_NOT_VERY_EFFECTIVE)) == (MOVE_RESULT_SUPER_EFFECTIVE | MOVE_RESULT_NOT_VERY_EFFECTIVE))) &&
         gBattleMoves[move].power)
     {
@@ -1764,41 +1698,43 @@ u8 TypeCalc(u16 move, u8 bank_atk, u8 bank_def)
     return flags;
 }
 
-u8 AI_TypeCalc(u16 move, u16 species, u8 ability)
+u8 AI_TypeCalc(u16 move, u16 targetSpecies, u8 targetAbility)
 {
     int i = 0;
     u8 flags = 0;
-    u8 type1 = gBaseStats[species].type1, type2 = gBaseStats[species].type2, move_type;
+    u8 type1 = gBaseStats[targetSpecies].type1, type2 = gBaseStats[targetSpecies].type2, moveType;
 
     if (move == MOVE_STRUGGLE)
         return 0;
 
-    move_type = gBattleMoves[move].type;
+    moveType = gBattleMoves[move].type;
 
-    if (ability == ABILITY_LEVITATE && move_type == TYPE_GROUND)
+    if (targetAbility == ABILITY_LEVITATE && moveType == TYPE_GROUND)
+    {
         flags = MOVE_RESULT_MISSED | MOVE_RESULT_DOESNT_AFFECT_FOE;
+    }
     else
     {
-        while (gTypeEffectiveness[i]!= TYPE_ENDTABLE)
+        while (TYPE_EFFECT_ATK_TYPE(i) != TYPE_ENDTABLE)
         {
-            if (gTypeEffectiveness[i] == TYPE_FORESIGHT)
+            if (TYPE_EFFECT_ATK_TYPE(i) == TYPE_FORESIGHT)
             {
                 i += 3;
                 continue;
             }
-            if (gTypeEffectiveness[i] == move_type)
+            if (TYPE_EFFECT_ATK_TYPE(i) == moveType)
             {
-                //check type1
-                if (gTypeEffectiveness[i + 1] == type1)
-                    ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
-                //check type2
-                if (gTypeEffectiveness[i + 1] == type2 && gBattleMons[gBattlerTarget].type1 != type2) //gf you morons, you should check if (type1 != type2)...
-                    ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
+                // check type1
+                if (TYPE_EFFECT_DEF_TYPE(i) == type1)
+                    ModulateDmgByType2(TYPE_EFFECT_MULTIPLIER(i), move, &flags);
+                // check type2
+                if (TYPE_EFFECT_DEF_TYPE(i) == type2 && gBattleMons[gBattlerTarget].type1 != type2) //gf you morons, you should check if (type1 != type2)...
+                    ModulateDmgByType2(TYPE_EFFECT_MULTIPLIER(i), move, &flags);
             }
             i += 3;
         }
     }
-    if (ability == ABILITY_WONDER_GUARD
+    if (targetAbility == ABILITY_WONDER_GUARD
      && (!(flags & MOVE_RESULT_SUPER_EFFECTIVE) || ((flags & (MOVE_RESULT_SUPER_EFFECTIVE | MOVE_RESULT_NOT_VERY_EFFECTIVE)) == (MOVE_RESULT_SUPER_EFFECTIVE | MOVE_RESULT_NOT_VERY_EFFECTIVE)))
      && gBattleMoves[move].power)
         flags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
@@ -1827,23 +1763,26 @@ void Unused_ApplyRandomDmgMultiplier(void)
 
 static void atk07_adjustnormaldamage(void)
 {
-    u8 hold_effect, quality;
+    u8 holdEffect, param;
+
     ApplyRandomDmgMultiplier();
+
     if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
     {
-        hold_effect = gEnigmaBerries[gBattlerTarget].holdEffect, quality = gEnigmaBerries[gBattlerTarget].holdEffectParam;
+        holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect;
+        param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     }
     else
     {
-        hold_effect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
-        quality = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
     gPotentialItemEffectBattler = gBattlerTarget;
 
-    if (hold_effect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < quality)
+    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemBattle(gBattlerTarget, hold_effect);
+        RecordItemEffectBattle(gBattlerTarget, holdEffect);
         gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
     if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE)
@@ -1860,9 +1799,8 @@ static void atk07_adjustnormaldamage(void)
     if (gProtectStructs[gBattlerTarget].endured)
     {
         gMoveResultFlags |= MOVE_RESULT_FOE_ENDURED;
-        goto END;
     }
-    if (gSpecialStatuses[gBattlerTarget].focusBanded)
+    else if (gSpecialStatuses[gBattlerTarget].focusBanded)
     {
         gMoveResultFlags |= MOVE_RESULT_FOE_HUNG_ON;
         gLastUsedItem = gBattleMons[gBattlerTarget].item;
@@ -1872,33 +1810,34 @@ static void atk07_adjustnormaldamage(void)
         gBattlescriptCurrInstr++;
 }
 
-static void atk08_adjustnormaldamage2(void) //literally the same as 0x7 except it doesn't check for false swipe move effect...
+static void atk08_adjustnormaldamage2(void) // The same as 0x7 except it doesn't check for false swipe move effect.
 {
-    u8 hold_effect, quality;
+    u8 holdEffect, param;
+
     ApplyRandomDmgMultiplier();
+
     if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
     {
-        hold_effect = gEnigmaBerries[gBattlerTarget].holdEffect, quality = gEnigmaBerries[gBattlerTarget].holdEffectParam;
+        holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect;
+        param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     }
     else
     {
-        hold_effect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
-        quality = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
     gPotentialItemEffectBattler = gBattlerTarget;
 
-    if (hold_effect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < quality)
+    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemBattle(gBattlerTarget, hold_effect);
+        RecordItemEffectBattle(gBattlerTarget, holdEffect);
         gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
     if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE)
         goto END;
-    if (!gProtectStructs[gBattlerTarget].endured
-     && !gSpecialStatuses[gBattlerTarget].focusBanded)
+    if (!gProtectStructs[gBattlerTarget].endured && !gSpecialStatuses[gBattlerTarget].focusBanded)
         goto END;
-
     if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
         goto END;
 
@@ -1907,9 +1846,8 @@ static void atk08_adjustnormaldamage2(void) //literally the same as 0x7 except i
     if (gProtectStructs[gBattlerTarget].endured)
     {
         gMoveResultFlags |= MOVE_RESULT_FOE_ENDURED;
-        goto END;
     }
-    if (gSpecialStatuses[gBattlerTarget].focusBanded)
+    else if (gSpecialStatuses[gBattlerTarget].focusBanded)
     {
         gMoveResultFlags |= MOVE_RESULT_FOE_HUNG_ON;
         gLastUsedItem = gBattleMons[gBattlerTarget].item;
@@ -1928,12 +1866,12 @@ static void atk09_attackanimation(void)
     {
         BattleScriptPush(gBattlescriptCurrInstr + 1);
         gBattlescriptCurrInstr = BattleScript_Pausex20;
-        gBattleStruct->animTurn += 1;
-        gBattleStruct->animTargetsHit += 1;
+        gBattleStruct->animTurn++;
+        gBattleStruct->animTargetsHit++;
     }
     else
     {
-        if ((gBattleMoves[gCurrentMove].target & TARGET_BOTH || gBattleMoves[gCurrentMove].target & TARGET_FOES_AND_ALLY || gBattleMoves[gCurrentMove].target & TARGET_DEPENDS) && gBattleStruct->animTargetsHit)
+        if ((gBattleMoves[gCurrentMove].target & MOVE_TARGET_BOTH || gBattleMoves[gCurrentMove].target & MOVE_TARGET_FOES_AND_ALLY || gBattleMoves[gCurrentMove].target & TARGET_DEPENDS) && gBattleStruct->animTargetsHit)
         {
             gBattlescriptCurrInstr++;
             return;
@@ -1969,7 +1907,7 @@ static void atk0B_healthbarupdate(void)
 
     if (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
-        gActiveBattler = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
         if (gBattleMons[gActiveBattler].status2 & STATUS2_SUBSTITUTE && gDisableStructs[gActiveBattler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE))
         {
@@ -1996,7 +1934,7 @@ static void atk0B_healthbarupdate(void)
             MarkBattlerForControllerExec(gActiveBattler);
 
             if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER && gBattleMoveDamage > 0)
-                gBattleResults.unk5_0 = 1;
+                gBattleResults.playerMonWasDamaged = TRUE;
         }
     }
 
@@ -2019,7 +1957,7 @@ static void atk0C_datahpupdate(void)
 
     if (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
-        gActiveBattler = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
         if (gBattleMons[gActiveBattler].status2 & STATUS2_SUBSTITUTE && gDisableStructs[gActiveBattler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE))
         {
             if (gDisableStructs[gActiveBattler].substituteHP >= gBattleMoveDamage)
@@ -2064,10 +2002,10 @@ static void atk0C_datahpupdate(void)
                 else
                 {
                     gTakenDmg[gActiveBattler] += gBattleMoveDamage;
-                    if (gBattlescriptCurrInstr[1] == BS_GET_TARGET)
-                        gTakenDmgBanks[gActiveBattler] = gBattlerAttacker;
+                    if (gBattlescriptCurrInstr[1] == BS_TARGET)
+                        gTakenDmgByBattler[gActiveBattler] = gBattlerAttacker;
                     else
-                        gTakenDmgBanks[gActiveBattler] = gBattlerTarget;
+                        gTakenDmgByBattler[gActiveBattler] = gBattlerTarget;
                 }
 
                 if (gBattleMons[gActiveBattler].hp > gBattleMoveDamage)
@@ -2084,11 +2022,11 @@ static void atk0C_datahpupdate(void)
                 if (!gSpecialStatuses[gActiveBattler].dmg && !(gHitMarker & HITMARKER_x100000))
                     gSpecialStatuses[gActiveBattler].dmg = gHpDealt;
 
-                if (TYPE_IS_PHYSICAL(moveType) && !(gHitMarker & HITMARKER_x100000) && gCurrentMove != MOVE_PAIN_SPLIT)
+                if (IS_TYPE_PHYSICAL(moveType) && !(gHitMarker & HITMARKER_x100000) && gCurrentMove != MOVE_PAIN_SPLIT)
                 {
                     gProtectStructs[gActiveBattler].physicalDmg = gHpDealt;
                     gSpecialStatuses[gActiveBattler].physicalDmg = gHpDealt;
-                    if (gBattlescriptCurrInstr[1] == BS_GET_TARGET)
+                    if (gBattlescriptCurrInstr[1] == BS_TARGET)
                     {
                         gProtectStructs[gActiveBattler].physicalBattlerId = gBattlerAttacker;
                         gSpecialStatuses[gActiveBattler].physicalBattlerId = gBattlerAttacker;
@@ -2099,11 +2037,11 @@ static void atk0C_datahpupdate(void)
                         gSpecialStatuses[gActiveBattler].physicalBattlerId = gBattlerTarget;
                     }
                 }
-                else if (!TYPE_IS_PHYSICAL(moveType) && !(gHitMarker & HITMARKER_x100000))
+                else if (!IS_TYPE_PHYSICAL(moveType) && !(gHitMarker & HITMARKER_x100000))
                 {
                     gProtectStructs[gActiveBattler].specialDmg = gHpDealt;
                     gSpecialStatuses[gActiveBattler].specialDmg = gHpDealt;
-                    if (gBattlescriptCurrInstr[1] == BS_GET_TARGET)
+                    if (gBattlescriptCurrInstr[1] == BS_TARGET)
                     {
                         gProtectStructs[gActiveBattler].specialBattlerId = gBattlerAttacker;
                         gSpecialStatuses[gActiveBattler].specialBattlerId = gBattlerAttacker;
@@ -2122,7 +2060,7 @@ static void atk0C_datahpupdate(void)
     }
     else
     {
-        gActiveBattler = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
         if (gSpecialStatuses[gActiveBattler].dmg == 0)
             gSpecialStatuses[gActiveBattler].dmg = 0xFFFF;
     }
@@ -2150,19 +2088,19 @@ static void atk0E_effectivenesssound(void)
     gActiveBattler = gBattlerTarget;
     if (!(gMoveResultFlags & MOVE_RESULT_MISSED))
     {
-        u8 flag = ~MOVE_RESULT_MISSED;
-        switch (gMoveResultFlags & flag)
+        switch (gMoveResultFlags & (u8)(~(MOVE_RESULT_MISSED)))
         {
         case MOVE_RESULT_SUPER_EFFECTIVE:
-            BtlController_EmitPlaySE(0, 14);
+            BtlController_EmitPlaySE(0, SE_KOUKA_H);
             MarkBattlerForControllerExec(gActiveBattler);
             break;
         case MOVE_RESULT_NOT_VERY_EFFECTIVE:
-            BtlController_EmitPlaySE(0, 12);
+            BtlController_EmitPlaySE(0, SE_KOUKA_L);
             MarkBattlerForControllerExec(gActiveBattler);
             break;
         case MOVE_RESULT_DOESNT_AFFECT_FOE:
         case MOVE_RESULT_FAILED:
+            // no sound
             break;
         case MOVE_RESULT_FOE_ENDURED:
         case MOVE_RESULT_ONE_HIT_KO:
@@ -2170,17 +2108,17 @@ static void atk0E_effectivenesssound(void)
         default:
             if (gMoveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE)
             {
-                BtlController_EmitPlaySE(0, 14);
+                BtlController_EmitPlaySE(0, SE_KOUKA_H);
                 MarkBattlerForControllerExec(gActiveBattler);
             }
             else if (gMoveResultFlags & MOVE_RESULT_NOT_VERY_EFFECTIVE)
             {
-                BtlController_EmitPlaySE(0, 12);
+                BtlController_EmitPlaySE(0, SE_KOUKA_L);
                 MarkBattlerForControllerExec(gActiveBattler);
             }
             else if (!(gMoveResultFlags & (MOVE_RESULT_DOESNT_AFFECT_FOE | MOVE_RESULT_FAILED)))
             {
-                BtlController_EmitPlaySE(0, 13);
+                BtlController_EmitPlaySE(0, SE_KOUKA_M);
                 MarkBattlerForControllerExec(gActiveBattler);
             }
             break;
@@ -2292,8 +2230,10 @@ static void atk10_printstring(void)
 static void atk11_printselectionstring(void)
 {
     gActiveBattler = gBattlerAttacker;
+
     BtlController_EmitPrintSelectionString(0, T2_READ_16(gBattlescriptCurrInstr + 1));
     MarkBattlerForControllerExec(gActiveBattler);
+
     gBattlescriptCurrInstr += 3;
     gBattleCommunication[MSG_DISPLAY] = 1;
 }
@@ -2308,8 +2248,8 @@ static void atk12_waitmessage(void)
         }
         else
         {
-            u16 to_wait = T2_READ_16(gBattlescriptCurrInstr + 1);
-            if (++gPauseCounterBattle >= to_wait)
+            u16 toWait = T2_READ_16(gBattlescriptCurrInstr + 1);
+            if (++gPauseCounterBattle >= toWait)
             {
                 gPauseCounterBattle = 0;
                 gBattlescriptCurrInstr += 3;
@@ -2345,12 +2285,12 @@ static void atk14_printselectionstringfromtable(void)
     }
 }
 
-u8 BankGetTurnOrder(u8 bank)
+u8 GetBattlerTurnOrderNum(u8 battlerId)
 {
     int i;
     for (i = 0; i < gBattlersCount; i++)
     {
-        if (gBanksByTurnOrder[i] == bank)
+        if (gBattlerByTurnOrder[i] == battlerId)
             break;
     }
     return i;
@@ -2383,7 +2323,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
         !primary && gBattleCommunication[MOVE_EFFECT_BYTE] <= 9)
         {gBattlescriptCurrInstr++; return;}
 
-    if (gSideAffecting[GetBattlerPosition(gEffectBattler) & 1] & SIDE_STATUS_SAFEGUARD && !(gHitMarker & HITMARKER_IGNORE_SAFEGUARD) &&
+    if (gSideStatuses[GetBattlerPosition(gEffectBattler) & 1] & SIDE_STATUS_SAFEGUARD && !(gHitMarker & HITMARKER_IGNORE_SAFEGUARD) &&
         !primary && gBattleCommunication[MOVE_EFFECT_BYTE] <= 7)
         {gBattlescriptCurrInstr++; return;}
 
@@ -2398,7 +2338,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
     {
         switch (sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]])
         {
-        case STATUS_SLEEP:
+        case STATUS1_SLEEP:
             //check active uproar
             if (gBattleMons[gEffectBattler].ability != ABILITY_SOUNDPROOF)
             {
@@ -2414,7 +2354,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
             CancelMultiTurnMoves(gEffectBattler);
             StatusChanged = 1;
             break;
-        case STATUS_POISON:
+        case STATUS1_POISON:
             if (gBattleMons[gEffectBattler].ability == ABILITY_IMMUNITY && (primary == 1 || certain == 0x80))
             {
                 gLastUsedAbility = ABILITY_IMMUNITY;
@@ -2448,7 +2388,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
 
             StatusChanged = 1;
             break;
-        case STATUS_BURN:
+        case STATUS1_BURN:
             if (gBattleMons[gEffectBattler].ability == ABILITY_WATER_VEIL && (primary == 1 || certain == 0x80))
             {
                 gLastUsedAbility = ABILITY_WATER_VEIL;
@@ -2479,7 +2419,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
             if (gBattleMons[gEffectBattler].status1 == 0) {break;}
             StatusChanged = 1;
             break;
-        case STATUS_FREEZE:
+        case STATUS1_FREEZE:
             if (WEATHER_HAS_EFFECT && gBattleWeather & WEATHER_SUN_ANY) {NoSunCanFreeze = 0;}
             if (gBattleMons[gEffectBattler].type1 == TYPE_ICE) {break;}
             if (gBattleMons[gEffectBattler].type2 == TYPE_ICE) {break;}
@@ -2490,7 +2430,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
             CancelMultiTurnMoves(gEffectBattler);
             StatusChanged = 1;
             break;
-        case STATUS_PARALYSIS:
+        case STATUS1_PARALYSIS:
             if (gBattleMons[gEffectBattler].ability == ABILITY_LIMBER)
             {
                 if ((primary == 1 || certain == 0x80))
@@ -2514,7 +2454,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
             if (gBattleMons[gEffectBattler].status1) {break;}
             StatusChanged = 1;
             break;
-        case STATUS_TOXIC_POISON:
+        case STATUS1_TOXIC_POISON:
             if (gBattleMons[gEffectBattler].ability == ABILITY_IMMUNITY && (primary == 1 || certain == 0x80))
             {
                 gLastUsedAbility = ABILITY_IMMUNITY;
@@ -2557,7 +2497,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
         if (StatusChanged == 1)
         {
             BattleScriptPush(gBattlescriptCurrInstr + 1);
-            if (sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]] == STATUS_SLEEP)
+            if (sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]] == STATUS1_SLEEP)
                 gBattleMons[gEffectBattler].status1 |= ((Random() & 3) + 2);
             else
                 gBattleMons[gEffectBattler].status1 |= sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]];
@@ -2615,7 +2555,7 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
             }
             else
             {
-                if (BankGetTurnOrder(gEffectBattler) > gCurrentTurnActionNumber)
+                if (GetBattlerTurnOrderNum(gEffectBattler) > gCurrentTurnActionNumber)
                     gBattleMons[gEffectBattler].status2 |= sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]];
                 gBattlescriptCurrInstr++; return;
             }
@@ -2781,9 +2721,9 @@ void SetMoveEffect(bool8 primary, u8 certainArg)
             gBattlescriptCurrInstr = BattleScript_RapidSpinAway;
             return;
         case 36: //paralysis removal
-            if (gBattleMons[gBattlerTarget].status1 & STATUS_PARALYSIS)
+            if (gBattleMons[gBattlerTarget].status1 & STATUS1_PARALYSIS)
             {
-                gBattleMons[gBattlerTarget].status1 &= ~(STATUS_PARALYSIS);
+                gBattleMons[gBattlerTarget].status1 &= ~(STATUS1_PARALYSIS);
                 gActiveBattler = gBattlerTarget;
                 BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerTarget].status1);
                 MarkBattlerForControllerExec(gActiveBattler);
@@ -2929,7 +2869,7 @@ _0801E48A:\n\
     mov r1, r8\n\
     ldrb r0, [r1]\n\
     bl GetBattlerPosition\n\
-    ldr r2, _0801E554 @ =gSideAffecting\n\
+    ldr r2, _0801E554 @ =gSideStatuses\n\
     movs r1, 0x1\n\
     ands r1, r0\n\
     lsls r1, 1\n\
@@ -3023,7 +2963,7 @@ _0801E544: .4byte gBattlerAttacker\n\
 _0801E548: .4byte 0x00016003\n\
 _0801E54C: .4byte gBattleMons\n\
 _0801E550: .4byte gHitMarker\n\
-_0801E554: .4byte gSideAffecting\n\
+_0801E554: .4byte gSideStatuses\n\
 _0801E558: .4byte gBattleCommunication\n\
 _0801E55C: .4byte sStatusFlagsForMoveEffects\n\
 _0801E560:\n\
@@ -3957,7 +3897,7 @@ _0801ED10: .4byte gBattlescriptCurrInstr\n\
 _0801ED14: .4byte BattleScript_FlinchPrevention\n\
 _0801ED18:\n\
     adds r0, r2, 0\n\
-    bl BankGetTurnOrder\n\
+    bl GetBattlerTurnOrderNum\n\
     ldr r1, _0801ED54 @ =gCurrentTurnActionNumber\n\
     lsls r0, 24\n\
     lsrs r0, 24\n\
@@ -5017,27 +4957,31 @@ _0801F610: .4byte BattleScript_SAtkDown2\n\
 
 static void atk15_seteffectwithchance(void)
 {
-    u32 PercentChance;
+    u32 percentChance;
 
     if (gBattleMons[gBattlerAttacker].ability == ABILITY_SERENE_GRACE)
-        PercentChance = gBattleMoves[gCurrentMove].secondaryEffectChance * 2;
+        percentChance = gBattleMoves[gCurrentMove].secondaryEffectChance * 2;
     else
-        PercentChance = gBattleMoves[gCurrentMove].secondaryEffectChance;
+        percentChance = gBattleMoves[gCurrentMove].secondaryEffectChance;
 
     if (DEBUG && (gUnknown_02023A14_50 & 4)
-     && !(gBattleCommunication[MOVE_EFFECT_BYTE] & 0x80) && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
+        && !(gBattleCommunication[MOVE_EFFECT_BYTE] & MOVE_EFFECT_CERTAIN)
+        && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
         SetMoveEffect(0, 0);
     }
-    else if ((gBattleCommunication[MOVE_EFFECT_BYTE] & 0x80) && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
+    else if ((gBattleCommunication[MOVE_EFFECT_BYTE] & MOVE_EFFECT_CERTAIN)
+        && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
-        gBattleCommunication[MOVE_EFFECT_BYTE] &= 0x7F;
-        SetMoveEffect(0, 0x80);
+        gBattleCommunication[MOVE_EFFECT_BYTE] &= ~(MOVE_EFFECT_CERTAIN);
+        SetMoveEffect(0, MOVE_EFFECT_CERTAIN);
     }
-    else if (Random() % 100 <= PercentChance && gBattleCommunication[MOVE_EFFECT_BYTE] != 0 && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
+    else if (Random() % 100 <= percentChance  // Random() % 100 < percentChance in Emerald
+             && gBattleCommunication[MOVE_EFFECT_BYTE]
+             && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
-        if (PercentChance >= 100)
-            SetMoveEffect(0, 0x80);
+        if (percentChance >= 100)
+            SetMoveEffect(0, MOVE_EFFECT_CERTAIN);
         else
             SetMoveEffect(0, 0);
     }
@@ -5062,8 +5006,9 @@ static void atk17_seteffectsecondary(void)
 
 static void atk18_clearstatusfromeffect(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
-    if (gBattleCommunication[MOVE_EFFECT_BYTE] <= 6)
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+
+    if (gBattleCommunication[MOVE_EFFECT_BYTE] <= MOVE_EFFECT_TOXIC)
         gBattleMons[gActiveBattler].status1 &= (~sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]]);
     else
         gBattleMons[gActiveBattler].status2 &= (~sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]]);
@@ -5075,18 +5020,18 @@ static void atk18_clearstatusfromeffect(void)
 
 static void atk19_tryfaintmon(void)
 {
-    u8 *r4;
+    const u8 *BS_ptr;
 
     if (gBattlescriptCurrInstr[2] != 0)
     {
-        gActiveBattler = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
         if (gHitMarker & HITMARKER_FAINTED(gActiveBattler))
         {
-            r4 = T1_READ_PTR(gBattlescriptCurrInstr + 3);
+            BS_ptr = T1_READ_PTR(gBattlescriptCurrInstr + 3);
 
             BattleScriptPop();
-            gBattlescriptCurrInstr = r4;
-            gSideAffecting[GetBattlerSide(gActiveBattler)] &= ~SIDE_STATUS_SPIKES_DAMAGED;
+            gBattlescriptCurrInstr = BS_ptr;
+            gSideStatuses[GetBattlerSide(gActiveBattler)] &= ~(SIDE_STATUS_SPIKES_DAMAGED);
         }
         else
         {
@@ -5095,41 +5040,41 @@ static void atk19_tryfaintmon(void)
     }
     else
     {
-        u8 bank;
+        u8 battlerId;
 
         if (gBattlescriptCurrInstr[1] == 1)
         {
             gActiveBattler = gBattlerAttacker;
-            bank = gBattlerTarget;
-            r4 = BattleScript_FaintAttacker;
+            battlerId = gBattlerTarget;
+            BS_ptr = BattleScript_FaintAttacker;
         }
         else
         {
             gActiveBattler = gBattlerTarget;
-            bank = gBattlerAttacker;
-            r4 = BattleScript_FaintTarget;
+            battlerId = gBattlerAttacker;
+            BS_ptr = BattleScript_FaintTarget;
         }
         if (!(gAbsentBattlerFlags & gBitTable[gActiveBattler])
          && gBattleMons[gActiveBattler].hp == 0)
         {
-            ewram160ACarr2(0, bank) = 0;
-            ewram160ACarr2(1, bank) = 0;
-            ewram16100arr2(0, bank) = 0;
-            ewram16100arr2(1, bank) = 0;
-            ewram16100arr2(2, bank) = 0;
-            ewram16100arr2(3, bank) = 0;
+            ewram160ACarr2(0, battlerId) = 0;
+            ewram160ACarr2(1, battlerId) = 0;
+            ewram16100arr2(0, battlerId) = 0;
+            ewram16100arr2(1, battlerId) = 0;
+            ewram16100arr2(2, battlerId) = 0;
+            ewram16100arr2(3, battlerId) = 0;
 
             gHitMarker |= HITMARKER_FAINTED(gActiveBattler);
             BattleScriptPush(gBattlescriptCurrInstr + 7);
-            gBattlescriptCurrInstr = r4;
-            if (GetBattlerSide(gActiveBattler) == 0)
+            gBattlescriptCurrInstr = BS_ptr;
+            if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
             {
                 gHitMarker |= HITMARKER_x400000;
                 if (gBattleResults.playerFaintCounter < 0xFF)
                     gBattleResults.playerFaintCounter++;
-                if (gBattleMons[bank].level > gBattleMons[gActiveBattler].level)
+                if (gBattleMons[battlerId].level > gBattleMons[gActiveBattler].level)
                 {
-                    if (gBattleMons[bank].level - gBattleMons[gActiveBattler].level > 29)
+                    if (gBattleMons[battlerId].level - gBattleMons[gActiveBattler].level > 29)
                         AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], FRIENDSHIP_EVENT_FAINT_LARGE);
                     else
                         AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], FRIENDSHIP_EVENT_FAINT_SMALL);
@@ -5144,7 +5089,7 @@ static void atk19_tryfaintmon(void)
             if ((gHitMarker & HITMARKER_DESTINYBOND) && gBattleMons[gBattlerAttacker].hp != 0)
             {
                 BattleScriptPush(gBattlescriptCurrInstr);
-                gBattleMoveDamage = gBattleMons[bank].hp;
+                gBattleMoveDamage = gBattleMons[battlerId].hp;
                 gBattlescriptCurrInstr = BattleScript_DestinyBondTakesLife;
             }
             if ((gStatuses3[gBattlerTarget] & STATUS3_GRUDGE)
@@ -5157,7 +5102,7 @@ static void atk19_tryfaintmon(void)
 
                 gBattleMons[gBattlerAttacker].pp[moveIndex] = 0;
                 BattleScriptPush(gBattlescriptCurrInstr);
-                gBattlescriptCurrInstr = BattleScript_SelectingImprisionedMoveInPalace;
+                gBattlescriptCurrInstr = BattleScript_GrudgeTakesPp;
                 gActiveBattler = gBattlerAttacker;
                 BtlController_EmitSetMonData(0, moveIndex + 9, 0, 1, &gBattleMons[gActiveBattler].pp[moveIndex]);
                 MarkBattlerForControllerExec(gActiveBattler);
@@ -5180,7 +5125,7 @@ static void atk1A_dofaintanimation(void)
 {
     if (gBattleControllerExecFlags == 0)
     {
-        gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
         BtlController_EmitFaintAnimation(0);
         MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 2;
@@ -5192,7 +5137,7 @@ static void atk1B_cleareffectsonfaint(void)
     //Clears things like attraction or trapping to other banks
     if (gBattleControllerExecFlags == 0)
     {
-        gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
         gBattleMons[gActiveBattler].status1 = 0;
         BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 0x4, &gBattleMons[gActiveBattler].status1);
         MarkBattlerForControllerExec(gActiveBattler);
@@ -5203,7 +5148,7 @@ static void atk1B_cleareffectsonfaint(void)
 
 static void atk1C_jumpifstatus(void)
 {
-    u8 bank = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    u8 bank = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     u32 flags = T2_READ_32(gBattlescriptCurrInstr + 2);
     void* jump_loc = T2_READ_PTR(gBattlescriptCurrInstr + 6);
     if (gBattleMons[bank].status1 & flags && gBattleMons[bank].hp)
@@ -5214,10 +5159,10 @@ static void atk1C_jumpifstatus(void)
 
 static void atk1D_jumpifstatus2(void)
 {
-    u8 bank = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    u8 battlerId = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     u32 flags = T2_READ_32(gBattlescriptCurrInstr + 2);
     void* jump_loc = T2_READ_PTR(gBattlescriptCurrInstr + 6);
-    if (gBattleMons[bank].status2 & flags && gBattleMons[bank].hp)
+    if (gBattleMons[battlerId].status2 & flags && gBattleMons[battlerId].hp)
         gBattlescriptCurrInstr = jump_loc;
     else
         gBattlescriptCurrInstr += 10;
@@ -5225,44 +5170,44 @@ static void atk1D_jumpifstatus2(void)
 
 static void atk1E_jumpifability(void)
 {
-    u8 bank;
-    u8 ability = T2_READ_8(gBattlescriptCurrInstr + 2);
-    void* jump_loc = T2_READ_PTR(gBattlescriptCurrInstr + 3);
+    u8 battlerId;
+    u8 ability = gBattlescriptCurrInstr[2];
+    void* jumpPtr = T2_READ_PTR(gBattlescriptCurrInstr + 3);
     if (T2_READ_8(gBattlescriptCurrInstr + 1) == 8)
     {
-        bank = AbilityBattleEffects(ABILITYEFFECT_CHECK_BANK_SIDE, gBattlerAttacker, ability, 0, 0);
-        if (bank)
+        battlerId = AbilityBattleEffects(ABILITYEFFECT_CHECK_BANK_SIDE, gBattlerAttacker, ability, 0, 0);
+        if (battlerId)
         {
             gLastUsedAbility = ability;
-            gBattlescriptCurrInstr = jump_loc;
-            RecordAbilityBattle(bank -1, gLastUsedAbility);
-            ewram160F8 = bank - 1;
+            gBattlescriptCurrInstr = jumpPtr;
+            RecordAbilityBattle(battlerId -1, gLastUsedAbility);
+            ewram160F8 = battlerId - 1;
         }
         else
             gBattlescriptCurrInstr += 7;
     }
     else if (T2_READ_8(gBattlescriptCurrInstr + 1) == 9)
     {
-        bank = AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gBattlerAttacker, ability, 0, 0);
-        if (bank)
+        battlerId = AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gBattlerAttacker, ability, 0, 0);
+        if (battlerId)
         {
             gLastUsedAbility = ability;
-            gBattlescriptCurrInstr = jump_loc;
-            RecordAbilityBattle(bank - 1, gLastUsedAbility);
-            ewram160F8 = bank - 1;
+            gBattlescriptCurrInstr = jumpPtr;
+            RecordAbilityBattle(battlerId - 1, gLastUsedAbility);
+            ewram160F8 = battlerId - 1;
         }
         else
             gBattlescriptCurrInstr += 7;
     }
     else
     {
-        bank = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
-        if (gBattleMons[bank].ability == ability)
+        battlerId = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
+        if (gBattleMons[battlerId].ability == ability)
         {
             gLastUsedAbility = ability;
-            gBattlescriptCurrInstr = jump_loc;
-            RecordAbilityBattle(bank, gLastUsedAbility);
-            ewram160F8 = bank;
+            gBattlescriptCurrInstr = jumpPtr;
+            RecordAbilityBattle(battlerId, gLastUsedAbility);
+            ewram160F8 = battlerId;
         }
         else
             gBattlescriptCurrInstr += 7;
@@ -5282,7 +5227,7 @@ static void atk1F_jumpifsideaffecting(void)
     flags = T2_READ_16(gBattlescriptCurrInstr + 2);
     jump_loc = T2_READ_PTR(gBattlescriptCurrInstr + 4);
 
-    if (gSideAffecting[side] & flags)
+    if (gSideStatuses[side] & flags)
         gBattlescriptCurrInstr = jump_loc;
     else
         gBattlescriptCurrInstr += 8;
@@ -5291,8 +5236,8 @@ static void atk1F_jumpifsideaffecting(void)
 static void atk20_jumpifstat(void)
 {
     u8 ret = 0;
-    u8 bank = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
-    u8 value = gBattleMons[bank].statStages[T2_READ_8(gBattlescriptCurrInstr + 3)];
+    u8 battlerId = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
+    u8 value = gBattleMons[battlerId].statStages[T2_READ_8(gBattlescriptCurrInstr + 3)];
     switch (T2_READ_8(gBattlescriptCurrInstr + 2))
     {
     case CMP_EQUAL:
@@ -5331,7 +5276,7 @@ static void atk21_jumpifstatus3condition(void)
     u32 flags;
     void* jump_loc;
 
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     flags = T2_READ_32(gBattlescriptCurrInstr + 2);
     jump_loc = T2_READ_PTR(gBattlescriptCurrInstr + 7);
     if (T2_READ_8(gBattlescriptCurrInstr + 6))
@@ -5350,13 +5295,13 @@ static void atk21_jumpifstatus3condition(void)
     }
 }
 
-static void atk22_jumpiftype(void) //u8 bank, u8 type, *ptr
+static void atk22_jumpiftype(void) //u8 battlerId, u8 type, *ptr
 {
-    u8 bank = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    u8 battlerId = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     u8 type = T2_READ_8(gBattlescriptCurrInstr + 2);
     void* jump_loc = T2_READ_PTR(gBattlescriptCurrInstr + 3);
 
-    if (gBattleMons[bank].type1 == type || gBattleMons[bank].type2 == type)
+    if (gBattleMons[battlerId].type1 == type || gBattleMons[battlerId].type2 == type)
         gBattlescriptCurrInstr = jump_loc;
     else
         gBattlescriptCurrInstr += 7;
@@ -5372,7 +5317,7 @@ static void atk23_getexp(void)
     s32 viaExpShare = 0;
     u16* exp = &gBattleStruct->exp;
 
-    gBank1 = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gBank1 = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     sentIn = gSentPokesToOpponent[(gBank1 & 2) >> 1];
 
     switch (gBattleStruct->getexpStateTracker)
@@ -5436,14 +5381,14 @@ static void atk23_getexp(void)
             }
 
             gBattleStruct->getexpStateTracker++;
-            gBattleStruct->expGetterID = 0;
+            gBattleStruct->expGetterMonId = 0;
             gBattleStruct->sentInPokes = sentIn;
         }
         // fall through
     case 2: // set exp value to the poke in expgetter_id and print message
         if (gBattleControllerExecFlags == 0)
         {
-            item = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_HELD_ITEM);
+            item = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HELD_ITEM);
 
             if (item == ITEM_ENIGMA_BERRY)
                 holdEffect = gSaveBlock1.enigmaBerry.holdEffect;
@@ -5456,7 +5401,7 @@ static void atk23_getexp(void)
                 gBattleStruct->getexpStateTracker = 5;
                 gBattleMoveDamage = 0; // used for exp
             }
-            else if (GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_LEVEL) == 100)
+            else if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) == 100)
             {
                 gBattleStruct->sentInPokes >>= 1;
                 gBattleStruct->getexpStateTracker = 5;
@@ -5468,11 +5413,11 @@ static void atk23_getexp(void)
                 if (!(gBattleTypeFlags & BATTLE_TYPE_TRAINER) && gBattleMons[0].hp && !gBattleStruct->wildVictorySong)
                 {
                     BattleStopLowHpSound();
-                    PlayBGM(0x161);
+                    PlayBGM(MUS_KACHI2);
                     gBattleStruct->wildVictorySong++;
                 }
 
-                if (GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_HP))
+                if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP))
                 {
                     if (gBattleStruct->sentInPokes & 1)
                         gBattleMoveDamage = *exp;
@@ -5486,7 +5431,7 @@ static void atk23_getexp(void)
                     if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
                         gBattleMoveDamage = (gBattleMoveDamage * 150) / 100;
 
-                    if (IsTradedMon(&gPlayerParty[gBattleStruct->expGetterID]))
+                    if (IsTradedMon(&gPlayerParty[gBattleStruct->expGetterMonId]))
                     {
                         gBattleMoveDamage = (gBattleMoveDamage * 150) / 100;
                         i = 0x14A;
@@ -5499,28 +5444,28 @@ static void atk23_getexp(void)
                     // get exp getter bank
                     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
                     {
-                        if (!(gBattlerPartyIndexes[2] != gBattleStruct->expGetterID) && !(gAbsentBattlerFlags & gBitTable[2]))
-                            gBattleStruct->expGetterBank = 2;
+                        if (!(gBattlerPartyIndexes[2] != gBattleStruct->expGetterMonId) && !(gAbsentBattlerFlags & gBitTable[2]))
+                            gBattleStruct->expGetterBattlerId = 2;
                         else
                         {
                             if (!(gAbsentBattlerFlags & gBitTable[0]))
-                                gBattleStruct->expGetterBank = 0;
+                                gBattleStruct->expGetterBattlerId = 0;
                             else
-                                gBattleStruct->expGetterBank = 2;
+                                gBattleStruct->expGetterBattlerId = 2;
                         }
                     }
                     else
-                        gBattleStruct->expGetterBank = 0;
+                        gBattleStruct->expGetterBattlerId = 0;
 
-                    PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gBattleStruct->expGetterBank, gBattleStruct->expGetterID)
+                    PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gBattleStruct->expGetterBattlerId, gBattleStruct->expGetterMonId)
 
 					// buffer 'gained' or 'gained a boosted'
 					PREPARE_STRING_BUFFER(gBattleTextBuff2, i)
 
                     PREPARE_WORD_NUMBER_BUFFER(gBattleTextBuff3, 5, gBattleMoveDamage)
 
-                    PrepareStringBattle(STRINGID_PKMNGAINEDEXP, gBattleStruct->expGetterBank);
-                    MonGainEVs(&gPlayerParty[gBattleStruct->expGetterID], gBattleMons[gBank1].species);
+                    PrepareStringBattle(STRINGID_PKMNGAINEDEXP, gBattleStruct->expGetterBattlerId);
+                    MonGainEVs(&gPlayerParty[gBattleStruct->expGetterMonId], gBattleMons[gBank1].species);
                 }
                 gBattleStruct->sentInPokes >>= 1;
                 gBattleStruct->getexpStateTracker++;
@@ -5530,19 +5475,19 @@ static void atk23_getexp(void)
     case 3: // Set stats and give exp
         if (gBattleControllerExecFlags == 0)
         {
-            gBattleBufferB[gBattleStruct->expGetterBank][0] = 0;
-            if (GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_HP) && GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_LEVEL) != 100)
+            gBattleBufferB[gBattleStruct->expGetterBattlerId][0] = 0;
+            if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP) && GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) != 100)
             {
-                gBattleResources_statsBeforeLvlUp->hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_MAX_HP);
-                gBattleResources_statsBeforeLvlUp->atk = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_ATK);
-                gBattleResources_statsBeforeLvlUp->def = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_DEF);
-                gBattleResources_statsBeforeLvlUp->spd = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPEED);
-                gBattleResources_statsBeforeLvlUp->spAtk = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPATK);
-                gBattleResources_statsBeforeLvlUp->spDef = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPDEF);
+                gBattleResources_statsBeforeLvlUp->hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_MAX_HP);
+                gBattleResources_statsBeforeLvlUp->atk = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_ATK);
+                gBattleResources_statsBeforeLvlUp->def = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_DEF);
+                gBattleResources_statsBeforeLvlUp->spd = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
+                gBattleResources_statsBeforeLvlUp->spAtk = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPATK);
+                gBattleResources_statsBeforeLvlUp->spDef = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPDEF);
 
-                gActiveBattler = gBattleStruct->expGetterBank;
+                gActiveBattler = gBattleStruct->expGetterBattlerId;
 
-                BtlController_EmitExpUpdate(0, gBattleStruct->expGetterID, gBattleMoveDamage);
+                BtlController_EmitExpUpdate(0, gBattleStruct->expGetterMonId, gBattleMoveDamage);
                 MarkBattlerForControllerExec(gActiveBattler);
             }
             gBattleStruct->getexpStateTracker++;
@@ -5551,49 +5496,49 @@ static void atk23_getexp(void)
     case 4: // lvl up if necessary
         if (gBattleControllerExecFlags == 0)
         {
-            gActiveBattler = gBattleStruct->expGetterBank;
+            gActiveBattler = gBattleStruct->expGetterBattlerId;
             if (gBattleBufferB[gActiveBattler][0] == CONTROLLER_TWORETURNVALUES
              && gBattleBufferB[gActiveBattler][1] == RET_VALUE_LEVELLED_UP)
             {
-                if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterID)
+                if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterMonId)
                     HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
 
-                PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gActiveBattler, gBattleStruct->expGetterID)
+                PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gActiveBattler, gBattleStruct->expGetterMonId)
 
-                PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff2, 3, GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_LEVEL))
+                PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff2, 3, GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL))
 
                 BattleScriptPushCursor();
-                gLeveledUpInBattle |= gBitTable[gBattleStruct->expGetterID];
+                gLeveledUpInBattle |= gBitTable[gBattleStruct->expGetterMonId];
                 gBattlescriptCurrInstr = BattleScript_LevelUp;
                 gBattleMoveDamage = (gBattleBufferB[gActiveBattler][2] | (gBattleBufferB[gActiveBattler][3] << 8));
-                AdjustFriendship(&gPlayerParty[gBattleStruct->expGetterID], FRIENDSHIP_EVENT_GROW_LEVEL);
+                AdjustFriendship(&gPlayerParty[gBattleStruct->expGetterMonId], FRIENDSHIP_EVENT_GROW_LEVEL);
 
                 // update battle mon structure after level up
-                if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterID && gBattleMons[0].hp)
+                if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId && gBattleMons[0].hp)
                 {
-                    gBattleMons[0].level = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_LEVEL);
-                    gBattleMons[0].hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_HP);
-                    gBattleMons[0].maxHP = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_MAX_HP);
-                    gBattleMons[0].attack = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_ATK);
-                    gBattleMons[0].defense = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_DEF);
+                    gBattleMons[0].level = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL);
+                    gBattleMons[0].hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP);
+                    gBattleMons[0].maxHP = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_MAX_HP);
+                    gBattleMons[0].attack = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_ATK);
+                    gBattleMons[0].defense = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_DEF);
                     // Why is this duplicated?
-                    gBattleMons[0].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPEED);
-                    gBattleMons[0].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPEED);
-                    gBattleMons[0].spAttack = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPATK);
-                    gBattleMons[0].spDefense = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPDEF);
+                    gBattleMons[0].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
+                    gBattleMons[0].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
+                    gBattleMons[0].spAttack = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPATK);
+                    gBattleMons[0].spDefense = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPDEF);
                 }
                 // What is else if?
-                if (gBattlerPartyIndexes[2] == gBattleStruct->expGetterID && gBattleMons[2].hp && (gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+                if (gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId && gBattleMons[2].hp && (gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
                 {
-                    gBattleMons[2].level = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_LEVEL);
-                    gBattleMons[2].hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_HP);
-                    gBattleMons[2].maxHP = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_MAX_HP);
-                    gBattleMons[2].attack = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_ATK);
-                    gBattleMons[2].defense = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_DEF);
+                    gBattleMons[2].level = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL);
+                    gBattleMons[2].hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP);
+                    gBattleMons[2].maxHP = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_MAX_HP);
+                    gBattleMons[2].attack = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_ATK);
+                    gBattleMons[2].defense = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_DEF);
                     // Duplicated again, but this time there's no Sp Defense
-                    gBattleMons[2].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPEED);
-                    gBattleMons[2].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPEED);
-                    gBattleMons[2].spAttack = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_SPATK);
+                    gBattleMons[2].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
+                    gBattleMons[2].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
+                    gBattleMons[2].spAttack = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPATK);
                 }
             }
             else
@@ -5608,8 +5553,8 @@ static void atk23_getexp(void)
             gBattleStruct->getexpStateTracker = 3;
         else
         {
-            gBattleStruct->expGetterID++;
-            if (gBattleStruct->expGetterID <= 5)
+            gBattleStruct->expGetterMonId++;
+            if (gBattleStruct->expGetterMonId <= 5)
                 gBattleStruct->getexpStateTracker = 2; // loop again
             else
                 gBattleStruct->getexpStateTracker = 6; // we're done
@@ -5641,7 +5586,7 @@ static void atk24(void)
     }
 
     if (HP_count == 0)
-        gBattleOutcome |= BATTLE_LOST;
+        gBattleOutcome |= B_OUTCOME_LOST;
 
     for (HP_count = 0, i = 0; i < 6; i++)
     {
@@ -5650,7 +5595,7 @@ static void atk24(void)
     }
 
     if (!HP_count)
-        gBattleOutcome |= BATTLE_WON;
+        gBattleOutcome |= B_OUTCOME_WON;
 
     if (!gBattleOutcome && (gBattleTypeFlags & BATTLE_TYPE_LINK))
     {
@@ -6271,7 +6216,7 @@ static void atk41_call(void)
 
 static void atk42_jumpiftype2(void) //u8 bank, u8 type, *ptr
 {
-    u8 bank = GetBattleBank(T1_READ_8(gBattlescriptCurrInstr + 1));
+    u8 bank = GetBattlerForBattleScript(T1_READ_8(gBattlescriptCurrInstr + 1));
 
     if (T1_READ_8(gBattlescriptCurrInstr + 2) == gBattleMons[bank].type1 || T1_READ_8(gBattlescriptCurrInstr + 2) == gBattleMons[bank].type2)
         gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 3);
@@ -6296,7 +6241,7 @@ static void atk45_playanimation(void)
 {
     const u16* argumentPtr;
 
-    gActiveBattler = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     argumentPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 3);
 
     if (gBattlescriptCurrInstr[2] == B_ANIM_STATS_CHANGE
@@ -6338,7 +6283,7 @@ static void atk46_playanimation2(void) // animation Id is stored in the first po
     const u16* argumentPtr;
     const u8* animationIdPtr;
 
-    gActiveBattler = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     animationIdPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 2);
     argumentPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 6);
 
@@ -6407,7 +6352,7 @@ static void atk48_playstatchangeanimation(void)
     u32 stats_to_check;
     u8 arg3;
 
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     stats_to_check = T2_READ_8(gBattlescriptCurrInstr + 2);
     arg3 = T2_READ_8(gBattlescriptCurrInstr + 3);
     if (arg3 & 1)
@@ -6499,7 +6444,7 @@ push {r4-r7,lr}\n\
     ldr r0, [r5]\n\
     ldrb r0, [r0, 0x1]\n\
     str r3, [sp]\n\
-    bl GetBattleBank\n\
+    bl GetBattlerForBattleScript\n\
     ldr r2, _08021674 @ =gActiveBattler\n\
     strb r0, [r2]\n\
     ldr r0, [r5]\n\
@@ -6815,12 +6760,12 @@ void atk49_moveend(void)
             gBattleStruct->cmd49StateTracker++;
             break;
         case ATK49_DEFROST: // defrosting check
-            if (gBattleMons[gBattlerTarget].status1 & STATUS_FREEZE
+            if (gBattleMons[gBattlerTarget].status1 & STATUS1_FREEZE
                 && gBattleMons[gBattlerTarget].hp && gBattlerAttacker != gBattlerTarget
                 && gSpecialStatuses[gBattlerTarget].specialDmg
                 && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT) && moveType == TYPE_FIRE)
             {
-                gBattleMons[gBattlerTarget].status1 &= ~(STATUS_FREEZE);
+                gBattleMons[gBattlerTarget].status1 &= ~(STATUS1_FREEZE);
                 gActiveBattler = gBattlerTarget;
                 BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerTarget].status1);
                 MarkBattlerForControllerExec(gActiveBattler);
@@ -6939,12 +6884,12 @@ void atk49_moveend(void)
             gBattleStruct->cmd49StateTracker++;
             break;
         case ATK49_UPDATE_LAST_MOVES:
-            if (gHitMarker & HITMARKER_PURSUIT_TRAP)
+            if (gHitMarker & HITMARKER_SWAP_ATTACKER_TARGET)
             {
                 gActiveBattler = gBattlerAttacker;
                 gBattlerAttacker = gBattlerTarget;
                 gBattlerTarget = gActiveBattler;
-                gHitMarker &= ~(HITMARKER_PURSUIT_TRAP);
+                gHitMarker &= ~(HITMARKER_SWAP_ATTACKER_TARGET);
             }
 
             if (gBattleMoves[gChosenMove].effect != 0x7F || (gMoveResultFlags & 0x29))
@@ -6956,12 +6901,12 @@ void atk49_moveend(void)
             {
                 if (gHitMarker & HITMARKER_OBEYS)
                 {
-                    gLastUsedMove[gBattlerAttacker] = gChosenMove;
+                    gLastMoves[gBattlerAttacker] = gChosenMove;
                     gUnknown_02024C4C[gBattlerAttacker] = gCurrentMove;
                 }
                 else
                 {
-                    gLastUsedMove[gBattlerAttacker] = 0xFFFF;
+                    gLastMoves[gBattlerAttacker] = 0xFFFF;
                     gUnknown_02024C4C[gBattlerAttacker] = 0xFFFF;
                 }
 
@@ -7053,14 +6998,14 @@ static void atk4A_typecalc2(void)
 {
     u8 flags = 0;
     int i = 0;
-    u8 move_type = gBattleMoves[gCurrentMove].type;
+    u8 moveType = gBattleMoves[gCurrentMove].type;
 
-    if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && move_type == TYPE_GROUND)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
         gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
         gMoveResultFlags |= (MOVE_RESULT_MISSED | MOVE_RESULT_DOESNT_AFFECT_FOE);
         gLastLandedMoves[gBattlerTarget] = 0;
-        gBattleCommunication[6] = move_type;
+        gBattleCommunication[6] = moveType;
         RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
     else
@@ -7073,7 +7018,7 @@ static void atk4A_typecalc2(void)
                 else {i += 3; continue;}
             }
 
-            if (gTypeEffectiveness[i] == move_type)
+            if (gTypeEffectiveness[i] == moveType)
             {
                 //check type1
                 if (gTypeEffectiveness[i + 1] == gBattleMons[gBattlerTarget].type1)
@@ -7140,7 +7085,7 @@ static void atk4C_getswitchedmondata(void)
     if (gBattleControllerExecFlags)
         return;
 
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
 
     gBattlerPartyIndexes[gActiveBattler] = ewram16068arr(gActiveBattler);
 
@@ -7158,7 +7103,7 @@ static void atk4D_switchindataupdate(void)
     if (gBattleControllerExecFlags)
         return;
 
-    gActiveBattler = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     oldData = gBattleMons[gActiveBattler];
     monData = (u8*)(&gBattleMons[gActiveBattler]);
 
@@ -7201,7 +7146,7 @@ static void atk4E_switchinanim(void)
     if (gBattleControllerExecFlags)
         return;
 
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     if (GetBattlerSide(gActiveBattler) == 1 && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER)))
     {
         GetSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gActiveBattler].species), 2);
@@ -7218,7 +7163,7 @@ static void atk4F_jumpifcantswitch(void)
     register struct Pokemon *party;
     u8 r7;
     //0x80 byte is used as a way of telling the function whether to not check status2/status3
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1) & 0x7F);
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1) & 0x7F);
     if (!(T2_READ_8(gBattlescriptCurrInstr + 1) & 0x80)
         && ((gBattleMons[gActiveBattler].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION))
             || (gStatuses3[gActiveBattler] & STATUS3_ROOTED)))
@@ -8170,7 +8115,7 @@ _08023170:\n\
 _0802317C:\n\
     movs r0, 0x7F\n\
     ands r0, r2\n\
-    bl GetBattleBank\n\
+    bl GetBattlerForBattleScript\n\
     lsls r0, 24\n\
     lsrs r7, r0, 24\n\
     ldr r1, _080231A4 @ =gSpecialStatuses\n\
@@ -8366,7 +8311,7 @@ static void atk51_switchhandleorder(void)
     if (gBattleControllerExecFlags)
         return;
 
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     switch (T2_READ_8(gBattlescriptCurrInstr + 2))
     {
     case 0:
@@ -8415,17 +8360,17 @@ static void atk52_switchineffects(void)
 {
     int i;
 
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     sub_80157C4(gActiveBattler);
     gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
     gSpecialStatuses[gActiveBattler].flag40 = 0;
 
-    if (!(gSideAffecting[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_SPIKES_DAMAGED) && (gSideAffecting[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_SPIKES)
+    if (!(gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_SPIKES_DAMAGED) && (gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_SPIKES)
         && gBattleMons[gActiveBattler].type1 != TYPE_FLYING && gBattleMons[gActiveBattler].type2 != TYPE_FLYING && gBattleMons[gActiveBattler].ability != ABILITY_LEVITATE)
     {
         u8 spikesDmg;
 
-        gSideAffecting[GetBattlerSide(gActiveBattler)] |= SIDE_STATUS_SPIKES_DAMAGED;
+        gSideStatuses[GetBattlerSide(gActiveBattler)] |= SIDE_STATUS_SPIKES_DAMAGED;
 
         spikesDmg = (5 - gSideTimers[GetBattlerSide(gActiveBattler)].spikesAmount) * 2;
         gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / (spikesDmg);
@@ -8451,11 +8396,11 @@ static void atk52_switchineffects(void)
 
         if (AbilityBattleEffects(0, gActiveBattler, 0, 0, 0) == 0 && ItemBattleEffects(0, gActiveBattler, 0) == 0)
         {
-            gSideAffecting[GetBattlerSide(gActiveBattler)] &= ~(SIDE_STATUS_SPIKES_DAMAGED);
+            gSideStatuses[GetBattlerSide(gActiveBattler)] &= ~(SIDE_STATUS_SPIKES_DAMAGED);
 
             for (i = 0; i < gBattlersCount; i++)
             {
-                if (gBanksByTurnOrder[i] == gActiveBattler)
+                if (gBattlerByTurnOrder[i] == gActiveBattler)
                     gActionsByTurnOrder[i] = 0xC;
             }
 
@@ -8512,7 +8457,7 @@ static void atk55_fanfare(void)
 
 static void atk56_playfaintcry(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     BtlController_EmitFaintingCry(0);
     MarkBattlerForControllerExec(gActiveBattler);
     gBattlescriptCurrInstr += 2;
@@ -8528,7 +8473,7 @@ static void atk57(void)
 
 static void atk58_returntoball(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     BtlController_EmitReturnMonToBall(0, 1);
     MarkBattlerForControllerExec(gActiveBattler);
     gBattlescriptCurrInstr += 2;
@@ -8539,9 +8484,9 @@ void atk59_handlelearnnewmove(void)
     u8* loc1 = T1_READ_PTR(gBattlescriptCurrInstr + 1);
     u8* loc2 = T1_READ_PTR(gBattlescriptCurrInstr + 5);
 
-    u16 ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterID], T2_READ_8(gBattlescriptCurrInstr + 9));
+    u16 ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterMonId], T2_READ_8(gBattlescriptCurrInstr + 9));
     while (ret == 0xFFFE)
-        ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterID], 0);
+        ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterMonId], 0);
 
     if (ret == 0)
     {
@@ -8554,12 +8499,12 @@ void atk59_handlelearnnewmove(void)
     else
     {
         gActiveBattler = GetBattlerAtPosition(0);
-        if (gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterID && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
+        if (gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterMonId && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
             GiveMoveToBattleMon(&gBattleMons[gActiveBattler], ret);
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) //what is else if
         {
             gActiveBattler = GetBattlerAtPosition(2);
-            if (gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterID && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
+            if (gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterMonId && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
                 GiveMoveToBattleMon(&gBattleMons[gActiveBattler], ret);
         }
         gBattlescriptCurrInstr = loc1;
@@ -8628,7 +8573,7 @@ static void atk5A_yesnoboxlearnmove(void)
     case 2:
         if (!gPaletteFade.active)
         {
-            ShowSelectMovePokemonSummaryScreen(gPlayerParty, gBattleStruct->expGetterID, gPlayerPartyCount - 1, ReshowBattleScreenAfterMenu, gMoveToLearn);
+            ShowSelectMovePokemonSummaryScreen(gPlayerParty, gBattleStruct->expGetterMonId, gPlayerPartyCount - 1, ReshowBattleScreenAfterMenu, gMoveToLearn);
             gBattleStruct->atk5A_StateTracker++;
         }
         break;
@@ -8642,7 +8587,7 @@ static void atk5A_yesnoboxlearnmove(void)
             }
             else
             {
-                u16 move = GetMonData(&gPlayerParty[gBattleStruct->expGetterID], MON_DATA_MOVE1 + move_pos);
+                u16 move = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_MOVE1 + move_pos);
                 if (IsHMMove2(move))
                 {
                     PrepareStringBattle(0x13F, gActiveBattler);
@@ -8662,16 +8607,16 @@ static void atk5A_yesnoboxlearnmove(void)
                         ptr += 4;
                     }
                     ptr[0] = 0xFF;
-                    RemoveMonPPBonus(&gPlayerParty[gBattleStruct->expGetterID], move_pos);
-                    SetMonMoveSlot(&gPlayerParty[gBattleStruct->expGetterID], gMoveToLearn, move_pos);
-                    if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterID && !(gBattleMons[0].status2 & STATUS2_TRANSFORMED)
-                        && !(gDisableStructs[0].unk18_b & gBitTable[move_pos]))
+                    RemoveMonPPBonus(&gPlayerParty[gBattleStruct->expGetterMonId], move_pos);
+                    SetMonMoveSlot(&gPlayerParty[gBattleStruct->expGetterMonId], gMoveToLearn, move_pos);
+                    if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId && !(gBattleMons[0].status2 & STATUS2_TRANSFORMED)
+                        && !(gDisableStructs[0].mimickedMoves & gBitTable[move_pos]))
                     {
                         RemoveBattleMonPPBonus(&gBattleMons[0], move_pos);
                         SetBattleMonMoveSlot(&gBattleMons[0], gMoveToLearn, move_pos);
                     }
-                    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && gBattlerPartyIndexes[2] == gBattleStruct->expGetterID && !(gBattleMons[2].status2 & STATUS2_TRANSFORMED)
-                        && !(gDisableStructs[2].unk18_b & gBitTable[move_pos]))
+                    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId && !(gBattleMons[2].status2 & STATUS2_TRANSFORMED)
+                        && !(gDisableStructs[2].mimickedMoves & gBitTable[move_pos]))
                     {
                         RemoveBattleMonPPBonus(&gBattleMons[2], move_pos);
                         SetBattleMonMoveSlot(&gBattleMons[2], gMoveToLearn, move_pos);
@@ -8738,7 +8683,7 @@ static void atk5B_yesnoboxstoplearningmove(void)
 
 static void atk5C_hitanimation(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT)
         gBattlescriptCurrInstr += 2;
     else if (!(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE) || !(gBattleMons[gActiveBattler].status2 & STATUS2_SUBSTITUTE) || gDisableStructs[gActiveBattler].substituteHP == 0)
@@ -9076,9 +9021,9 @@ static void atk5D_getmoneyreward(void)
 }
 */
 
-static void atk5E_8025A70(void)
+static void atk5E(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     switch (gBattleCommunication[0])
     {
     case 0:
@@ -9102,16 +9047,16 @@ static void atk5E_8025A70(void)
     }
 }
 
-static void atk5F_8025B24(void)
+static void atk5F_swapattackerwithtarget(void)
 {
     gActiveBattler = gBattlerAttacker;
     gBattlerAttacker = gBattlerTarget;
     gBattlerTarget = gActiveBattler;
     //what is xor...
-    if (gHitMarker & HITMARKER_PURSUIT_TRAP)
-        gHitMarker &= ~(HITMARKER_PURSUIT_TRAP);
+    if (gHitMarker & HITMARKER_SWAP_ATTACKER_TARGET)
+        gHitMarker &= ~(HITMARKER_SWAP_ATTACKER_TARGET);
     else
-        gHitMarker |= HITMARKER_PURSUIT_TRAP;
+        gHitMarker |= HITMARKER_SWAP_ATTACKER_TARGET;
     gBattlescriptCurrInstr++;
 }
 
@@ -9132,7 +9077,7 @@ static void atk61_drawpartystatussummary(void)
     if (gBattleControllerExecFlags)
         return;
 
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     if (GetBattlerSide(gActiveBattler) == 0)
         party = gPlayerParty;
     else
@@ -9156,9 +9101,9 @@ static void atk61_drawpartystatussummary(void)
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk62_08025C6C(void)
+static void atk62_hidepartystatussummary(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     BtlController_EmitHidePartyStatusSummary(0);
     MarkBattlerForControllerExec(gActiveBattler);
     gBattlescriptCurrInstr += 2;
@@ -9177,7 +9122,7 @@ static void atk64_statusanimation(void)
 {
     if (gBattleControllerExecFlags == 0)
     {
-        gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
         if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) && gDisableStructs[gActiveBattler].substituteHP == 0 && !(gHitMarker & HITMARKER_NO_ANIMATIONS))
         {
             BtlController_EmitStatusAnimation(0, 0, gBattleMons[gActiveBattler].status1);
@@ -9192,7 +9137,7 @@ static void atk65_status2animation(void)
     if (gBattleControllerExecFlags == 0)
     {
         u32 possible_to_anim;
-        gActiveBattler = GetBattleBank(T1_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(T1_READ_8(gBattlescriptCurrInstr + 1));
         possible_to_anim = T1_READ_32(gBattlescriptCurrInstr + 2);
         if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) && gDisableStructs[gActiveBattler].substituteHP == 0 && !(gHitMarker & HITMARKER_NO_ANIMATIONS))
         {
@@ -9208,7 +9153,7 @@ static void atk66_chosenstatusanimation(void)
     if (gBattleControllerExecFlags == 0)
     {
         u32 status;
-        gActiveBattler = GetBattleBank(T1_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(T1_READ_8(gBattlescriptCurrInstr + 1));
         status = T1_READ_32(gBattlescriptCurrInstr + 3);
         if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) && gDisableStructs[gActiveBattler].substituteHP == 0 && !(gHitMarker & HITMARKER_NO_ANIMATIONS))
         {
@@ -9273,20 +9218,20 @@ static void atk68_cancelallactions(void)
 
 static void atk69_adjustsetdamage(void) //literally a copy of atk07 except theres no rand dmg modifier...
 {
-    u8 hold_effect, quality;
+    u8 holdEffect, param;
     if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
-        hold_effect = gEnigmaBerries[gBattlerTarget].holdEffect, quality = gEnigmaBerries[gBattlerTarget].holdEffectParam;
+        holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect, param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     else
     {
-        hold_effect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
-        quality = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
     gPotentialItemEffectBattler = gBattlerTarget;
 
-    if (hold_effect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < quality)
+    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemBattle(gBattlerTarget, hold_effect);
+        RecordItemEffectBattle(gBattlerTarget, holdEffect);
         gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
     if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE)
@@ -9316,7 +9261,7 @@ static void atk69_adjustsetdamage(void) //literally a copy of atk07 except there
 
 void atk6A_removeitem(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     USED_HELD_ITEMS(gActiveBattler) = gBattleMons[gActiveBattler].item;
 
     gBattleMons[gActiveBattler].item = 0;
@@ -9778,7 +9723,7 @@ static void atk6E_setatktoplayer0(void)
 
 static void atk6F_makevisible(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     BtlController_EmitSpriteInvisibility(0, 0);
     MarkBattlerForControllerExec(gActiveBattler);
     gBattlescriptCurrInstr += 2;
@@ -9786,7 +9731,7 @@ static void atk6F_makevisible(void)
 
 static void atk70_recordlastability(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     RecordAbilityBattle(gActiveBattler, gLastUsedAbility);
     gBattlescriptCurrInstr += 1; //buggy, should be += 2, one byte for command, one byte for argument...
 }
@@ -9820,7 +9765,7 @@ static void atk73_hpthresholds(void)
     s32 result;
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
     {
-        gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
         opposing_bank = gActiveBattler ^ 1;
 
         result = gBattleMons[opposing_bank].hp * 100 / gBattleMons[opposing_bank].maxHP;
@@ -9847,7 +9792,7 @@ static void atk74_hpthresholds2(void)
     s32 result;
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
     {
-        gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
         opposing_bank = gActiveBattler ^ 1;
         hp_switchout = ewram160BCarr(GetBattlerSide(opposing_bank)); //gBattleStruct->HP_OnSwitchout[GetBattlerSide(opposing_bank)];
         result = (hp_switchout - gBattleMons[opposing_bank].hp) * 100 / hp_switchout;
@@ -9874,7 +9819,7 @@ static void atk75_useitemonopponent(void)
 
 static void atk76_various(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     switch (T2_READ_8(gBattlescriptCurrInstr + 2))
     {
     case 0:
@@ -9911,9 +9856,9 @@ static void atk76_various(void)
         {
             int i;
             u16* choiced_move;
-            if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterID)
+            if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId)
                 goto ACTIVE_0;
-            if (gBattlerPartyIndexes[2] != gBattleStruct->expGetterID)
+            if (gBattlerPartyIndexes[2] != gBattleStruct->expGetterMonId)
                 break;
             if (gBattlerPartyIndexes[0] == gBattlerPartyIndexes[2])
             {
@@ -10123,14 +10068,14 @@ static void atk7D_setrain(void)
 
 static void atk7E_setreflect(void)
 {
-    if (gSideAffecting[GetBattlerPosition(gBattlerAttacker) & 1] & SIDE_STATUS_REFLECT)
+    if (gSideStatuses[GetBattlerPosition(gBattlerAttacker) & 1] & SIDE_STATUS_REFLECT)
     {
         gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     else
     {
-        gSideAffecting[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_REFLECT;
+        gSideStatuses[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_REFLECT;
         gSideTimers[GetBattlerPosition(gBattlerAttacker) & 1].reflectTimer = 5;
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && CountAliveMons(1) == 2)
             gBattleCommunication[MULTISTRING_CHOOSER] = 2;
@@ -10193,7 +10138,7 @@ static void atk81_trysetrest(void)
         gBattlescriptCurrInstr = fail_loc;
     else
     {
-        if (gBattleMons[gBattlerTarget].status1 & ((u8)(~STATUS_SLEEP)))
+        if (gBattleMons[gBattlerTarget].status1 & ((u8)(~STATUS1_SLEEP)))
             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
         else
             gBattleCommunication[MULTISTRING_CHOOSER] = 0;
@@ -10293,7 +10238,7 @@ static void atk86_stockpiletobasedamage(void)
         if (gBattleCommunication[6] != 1)
         {
             gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[gBattlerAttacker], &gBattleMons[gBattlerTarget], gCurrentMove,
-                                                    gSideAffecting[GetBattlerPosition(gBattlerTarget) & 1], 0,
+                                                    gSideStatuses[GetBattlerPosition(gBattlerTarget) & 1], 0,
                                                     0, gBattlerAttacker, gBattlerTarget)
                                 * gDisableStructs[gBattlerAttacker].stockpileCounter;
             gBattleStruct->animTurn = gDisableStructs[gBattlerAttacker].stockpileCounter;
@@ -10688,7 +10633,7 @@ static void atk90_tryconversiontypechange(void)
     //randomly changes user's type to one of its moves' type
     u8 valid_moves = 0;
     u8 checked_move;
-    u8 move_type;
+    u8 moveType;
     while (valid_moves < 4)
     {
         if (gBattleMons[gBattlerAttacker].moves[valid_moves] == 0)
@@ -10698,15 +10643,15 @@ static void atk90_tryconversiontypechange(void)
 
     for (checked_move = 0; checked_move < valid_moves; checked_move++)
     {
-        move_type = gBattleMoves[gBattleMons[gBattlerAttacker].moves[checked_move]].type;
-        if (move_type == TYPE_MYSTERY)
+        moveType = gBattleMoves[gBattleMons[gBattlerAttacker].moves[checked_move]].type;
+        if (moveType == TYPE_MYSTERY)
         {
             if (gBattleMons[gBattlerAttacker].type1 == TYPE_GHOST || gBattleMons[gBattlerAttacker].type2 == TYPE_GHOST)
-                move_type = TYPE_GHOST;
+                moveType = TYPE_GHOST;
             else
-                move_type = TYPE_NORMAL;
+                moveType = TYPE_NORMAL;
         }
-        if (move_type != gBattleMons[gBattlerAttacker].type1 && move_type != gBattleMons[gBattlerAttacker].type2)
+        if (moveType != gBattleMons[gBattlerAttacker].type1 && moveType != gBattleMons[gBattlerAttacker].type2)
             break;
     }
 
@@ -10721,22 +10666,22 @@ static void atk90_tryconversiontypechange(void)
 
             while ((checked_move = Random() & 3) >= valid_moves);
 
-            move_type = gBattleMoves[gBattleMons[gBattlerAttacker].moves[checked_move]].type;
-            if (move_type == TYPE_MYSTERY)
+            moveType = gBattleMoves[gBattleMons[gBattlerAttacker].moves[checked_move]].type;
+            if (moveType == TYPE_MYSTERY)
             {
                 if (gBattleMons[gBattlerAttacker].type1 == TYPE_GHOST || gBattleMons[gBattlerAttacker].type2 == TYPE_GHOST)
-                    move_type = TYPE_GHOST;
+                    moveType = TYPE_GHOST;
                 else
-                    move_type = TYPE_NORMAL;
+                    moveType = TYPE_NORMAL;
             }
-        } while (move_type == gBattleMons[gBattlerAttacker].type1 || move_type == gBattleMons[gBattlerAttacker].type2);
+        } while (moveType == gBattleMons[gBattlerAttacker].type1 || moveType == gBattleMons[gBattlerAttacker].type2);
 
-        gBattleMons[gBattlerAttacker].type1 = move_type;
-        gBattleMons[gBattlerAttacker].type2 = move_type;
+        gBattleMons[gBattlerAttacker].type1 = moveType;
+        gBattleMons[gBattlerAttacker].type2 = moveType;
 
         gBattleTextBuff1[0] = 0xFD;
         gBattleTextBuff1[1] = 3;
-        gBattleTextBuff1[2] = move_type;
+        gBattleTextBuff1[2] = moveType;
         gBattleTextBuff1[3] = 0xFF;
 
         gBattlescriptCurrInstr += 5;
@@ -10764,14 +10709,14 @@ static void atk91_givepaydaymoney(void)
 
 static void atk92_setlightscreen(void)
 {
-    if (gSideAffecting[GetBattlerPosition(gBattlerAttacker) & 1] & SIDE_STATUS_LIGHTSCREEN)
+    if (gSideStatuses[GetBattlerPosition(gBattlerAttacker) & 1] & SIDE_STATUS_LIGHTSCREEN)
     {
         gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     else
     {
-        gSideAffecting[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_LIGHTSCREEN;
+        gSideStatuses[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_LIGHTSCREEN;
         gSideTimers[GetBattlerPosition(gBattlerAttacker) & 1].lightscreenTimer = 5;
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && CountAliveMons(1) == 2)
             gBattleCommunication[MULTISTRING_CHOOSER] = 4;
@@ -10785,18 +10730,18 @@ static void atk92_setlightscreen(void)
 static void atk93_tryKO(void)
 {
    if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
-        hold_effect = gEnigmaBerries[gBattlerTarget].holdEffect, quality = gEnigmaBerries[gBattlerTarget].holdEffectParam;
+        holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect, param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     else
     {
-        hold_effect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
-        quality = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
     gPotentialItemEffectBattler = gBattlerTarget;
 
-    if (hold_effect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < quality)
+    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemBattle(gBattlerTarget, hold_effect);
+        RecordItemEffectBattle(gBattlerTarget, holdEffect);
         gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
 
@@ -10819,7 +10764,7 @@ static void atk93_tryKO(void)
     }
     else
     {
-        if (gDisableStructs[gBattlerTarget].bankWithSureHit != gBattlerAttacker || gBattleMons[gBattlerAttacker].level < gBattleMons[gBattlerTarget].level)
+        if (gDisableStructs[gBattlerTarget].battlerWithSureHit != gBattlerAttacker || gBattleMons[gBattlerAttacker].level < gBattleMons[gBattlerTarget].level)
         {
 
         }
@@ -10896,7 +10841,7 @@ _08026BCE:\n\
     bcs _08026C0C\n\
     ldrb r0, [r5]\n\
     movs r1, 0x27\n\
-    bl RecordItemBattle\n\
+    bl RecordItemEffectBattle\n\
     ldr r2, _08026C54 @ =gSpecialStatuses\n\
     ldrb r1, [r5]\n\
     lsls r0, r1, 2\n\
@@ -11303,7 +11248,7 @@ static void atk98_updatestatusicon(void)
 
     if (T2_READ_8(gBattlescriptCurrInstr + 1) != 4)
     {
-        gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+        gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
         BtlController_EmitStatusIconUpdate(0, gBattleMons[gActiveBattler].status1, gBattleMons[gActiveBattler].status2);
         MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 2;
@@ -11339,7 +11284,7 @@ static void atk99_setmist(void)
     else
     {
         gSideTimers[GetBattlerPosition(gBattlerAttacker) & 1].mistTimer = 5;
-        gSideAffecting[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_MIST;
+        gSideStatuses[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_MIST;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     gBattlescriptCurrInstr++;
@@ -11377,7 +11322,7 @@ static void atk9B_transformdataexecution(void)
         gDisableStructs[gBattlerAttacker].disabledMove = 0;
         gDisableStructs[gBattlerAttacker].disableTimer1 = 0;
         gDisableStructs[gBattlerAttacker].transformedMonPersonality = gBattleMons[gBattlerTarget].personality;
-        gDisableStructs[gBattlerAttacker].unk18_b = 0;
+        gDisableStructs[gBattlerAttacker].mimickedMoves = 0;
 
         gBattleTextBuff1[0] = 0xFD;
         gBattleTextBuff1[1] = 6;
@@ -11440,8 +11385,8 @@ static bool8 IsMoveUncopyable(u16 move)
 static void atk9D_mimicattackcopy(void)
 {
     gChosenMove = 0xFFFF;
-    if (IsMoveUncopyable(gLastUsedMove[gBattlerTarget]) || gBattleMons[gBattlerAttacker].status2 & STATUS2_TRANSFORMED
-        || gLastUsedMove[gBattlerTarget] == 0 || gLastUsedMove[gBattlerTarget] == 0xFFFF)
+    if (IsMoveUncopyable(gLastMoves[gBattlerTarget]) || gBattleMons[gBattlerAttacker].status2 & STATUS2_TRANSFORMED
+        || gLastMoves[gBattlerTarget] == 0 || gLastMoves[gBattlerTarget] == 0xFFFF)
     {
         gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1);
     }
@@ -11450,24 +11395,24 @@ static void atk9D_mimicattackcopy(void)
         int i;
         for (i = 0; i < 4; i++)
         {
-            if (gBattleMons[gBattlerAttacker].moves[i] == gLastUsedMove[gBattlerTarget])
+            if (gBattleMons[gBattlerAttacker].moves[i] == gLastMoves[gBattlerTarget])
                 break;
         }
         if (i == 4)
         {
-            gBattleMons[gBattlerAttacker].moves[gCurrMovePos] = gLastUsedMove[gBattlerTarget];
-            if (gBattleMoves[gLastUsedMove[gBattlerTarget]].pp < 5)
-                gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = gBattleMoves[gLastUsedMove[gBattlerTarget]].pp;
+            gBattleMons[gBattlerAttacker].moves[gCurrMovePos] = gLastMoves[gBattlerTarget];
+            if (gBattleMoves[gLastMoves[gBattlerTarget]].pp < 5)
+                gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = gBattleMoves[gLastMoves[gBattlerTarget]].pp;
             else
                 gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = 5;
 
             gBattleTextBuff1[0] = 0xFD;
             gBattleTextBuff1[1] = 2;
-            gBattleTextBuff1[2] = gLastUsedMove[gBattlerTarget];
-            gBattleTextBuff1[3] = uBYTE1_16(gLastUsedMove[gBattlerTarget]);
+            gBattleTextBuff1[2] = gLastMoves[gBattlerTarget];
+            gBattleTextBuff1[3] = uBYTE1_16(gLastMoves[gBattlerTarget]);
             gBattleTextBuff1[4] = 0xFF;
 
-            gDisableStructs[gBattlerAttacker].unk18_b |= gBitTable[gCurrMovePos];
+            gDisableStructs[gBattlerAttacker].mimickedMoves |= gBitTable[gCurrMovePos];
             gBattlescriptCurrInstr += 5;
         }
         else
@@ -11825,7 +11770,7 @@ static void atkA3_disablelastusedattack(void)
     int i;
     for (i = 0; i < 4; i++)
     {
-        if (gBattleMons[gBattlerTarget].moves[i] == gLastUsedMove[gBattlerTarget])
+        if (gBattleMons[gBattlerTarget].moves[i] == gLastMoves[gBattlerTarget])
             break;
     }
     if (gDisableStructs[gBattlerTarget].disabledMove == 0 && i != 4 && gBattleMons[gBattlerTarget].pp[i] != 0)
@@ -11852,10 +11797,10 @@ static void atkA4_trysetencore(void)
     int i;
     for (i = 0; i < 4; i++)
     {
-        if (gBattleMons[gBattlerTarget].moves[i] == gLastUsedMove[gBattlerTarget])
+        if (gBattleMons[gBattlerTarget].moves[i] == gLastMoves[gBattlerTarget])
             break;
     }
-    if (gLastUsedMove[gBattlerTarget] == MOVE_STRUGGLE || gLastUsedMove[gBattlerTarget] == MOVE_ENCORE || gLastUsedMove[gBattlerTarget] == MOVE_MIRROR_MOVE)
+    if (gLastMoves[gBattlerTarget] == MOVE_STRUGGLE || gLastMoves[gBattlerTarget] == MOVE_ENCORE || gLastMoves[gBattlerTarget] == MOVE_MIRROR_MOVE)
         i = 4;
     if (gDisableStructs[gBattlerTarget].encoredMove == 0 && i != 4 && gBattleMons[gBattlerTarget].pp[i] != 0)
     {
@@ -12201,7 +12146,7 @@ static void atkA7_setalwayshitflag(void)
 {
     gStatuses3[gBattlerTarget] &= ~(STATUS3_ALWAYS_HITS);
     gStatuses3[gBattlerTarget] |= 0x10;
-    gDisableStructs[gBattlerTarget].bankWithSureHit = gBattlerAttacker;
+    gDisableStructs[gBattlerTarget].battlerWithSureHit = gBattlerAttacker;
     gBattlescriptCurrInstr++;
 }
 
@@ -12279,7 +12224,7 @@ static u8 AttacksThisTurn(u8 bank, u16 move) //Note: returns 1 if it's a chargin
     effect = gBattleMoves[move].effect;
     if (effect == EFFECT_SKULL_BASH || effect == EFFECT_RAZOR_WIND || effect == EFFECT_SKY_ATTACK || effect == EFFECT_SOLARBEAM || effect == EFFECT_FLY || effect == EFFECT_BIDE)
     {
-        if ((gHitMarker & HITMARKER_x8000000))
+        if ((gHitMarker & HITMARKER_CHARGING))
             return 1;
     }
     return 2;
@@ -12350,12 +12295,12 @@ static void atkAC_remaininghptopower(void)
 
 static void atkAD_tryspiteppreduce(void)
 {
-    if (gLastUsedMove[gBattlerTarget] != 0 && gLastUsedMove[gBattlerTarget] != 0xFFFF && !(gStatuses3[gBattlerTarget] & STATUS3_SEMI_INVULNERABLE))
+    if (gLastMoves[gBattlerTarget] != 0 && gLastMoves[gBattlerTarget] != 0xFFFF && !(gStatuses3[gBattlerTarget] & STATUS3_SEMI_INVULNERABLE))
     {
         int i;
         for (i = 0; i < 4; i++)
         {
-            if (gLastUsedMove[gBattlerTarget] == gBattleMons[gBattlerTarget].moves[i])
+            if (gLastMoves[gBattlerTarget] == gBattleMons[gBattlerTarget].moves[i])
                 break;
         }
         if (i != 4 && gBattleMons[gBattlerTarget].pp[i] > 1)
@@ -12366,8 +12311,8 @@ static void atkAD_tryspiteppreduce(void)
 
             gBattleTextBuff1[0] = 0xFD;
             gBattleTextBuff1[1] = 2;
-            gBattleTextBuff1[2] = gLastUsedMove[gBattlerTarget];
-            gBattleTextBuff1[3] = gLastUsedMove[gBattlerTarget] >> 8;
+            gBattleTextBuff1[2] = gLastMoves[gBattlerTarget];
+            gBattleTextBuff1[3] = gLastMoves[gBattlerTarget] >> 8;
             gBattleTextBuff1[4] = 0xFF;
             ConvertIntToDecimalStringN(gBattleTextBuff2, lost_pp, 0, 1);
             gBattleTextBuff2[0] = 0xFD;
@@ -12379,7 +12324,7 @@ static void atkAD_tryspiteppreduce(void)
 
             gBattleMons[gBattlerTarget].pp[i] -= lost_pp;
             gActiveBattler = gBattlerTarget;
-            if (!(gDisableStructs[gActiveBattler].unk18_b & gBitTable[i])
+            if (!(gDisableStructs[gActiveBattler].mimickedMoves & gBitTable[i])
                 && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
             {
                 BtlController_EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + i, 0, 1, &gBattleMons[gActiveBattler].pp[i]);
@@ -12497,7 +12442,7 @@ static void atkB0_trysetspikes(void)
     }
     else
     {
-        gSideAffecting[side] |= SIDE_STATUS_SPIKES;
+        gSideStatuses[side] |= SIDE_STATUS_SPIKES;
         gSideTimers[side].spikesAmount++;
         gBattlescriptCurrInstr += 5;
     }
@@ -12631,14 +12576,14 @@ static void atkB7_presentdamagecalculation(void)
 
 static void atkB8_setsafeguard(void)
 {
-    if (gSideAffecting[GetBattlerPosition(gBattlerAttacker) & 1] & SIDE_STATUS_SAFEGUARD)
+    if (gSideStatuses[GetBattlerPosition(gBattlerAttacker) & 1] & SIDE_STATUS_SAFEGUARD)
     {
         gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     else
     {
-        gSideAffecting[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_SAFEGUARD;
+        gSideStatuses[GetBattlerPosition(gBattlerAttacker) & 1] |= SIDE_STATUS_SAFEGUARD;
         gSideTimers[GetBattlerPosition(gBattlerAttacker) & 1].safeguardTimer = 5;
         gBattleCommunication[MULTISTRING_CHOOSER] = 5;
     }
@@ -12718,13 +12663,13 @@ static void atkBA_jumpifnopursuitswitchdmg(void)
             gBattlerTarget = GetBattlerAtPosition(2);
     }
 
-    if (gActionForBanks[gBattlerTarget] == 0 && gBattlerAttacker == ewram16010arr(gBattlerTarget) && !(gBattleMons[gBattlerTarget].status1 & (STATUS_SLEEP | STATUS_FREEZE))
+    if (gActionForBanks[gBattlerTarget] == 0 && gBattlerAttacker == ewram16010arr(gBattlerTarget) && !(gBattleMons[gBattlerTarget].status1 & (STATUS1_SLEEP | STATUS1_FREEZE))
         && gBattleMons[gBattlerAttacker].hp && !gDisableStructs[gBattlerTarget].truantCounter && gChosenMovesByBanks[gBattlerTarget] == MOVE_PURSUIT)
     {
         int i;
         for (i = 0; i < gBattlersCount; i++)
         {
-            if (gBanksByTurnOrder[i] == gBattlerTarget)
+            if (gBattlerByTurnOrder[i] == gBattlerTarget)
                 gActionsByTurnOrder[i] = 11;
         }
         gCurrentMove = MOVE_PURSUIT;
@@ -12799,13 +12744,13 @@ static void atkBE_rapidspinfree(void) //rapid spin
     else if (gStatuses3[gBattlerAttacker] & STATUS3_LEECHSEED)
     {
         gStatuses3[gBattlerAttacker] &= ~(STATUS3_LEECHSEED);
-        gStatuses3[gBattlerAttacker] &= ~(STATUS3_LEECHSEED_BANK);
+        gStatuses3[gBattlerAttacker] &= ~(STATUS3_LEECHSEED_BATTLER);
         BattleScriptPushCursor();
         gBattlescriptCurrInstr = BattleScript_LeechSeedFree;
     }
-    else if (gSideAffecting[GetBattlerSide(gBattlerAttacker)] & SIDE_STATUS_SPIKES)
+    else if (gSideStatuses[GetBattlerSide(gBattlerAttacker)] & SIDE_STATUS_SPIKES)
     {
-        gSideAffecting[GetBattlerSide(gBattlerAttacker)] &= ~(SIDE_STATUS_SPIKES);
+        gSideStatuses[GetBattlerSide(gBattlerAttacker)] &= ~(SIDE_STATUS_SPIKES);
         gSideTimers[GetBattlerSide(gBattlerAttacker)].spikesAmount = 0;
         BattleScriptPushCursor();
         gBattlescriptCurrInstr = BattleScript_SpikesFree;
@@ -12892,7 +12837,7 @@ static void atkC3_trysetfutureattack(void)
         gWishFutureKnock.futureSightAttacker[gBattlerTarget] = gBattlerAttacker;
         gWishFutureKnock.futureSightCounter[gBattlerTarget] = 3;
         gWishFutureKnock.futureSightDmg[gBattlerTarget] = CalculateBaseDamage(&gBattleMons[gBattlerAttacker], &gBattleMons[gBattlerTarget], gCurrentMove,
-                                                    gSideAffecting[GetBattlerPosition(gBattlerTarget) & 1], 0,
+                                                    gSideStatuses[GetBattlerPosition(gBattlerTarget) & 1], 0,
                                                     0, gBattlerAttacker, gBattlerTarget);
 
         if (gProtectStructs[gBattlerAttacker].helpingHand)
@@ -13308,7 +13253,7 @@ static void atkCC_callterrainattack(void) //nature power
 
 static void atkCD_cureifburnedparalysedorpoisoned(void) //refresh
 {
-    if (gBattleMons[gBattlerAttacker].status1 & (STATUS_POISON | STATUS_BURN | STATUS_PARALYSIS | STATUS_TOXIC_POISON))
+    if (gBattleMons[gBattlerAttacker].status1 & (STATUS1_POISON | STATUS1_BURN | STATUS1_PARALYSIS | STATUS1_TOXIC_POISON))
     {
         gBattleMons[gBattlerAttacker].status1 = 0;
         gBattlescriptCurrInstr += 5;
@@ -13554,10 +13499,10 @@ static void atkDA_tryswapabilities(void)
     }
 }
 
-static void atkDB_tryimprision(void)
+static void atkDB_tryimprison(void)
 {
     u8 r8 = 0;
-    if ((gStatuses3[gBattlerAttacker] & STATUS3_IMPRISIONED))
+    if ((gStatuses3[gBattlerAttacker] & STATUS3_IMPRISONED_OTHERS))
     {
         gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1);
     }
@@ -13583,7 +13528,7 @@ static void atkDB_tryimprision(void)
                 }
                 if (j != 4)
                 {
-                    gStatuses3[gBattlerAttacker] |= STATUS3_IMPRISIONED;
+                    gStatuses3[gBattlerAttacker] |= STATUS3_IMPRISONED_OTHERS;
                     gBattlescriptCurrInstr += 5;
                     break;
                 }
@@ -13621,7 +13566,7 @@ static void atkDD_weightdamagecalculation(void)
 }
 
 #ifdef NONMATCHING
-static void atkDE_asistattackselect(void)
+static void atkDE_assistattackselect(void)
 {
     u32 chooseable_moves_no = 0;
     struct Pokemon* party;
@@ -13676,7 +13621,7 @@ static void atkDE_asistattackselect(void)
 
 #else
 NAKED
-static void atkDE_asistattackselect(void)
+static void atkDE_assistattackselect(void)
 {
     asm(".syntax unified\n\
     push {r4-r7,lr}\n\
@@ -13914,7 +13859,7 @@ static void atkE1_trygetintimidatetarget(void)
 
 static void atkE2_switchoutabilities(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     switch (gBattleMons[gActiveBattler].ability)
     {
     case ABILITY_NATURAL_CURE:
@@ -13928,7 +13873,7 @@ static void atkE2_switchoutabilities(void)
 
 static void atkE3_jumpifhasnohp(void)
 {
-    gActiveBattler = GetBattleBank(T2_READ_8(gBattlescriptCurrInstr + 1));
+    gActiveBattler = GetBattlerForBattleScript(T2_READ_8(gBattlescriptCurrInstr + 1));
     if (gBattleMons[gActiveBattler].hp == 0)
         gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 2);
     else
@@ -14117,7 +14062,7 @@ static void atkEC_pursuitrelated(void)
         gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1);
 }
 
-static void atkED_snatchsetbanks(void)
+static void atkEF_snatchsetbattlers(void)
 {
     gEffectBattler = gBattlerAttacker;
     if (gBattlerAttacker == gBattlerTarget)
@@ -14133,8 +14078,8 @@ static void atkEE_removelightscreenreflect(void) //brick break
     u8 side = GetBattlerSide(gBattlerAttacker) ^ 1;
     if (gSideTimers[side].reflectTimer || gSideTimers[side].lightscreenTimer)
     {
-        gSideAffecting[side] &= ~(SIDE_STATUS_REFLECT);
-        gSideAffecting[side] &= ~(SIDE_STATUS_LIGHTSCREEN);
+        gSideStatuses[side] &= ~(SIDE_STATUS_REFLECT);
+        gSideStatuses[side] &= ~(SIDE_STATUS_LIGHTSCREEN);
         gSideTimers[side].reflectTimer = 0;
         gSideTimers[side].lightscreenTimer = 0;
         gBattleStruct->animTurn = 1;
@@ -14223,9 +14168,9 @@ void atkEF_handleballthrow(void)
             ball_multiplier = sBallCatchBonuses[gLastUsedItem - 2];
 
         odds = (catch_rate * ball_multiplier / 10) * (gBattleMons[gBattlerTarget].maxHP * 3 - gBattleMons[gBattlerTarget].hp * 2) / (3 * gBattleMons[gBattlerTarget].maxHP);
-        if (gBattleMons[gBattlerTarget].status1 & (STATUS_SLEEP | STATUS_FREEZE))
+        if (gBattleMons[gBattlerTarget].status1 & (STATUS1_SLEEP | STATUS1_FREEZE))
             odds *= 2;
-        if (gBattleMons[gBattlerTarget].status1 & (STATUS_POISON | STATUS_BURN | STATUS_PARALYSIS /*| STATUS_TOXIC_POISON */)) //nice one gf
+        if (gBattleMons[gBattlerTarget].status1 & (STATUS1_POISON | STATUS1_BURN | STATUS1_PARALYSIS /*| STATUS1_TOXIC_POISON */)) //nice one gf
             odds = (odds * 15) / 10;
 
         if (gLastUsedItem != ITEM_SAFARI_BALL)
diff --git a/src/battle_setup.c b/src/battle_setup.c
index 2ad57e961..fb76a2ed2 100644
--- a/src/battle_setup.c
+++ b/src/battle_setup.c
@@ -558,7 +558,7 @@ void ScrSpecial_StartWallyTutorialBattle(void)
 {
     CreateMaleMon(&gEnemyParty[0], SPECIES_RALTS, 5);
     ScriptContext2_Enable();
-    gMain.savedCallback = c2_exit_to_overworld_1_continue_scripts_restart_music;
+    gMain.savedCallback = CB2_ReturnToFieldContinueScriptPlayMapMusic;
     gBattleTypeFlags = BATTLE_TYPE_WALLY_TUTORIAL;
     CreateBattleStartTask(B_TRANSITION_SLICE, 0);
 }
@@ -640,7 +640,7 @@ void CB2_EndScriptedWildBattle(void)
     if (IsPlayerDefeated(gBattleOutcome) == TRUE)
         SetMainCallback2(CB2_WhiteOut);
     else
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+        SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 s8 BattleSetup_GetTerrain(void)
@@ -898,7 +898,7 @@ static void CB2_StartFirstBattle(void)
 static void CB2_EndFirstBattle(void)
 {
     Overworld_ClearSavedMusic();
-    SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+    SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 // why not just use the macros? maybe its because they didnt want to uncast const every time?
@@ -926,14 +926,14 @@ static bool32 IsPlayerDefeated(u32 battleOutcome)
 {
     switch (battleOutcome)
     {
-    case BATTLE_LOST:
-    case BATTLE_DREW:
+    case B_OUTCOME_LOST:
+    case B_OUTCOME_DREW:
         return TRUE;
-    case BATTLE_WON:
-    case BATTLE_RAN:
-    case BATTLE_PLAYER_TELEPORTED:
-    case BATTLE_POKE_FLED:
-    case BATTLE_CAUGHT:
+    case B_OUTCOME_WON:
+    case B_OUTCOME_RAN:
+    case B_OUTCOME_PLAYER_TELEPORTED:
+    case B_OUTCOME_MON_FLED:
+    case B_OUTCOME_CAUGHT:
         return FALSE;
     default:
         return FALSE;
@@ -1107,7 +1107,7 @@ void CB2_EndTrainerBattle(void)
 {
     if (gTrainerBattleOpponent == SECRET_BASE_OPPONENT)
     {
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+        SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
     }
     else if (IsPlayerDefeated(gBattleOutcome) == TRUE)
     {
@@ -1115,7 +1115,7 @@ void CB2_EndTrainerBattle(void)
     }
     else
     {
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+        SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
         SetCurrentTrainerBattledFlag();
     }
 }
@@ -1124,7 +1124,7 @@ void CB2_EndTrainerEyeRematchBattle(void)
 {
     if (gTrainerBattleOpponent == SECRET_BASE_OPPONENT)
     {
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+        SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
     }
     else if (IsPlayerDefeated(gBattleOutcome) == TRUE)
     {
@@ -1132,7 +1132,7 @@ void CB2_EndTrainerEyeRematchBattle(void)
     }
     else
     {
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+        SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
         SetCurrentTrainerBattledFlag();
         SetTrainerFlagsAfterTrainerEyeRematch();
     }
diff --git a/src/battle_tower.c b/src/battle_tower.c
index 8449b7e42..a5b2df0a6 100644
--- a/src/battle_tower.c
+++ b/src/battle_tower.c
@@ -1282,7 +1282,7 @@ void sub_81354CC(void)
         break;
     }
 
-    SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+    SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 void sub_8135534(u8 taskId)
@@ -1805,9 +1805,9 @@ void PrintEReaderTrainerGreeting(void)
 
 void PrintEReaderTrainerFarewellMessage(void)
 {
-    if (gBattleOutcome == BATTLE_DREW)
+    if (gBattleOutcome == B_OUTCOME_DREW)
         gStringVar4[0] = EOS;
-    else if (gBattleOutcome == BATTLE_WON)
+    else if (gBattleOutcome == B_OUTCOME_WON)
         PrintBattleTowerTrainerMessage(gSaveBlock2.battleTower.ereaderTrainer.farewellPlayerWon);
     else
         PrintBattleTowerTrainerMessage(gSaveBlock2.battleTower.ereaderTrainer.farewellPlayerLost);
diff --git a/src/battle_util.c b/src/battle_util.c
index 1825d7a2c..b1260cd4e 100644
--- a/src/battle_util.c
+++ b/src/battle_util.c
@@ -1,6 +1,8 @@
 #include "global.h"
 #include "battle.h"
 #include "battle_util.h"
+#include "battle_controllers.h"
+#include "battle_message.h"
 #include "data2.h"
 #include "event_data.h"
 #include "ewram.h"
@@ -28,7 +30,7 @@ extern const u8* gBattlescriptCurrInstr;
 extern u8 gActiveBattler;
 extern u8 gBattleBufferB[4][0x200];
 extern u8* gSelectionBattleScripts[4]; //battlescript location when you try to choose a move you're not allowed to
-extern u16 gLastUsedMove[4];
+extern u16 gLastMoves[4];
 extern struct BattlePokemon gBattleMons[4];
 extern struct BattleEnigmaBerry gEnigmaBerries[4];
 extern u8 gPotentialItemEffectBattler;
@@ -40,8 +42,8 @@ extern u8 gBattlersCount;
 extern u32 gStatuses3[4];
 extern u8 gBattlerAttacker;
 extern u8 gBattlerTarget;
-extern u8 gBanksByTurnOrder[4];
-extern u16 gSideAffecting[2];
+extern u8 gBattlerByTurnOrder[4];
+extern u16 gSideStatuses[2];
 extern u16 gBattleWeather;
 extern void (*gBattleMainFunc)(void);
 extern u8 gAbsentBattlerFlags;
@@ -53,7 +55,7 @@ extern s32 gBattleMoveDamage;
 extern u16 gBattlerPartyIndexes[4];
 extern u16 gChosenMovesByBanks[4];
 extern s32 gTakenDmg[4];
-extern u8 gTakenDmgBanks[4];
+extern u8 gTakenDmgByBattler[4];
 extern u8 gMoveResultFlags;
 extern u8 gLastUsedAbility;
 extern u8 gBattleTextBuff2[];
@@ -89,7 +91,7 @@ u8 GetMoveTarget(u16 move, u8 useMoveTarget);
 u8 sub_803FC34(u8 bank);
 u16 sub_803FBFC(u8 a);
 void RecordAbilityBattle(u8 bank, u8 ability);
-void RecordItemBattle(u8 bank, u8 holdEffect);
+void RecordItemEffectBattle(u8 bank, u8 holdEffect);
 s8 GetPokeFlavourRelation(u32 pid, u8 flavor);
 
 extern u8 BattleScript_MoveSelectionDisabledMove[];
@@ -207,12 +209,12 @@ extern u8 gUnknown_081D99A0[]; //disobedient, hits itself
 #define MULTISTRING_CHOOSER 0x5
 #define MSG_DISPLAY         0x7
 
-u8 GetBattleBank(u8 caseId)
+u8 GetBattlerForBattleScript(u8 caseId)
 {
     u8 ret = 0;
     switch (caseId)
     {
-    case BS_GET_TARGET:
+    case BS_TARGET:
         ret = gBattlerTarget;
         break;
     case BS_GET_ATTACKER:
@@ -257,7 +259,7 @@ void PressurePPLose(u8 bankDef, u8 bankAtk, u16 move)
         gBattleMons[bankAtk].pp[i]--;
 
     if (!(gBattleMons[bankAtk].status2 & STATUS2_TRANSFORMED)
-        && !(gDisableStructs[bankAtk].unk18_b & gBitTable[i]))
+        && !(gDisableStructs[bankAtk].mimickedMoves & gBitTable[i]))
     {
         gActiveBattler = bankAtk;
         BtlController_EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + i, 0, 1, &gBattleMons[gActiveBattler].pp[i]);
@@ -291,7 +293,7 @@ void PressurePPLoseOnUsingImprision(u8 bankAtk)
 
     if (imprisionPos != 4
         && !(gBattleMons[bankAtk].status2 & STATUS2_TRANSFORMED)
-        && !(gDisableStructs[bankAtk].unk18_b & gBitTable[imprisionPos]))
+        && !(gDisableStructs[bankAtk].mimickedMoves & gBitTable[imprisionPos]))
     {
         gActiveBattler = bankAtk;
         BtlController_EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + imprisionPos, 0, 1, &gBattleMons[gActiveBattler].pp[imprisionPos]);
@@ -324,7 +326,7 @@ void PressurePPLoseOnUsingPerishSong(u8 bankAtk)
 
     if (perishSongPos != 4
         && !(gBattleMons[bankAtk].status2 & STATUS2_TRANSFORMED)
-        && !(gDisableStructs[bankAtk].unk18_b & gBitTable[perishSongPos]))
+        && !(gDisableStructs[bankAtk].mimickedMoves & gBitTable[perishSongPos]))
     {
         gActiveBattler = bankAtk;
         BtlController_EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + perishSongPos, 0, 1, &gBattleMons[gActiveBattler].pp[perishSongPos]);
@@ -333,7 +335,7 @@ void PressurePPLoseOnUsingPerishSong(u8 bankAtk)
 }
 
 
-void MarkAllBufferBanksForExecution(void) // unused
+void MarkAllBattlersForControllerExec(void) // unused
 {
     s32 i;
 
@@ -481,7 +483,7 @@ u8 TrySetCantSelectMoveBattleScript(void) //msg can't select a move
         gSelectionBattleScripts[gActiveBattler] = BattleScript_MoveSelectionDisabledMove;
         limitations++;
     }
-    if (move == gLastUsedMove[gActiveBattler] && move != MOVE_STRUGGLE && gBattleMons[gActiveBattler].status2 & STATUS2_TORMENT)
+    if (move == gLastMoves[gActiveBattler] && move != MOVE_STRUGGLE && gBattleMons[gActiveBattler].status2 & STATUS2_TORMENT)
     {
         CancelMultiTurnMoves(gActiveBattler);
         gSelectionBattleScripts[gActiveBattler] = BattleScript_MoveSelectionTormented;
@@ -522,40 +524,36 @@ u8 TrySetCantSelectMoveBattleScript(void) //msg can't select a move
     return limitations;
 }
 
-#define MOVE_LIMITATION_ZEROMOVE    (1 << 0)
-#define MOVE_LIMITATION_PP          (1 << 1)
-#define MOVE_LIMITATION_DISABLED    (1 << 2)
-#define MOVE_LIMITATION_TORMENTED   (1 << 3)
-#define MOVE_LIMITATION_TAUNT       (1 << 4)
-#define MOVE_LIMITATION_IMPRISION   (1 << 5)
-
-u8 CheckMoveLimitations(u8 bank, u8 unusableMoves, u8 check)
+u8 CheckMoveLimitations(u8 battlerId, u8 unusableMoves, u8 check)
 {
     u8 holdEffect;
-    u16* choicedMove = CHOICED_MOVE(bank);
+    u16* choicedMove = CHOICED_MOVE(battlerId);
     s32 i;
-    if (gBattleMons[bank].item == ITEM_ENIGMA_BERRY)
-        holdEffect = gEnigmaBerries[bank].holdEffect;
+
+    if (gBattleMons[battlerId].item == ITEM_ENIGMA_BERRY)
+        holdEffect = gEnigmaBerries[battlerId].holdEffect;
     else
-        holdEffect = ItemId_GetHoldEffect(gBattleMons[bank].item);
-    gPotentialItemEffectBattler = bank;
-    for (i = 0; i < 4; i++)
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[battlerId].item);
+
+    gPotentialItemEffectBattler = battlerId;
+
+    for (i = 0; i < MAX_MON_MOVES; i++)
     {
-        if (gBattleMons[bank].moves[i] == 0 && check & MOVE_LIMITATION_ZEROMOVE)
+        if (gBattleMons[battlerId].moves[i] == 0 && check & MOVE_LIMITATION_ZEROMOVE)
             unusableMoves |= gBitTable[i];
-        if (gBattleMons[bank].pp[i] == 0 && check & MOVE_LIMITATION_PP)
+        if (gBattleMons[battlerId].pp[i] == 0 && check & MOVE_LIMITATION_PP)
             unusableMoves |= gBitTable[i];
-        if (gBattleMons[bank].moves[i] == gDisableStructs[bank].disabledMove && check & MOVE_LIMITATION_DISABLED)
+        if (gBattleMons[battlerId].moves[i] == gDisableStructs[battlerId].disabledMove && check & MOVE_LIMITATION_DISABLED)
             unusableMoves |= gBitTable[i];
-        if (gBattleMons[bank].moves[i] == gLastUsedMove[bank] && check & MOVE_LIMITATION_TORMENTED && gBattleMons[bank].status2 & STATUS2_TORMENT)
+        if (gBattleMons[battlerId].moves[i] == gLastMoves[battlerId] && check & MOVE_LIMITATION_TORMENTED && gBattleMons[battlerId].status2 & STATUS2_TORMENT)
             unusableMoves |= gBitTable[i];
-        if (gDisableStructs[bank].tauntTimer1 && check & MOVE_LIMITATION_TAUNT && gBattleMoves[gBattleMons[bank].moves[i]].power == 0)
+        if (gDisableStructs[battlerId].tauntTimer1 && check & MOVE_LIMITATION_TAUNT && gBattleMoves[gBattleMons[battlerId].moves[i]].power == 0)
             unusableMoves |= gBitTable[i];
-        if (IsImprisoned(bank, gBattleMons[bank].moves[i]) && check & MOVE_LIMITATION_IMPRISION)
+        if (IsImprisoned(battlerId, gBattleMons[battlerId].moves[i]) && check & MOVE_LIMITATION_IMPRISON)
             unusableMoves |= gBitTable[i];
-        if (gDisableStructs[bank].encoreTimer1 && gDisableStructs[bank].encoredMove != gBattleMons[bank].moves[i])
+        if (gDisableStructs[battlerId].encoreTimer1 && gDisableStructs[battlerId].encoredMove != gBattleMons[battlerId].moves[i])
             unusableMoves |= gBitTable[i];
-        if (holdEffect == HOLD_EFFECT_CHOICE_BAND && *choicedMove != 0 && *choicedMove != 0xFFFF && *choicedMove != gBattleMons[bank].moves[i])
+        if (holdEffect == HOLD_EFFECT_CHOICE_BAND && *choicedMove != 0 && *choicedMove != 0xFFFF && *choicedMove != gBattleMons[battlerId].moves[i])
             unusableMoves |= gBitTable[i];
     }
     return unusableMoves;
@@ -563,9 +561,9 @@ u8 CheckMoveLimitations(u8 bank, u8 unusableMoves, u8 check)
 
 bool8 AreAllMovesUnusable(void)
 {
-    u8 unusable;
-    unusable = CheckMoveLimitations(gActiveBattler, 0, 0xFF);
-    if (unusable == 0xF) //all moves are unusable
+    u8 unusable = CheckMoveLimitations(gActiveBattler, 0, 0xFF);
+
+    if (unusable == 0xF) // All moves are unusable.
     {
         gProtectStructs[gActiveBattler].noValidMoves = 1;
         gSelectionBattleScripts[gActiveBattler] = BattleScript_NoMovesLeft;
@@ -575,33 +573,53 @@ bool8 AreAllMovesUnusable(void)
             gBattleBufferB[gActiveBattler][3] = GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ 1);
     }
     else
+    {
         gProtectStructs[gActiveBattler].noValidMoves = 0;
+    }
+
     return (unusable == 0xF);
 }
 
-u8 IsImprisoned(u8 bank, u16 move)
+u8 IsImprisoned(u8 battlerId, u16 move)
 {
-    u8 imprisionedMoves = 0;
-    u8 bankSide = GetBattlerSide(bank);
     s32 i;
+    u8 imprisonedMoves = 0;
+    u8 battlerSide = GetBattlerSide(battlerId);
+
     for (i = 0; i < gBattlersCount; i++)
     {
-        if (bankSide != GetBattlerSide(i) && gStatuses3[i] & STATUS3_IMPRISIONED)
+        if (battlerSide != GetBattlerSide(i) && gStatuses3[i] & STATUS3_IMPRISONED_OTHERS)
         {
             s32 j;
-            for (j = 0; j < 4; j++)
+            for (j = 0; j < MAX_MON_MOVES; j++)
             {
                 if (move == gBattleMons[i].moves[j])
                     break;
             }
-            if (j < 4)
-                imprisionedMoves++;
+            if (j < MAX_MON_MOVES)
+                imprisonedMoves++;
         }
     }
-    return imprisionedMoves;
+
+    return imprisonedMoves;
 }
 
-u8 UpdateTurnCounters(void)
+enum
+{
+    ENDTURN_ORDER,
+    ENDTURN_REFLECT,
+    ENDTURN_LIGHT_SCREEN,
+    ENDTURN_MIST,
+    ENDTURN_SAFEGUARD,
+    ENDTURN_WISH,
+    ENDTURN_RAIN,
+    ENDTURN_SANDSTORM,
+    ENDTURN_SUN,
+    ENDTURN_HAIL,
+    ENDTURN_FIELD_COUNT,
+};
+
+u8 DoFieldEndTurnEffects(void)
 {
     u8 effect = 0;
     s32 i;
@@ -615,43 +633,39 @@ u8 UpdateTurnCounters(void)
 
     do
     {
-        u8 sideBank;
+        u8 side;
 
-        switch (gBattleStruct->turncountersTracker)
+        switch (gBattleStruct->turnCountersTracker)
         {
-        case 0:
+        case ENDTURN_ORDER:
             for (i = 0; i < gBattlersCount; i++)
             {
-                gBanksByTurnOrder[i] = i;
+                gBattlerByTurnOrder[i] = i;
             }
             for (i = 0; i < gBattlersCount - 1; i++)
             {
                 s32 j;
                 for (j = i + 1; j < gBattlersCount; j++)
                 {
-                    if (GetWhoStrikesFirst(gBanksByTurnOrder[i], gBanksByTurnOrder[j], 0))
+                    if (GetWhoStrikesFirst(gBattlerByTurnOrder[i], gBattlerByTurnOrder[j], 0))
                         SwapTurnOrder(i, j);
                 }
             }
-            gBattleStruct->turncountersTracker++;
+            gBattleStruct->turnCountersTracker++;
             gBattleStruct->turnSideTracker = 0;
-        case 1:
+            // fall through
+        case ENDTURN_REFLECT:
             while (gBattleStruct->turnSideTracker < 2)
             {
-                gActiveBattler = gBattlerAttacker = sideBank = gBattleStruct->turnSideTracker;
+                gActiveBattler = gBattlerAttacker = side = gBattleStruct->turnSideTracker;
 
-                if (gSideAffecting[sideBank] & SIDE_STATUS_REFLECT)
+                if (gSideStatuses[side] & SIDE_STATUS_REFLECT)
                 {
-                    if (--gSideTimers[sideBank].reflectTimer == 0)
+                    if (--gSideTimers[side].reflectTimer == 0)
                     {
-
-                        gSideAffecting[sideBank] &= ~SIDE_STATUS_REFLECT;
+                        gSideStatuses[side] &= ~SIDE_STATUS_REFLECT;
                         BattleScriptExecute(BattleScript_SideStatusWoreOff);
-                        gBattleTextBuff1[0] = 0xFD;
-                        gBattleTextBuff1[1] = 2;
-                        gBattleTextBuff1[2] = MOVE_REFLECT;
-                        gBattleTextBuff1[3] = MOVE_REFLECT >> 8;
-                        gBattleTextBuff1[4] = EOS;
+                        PREPARE_MOVE_BUFFER(gBattleTextBuff1, MOVE_REFLECT);
                         effect++;
                     }
                 }
@@ -661,26 +675,22 @@ u8 UpdateTurnCounters(void)
             }
             if (!effect)
             {
-                gBattleStruct->turncountersTracker++;
+                gBattleStruct->turnCountersTracker++;
                 gBattleStruct->turnSideTracker = 0;
             }
             break;
-        case 2:
+        case ENDTURN_LIGHT_SCREEN:
             while (gBattleStruct->turnSideTracker < 2)
             {
-                gActiveBattler = gBattlerAttacker = sideBank = gBattleStruct->turnSideTracker;
-                if (gSideAffecting[sideBank] & SIDE_STATUS_LIGHTSCREEN)
+                gActiveBattler = gBattlerAttacker = side = gBattleStruct->turnSideTracker;
+                if (gSideStatuses[side] & SIDE_STATUS_LIGHTSCREEN)
                 {
-                    if (--gSideTimers[sideBank].lightscreenTimer == 0)
+                    if (--gSideTimers[side].lightscreenTimer == 0)
                     {
-                        gSideAffecting[sideBank] &= ~SIDE_STATUS_LIGHTSCREEN;
+                        gSideStatuses[side] &= ~SIDE_STATUS_LIGHTSCREEN;
                         BattleScriptExecute(BattleScript_SideStatusWoreOff);
-                        gBattleCommunication[MULTISTRING_CHOOSER] = sideBank;
-                        gBattleTextBuff1[0] = 0xFD;
-                        gBattleTextBuff1[1] = 2;
-                        gBattleTextBuff1[2] = MOVE_LIGHT_SCREEN;
-                        gBattleTextBuff1[3] = MOVE_LIGHT_SCREEN >> 8;
-                        gBattleTextBuff1[4] = EOS;
+                        gBattleCommunication[MULTISTRING_CHOOSER] = side;
+                        PREPARE_MOVE_BUFFER(gBattleTextBuff1, MOVE_LIGHT_SCREEN);
                         effect++;
                     }
                 }
@@ -690,24 +700,20 @@ u8 UpdateTurnCounters(void)
             }
             if (!effect)
             {
-                gBattleStruct->turncountersTracker++;
+                gBattleStruct->turnCountersTracker++;
                 gBattleStruct->turnSideTracker = 0;
             }
             break;
-        case 3:
+        case ENDTURN_MIST:
             while (gBattleStruct->turnSideTracker < 2)
             {
-                gActiveBattler = gBattlerAttacker = sideBank = gBattleStruct->turnSideTracker;
-                if (gSideTimers[sideBank].mistTimer && --gSideTimers[sideBank].mistTimer == 0)
+                gActiveBattler = gBattlerAttacker = side = gBattleStruct->turnSideTracker;
+                if (gSideTimers[side].mistTimer && --gSideTimers[side].mistTimer == 0)
                 {
-                    gSideAffecting[sideBank] &= ~SIDE_STATUS_MIST;
+                    gSideStatuses[side] &= ~SIDE_STATUS_MIST;
                     BattleScriptExecute(BattleScript_SideStatusWoreOff);
-                    gBattleCommunication[MULTISTRING_CHOOSER] = sideBank;
-                    gBattleTextBuff1[0] = 0xFD;
-                    gBattleTextBuff1[1] = 2;
-                    gBattleTextBuff1[2] = MOVE_MIST;
-                    gBattleTextBuff1[3] = MOVE_MIST >> 8;
-                    gBattleTextBuff1[4] = EOS;
+                    gBattleCommunication[MULTISTRING_CHOOSER] = side;
+                    PREPARE_MOVE_BUFFER(gBattleTextBuff1, MOVE_MIST);
                     effect++;
                 }
                 gBattleStruct->turnSideTracker++;
@@ -716,19 +722,19 @@ u8 UpdateTurnCounters(void)
             }
             if (!effect)
             {
-                gBattleStruct->turncountersTracker++;
+                gBattleStruct->turnCountersTracker++;
                 gBattleStruct->turnSideTracker = 0;
             }
             break;
-        case 4:
+        case ENDTURN_SAFEGUARD:
             while (gBattleStruct->turnSideTracker < 2)
             {
-                gActiveBattler = gBattlerAttacker = sideBank = gBattleStruct->turnSideTracker;
-                if (gSideAffecting[sideBank] & SIDE_STATUS_SAFEGUARD)
+                gActiveBattler = gBattlerAttacker = side = gBattleStruct->turnSideTracker;
+                if (gSideStatuses[side] & SIDE_STATUS_SAFEGUARD)
                 {
-                    if (--gSideTimers[sideBank].safeguardTimer == 0)
+                    if (--gSideTimers[side].safeguardTimer == 0)
                     {
-                        gSideAffecting[sideBank] &= ~SIDE_STATUS_SAFEGUARD;
+                        gSideStatuses[side] &= ~SIDE_STATUS_SAFEGUARD;
                         BattleScriptExecute(BattleScript_SafeguardEnds);
                         effect++;
                     }
@@ -739,14 +745,14 @@ u8 UpdateTurnCounters(void)
             }
             if (!effect)
             {
-                gBattleStruct->turncountersTracker++;
+                gBattleStruct->turnCountersTracker++;
                 gBattleStruct->turnSideTracker = 0;
             }
             break;
-        case 5:
+        case ENDTURN_WISH:
             while (gBattleStruct->turnSideTracker < gBattlersCount)
             {
-                gActiveBattler = gBanksByTurnOrder[gBattleStruct->turnSideTracker];
+                gActiveBattler = gBattlerByTurnOrder[gBattleStruct->turnSideTracker];
                 if (gWishFutureKnock.wishCounter[gActiveBattler] && --gWishFutureKnock.wishCounter[gActiveBattler] == 0 && gBattleMons[gActiveBattler].hp)
                 {
                     gBattlerTarget = gActiveBattler;
@@ -759,10 +765,10 @@ u8 UpdateTurnCounters(void)
             }
             if (!effect)
             {
-                gBattleStruct->turncountersTracker++;
+                gBattleStruct->turnCountersTracker++;
             }
             break;
-        case 6:
+        case ENDTURN_RAIN:
             if (gBattleWeather & WEATHER_RAIN_ANY)
             {
                 if (!(gBattleWeather & WEATHER_RAIN_PERMANENT))
@@ -779,15 +785,20 @@ u8 UpdateTurnCounters(void)
                         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
                 }
                 else if (gBattleWeather & WEATHER_RAIN_DOWNPOUR)
+                {
                     gBattleCommunication[MULTISTRING_CHOOSER] = 1;
+                }
                 else
+                {
                     gBattleCommunication[MULTISTRING_CHOOSER] = 0;
+                }
+
                 BattleScriptExecute(BattleScript_RainContinuesOrEnds);
                 effect++;
             }
-            gBattleStruct->turncountersTracker++;
+            gBattleStruct->turnCountersTracker++;
             break;
-        case 7:
+        case ENDTURN_SANDSTORM:
             if (gBattleWeather & WEATHER_SANDSTORM_ANY)
             {
                 if (!(gBattleWeather & WEATHER_SANDSTORM_PERMANENT) && --gWishFutureKnock.weatherDuration == 0)
@@ -796,16 +807,18 @@ u8 UpdateTurnCounters(void)
                     gBattlescriptCurrInstr = BattleScript_SandStormHailEnds;
                 }
                 else
+                {
                     gBattlescriptCurrInstr = BattleScript_DamagingWeatherContinues;
+                }
 
                 gBattleStruct->animArg1 = B_ANIM_SANDSTORM_CONTINUES;
                 gBattleCommunication[MULTISTRING_CHOOSER] = 0;
                 BattleScriptExecute(gBattlescriptCurrInstr);
                 effect++;
             }
-            gBattleStruct->turncountersTracker++;
+            gBattleStruct->turnCountersTracker++;
             break;
-        case 8:
+        case ENDTURN_SUN:
             if (gBattleWeather & WEATHER_SUN_ANY)
             {
                 if (!(gBattleWeather & WEATHER_SUN_PERMANENT) && --gWishFutureKnock.weatherDuration == 0)
@@ -814,14 +827,16 @@ u8 UpdateTurnCounters(void)
                     gBattlescriptCurrInstr = BattleScript_SunlightFaded;
                 }
                 else
+                {
                     gBattlescriptCurrInstr = BattleScript_SunlightContinues;
+                }
 
                 BattleScriptExecute(gBattlescriptCurrInstr);
                 effect++;
             }
-            gBattleStruct->turncountersTracker++;
+            gBattleStruct->turnCountersTracker++;
             break;
-        case 9:
+        case ENDTURN_HAIL:
             if (gBattleWeather & WEATHER_HAIL)
             {
                 if (--gWishFutureKnock.weatherDuration == 0)
@@ -830,16 +845,18 @@ u8 UpdateTurnCounters(void)
                     gBattlescriptCurrInstr = BattleScript_SandStormHailEnds;
                 }
                 else
+                {
                     gBattlescriptCurrInstr = BattleScript_DamagingWeatherContinues;
+                }
 
                 gBattleStruct->animArg1 = B_ANIM_HAIL_CONTINUES;
                 gBattleCommunication[MULTISTRING_CHOOSER] = 1;
                 BattleScriptExecute(gBattlescriptCurrInstr);
                 effect++;
             }
-            gBattleStruct->turncountersTracker++;
+            gBattleStruct->turnCountersTracker++;
             break;
-        case 10:
+        case ENDTURN_FIELD_COUNT:
             effect++;
             break;
         }
@@ -849,23 +866,47 @@ u8 UpdateTurnCounters(void)
 
 #define TURNBASED_MAX_CASE 19
 
+enum
+{
+    ENDTURN_INGRAIN,
+    ENDTURN_ABILITIES,
+    ENDTURN_ITEMS1,
+    ENDTURN_LEECH_SEED,
+    ENDTURN_POISON,
+    ENDTURN_BAD_POISON,
+    ENDTURN_BURN,
+    ENDTURN_NIGHTMARES,
+    ENDTURN_CURSE,
+    ENDTURN_WRAP,
+    ENDTURN_UPROAR,
+    ENDTURN_THRASH,
+    ENDTURN_DISABLE,
+    ENDTURN_ENCORE,
+    ENDTURN_LOCK_ON,
+    ENDTURN_CHARGE,
+    ENDTURN_TAUNT,
+    ENDTURN_YAWN,
+    ENDTURN_ITEMS2,
+    ENDTURN_BATTLER_COUNT
+};
+
 u8 TurnBasedEffects(void)
 {
     u8 effect = 0;
 
     gHitMarker |= (HITMARKER_GRUDGE | HITMARKER_x20);
-    while (gBattleStruct->turnEffectsBank < gBattlersCount && gBattleStruct->turnEffectsTracker <= TURNBASED_MAX_CASE)
+    while (gBattleStruct->turnEffectsBattlerId < gBattlersCount && gBattleStruct->turnEffectsTracker <= TURNBASED_MAX_CASE)
     {
-        gActiveBattler = gBattlerAttacker = gBanksByTurnOrder[gBattleStruct->turnEffectsBank];
+        gActiveBattler = gBattlerAttacker = gBattlerByTurnOrder[gBattleStruct->turnEffectsBattlerId];
         if (gAbsentBattlerFlags & gBitTable[gActiveBattler])
         {
-            gBattleStruct->turnEffectsBank++;
+            gBattleStruct->turnEffectsBattlerId++;
         }
         else
         {
             switch (gBattleStruct->turnEffectsTracker)
             {
-            case 0:  // ingrain
+            case ENDTURN_INGRAIN:  // ingrain
                 if ((gStatuses3[gActiveBattler] & STATUS3_ROOTED)
                  && gBattleMons[gActiveBattler].hp != gBattleMons[gActiveBattler].maxHP
                  && gBattleMons[gActiveBattler].hp != 0)
@@ -879,25 +920,27 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 1:  // end turn abilities
+            case ENDTURN_ABILITIES:  // end turn abilities
                 if (AbilityBattleEffects(ABILITYEFFECT_ENDTURN, gActiveBattler, 0, 0, 0))
                     effect++;
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 2:  // item effects
-                if (ItemBattleEffects(1, gActiveBattler, 0))
+            case ENDTURN_ITEMS1:  // item effects
+                if (ItemBattleEffects(1, gActiveBattler, FALSE))
                     effect++;
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 18:  // item effects again
-                if (ItemBattleEffects(1, gActiveBattler, 1))
+            case ENDTURN_ITEMS2:  // item effects again
+                if (ItemBattleEffects(1, gActiveBattler, TRUE))
                     effect++;
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 3:  // leech seed
-                if (gStatuses3[gActiveBattler] & STATUS3_LEECHSEED && gBattleMons[gStatuses3[gActiveBattler] & STATUS3_LEECHSEED_BANK].hp != 0 && gBattleMons[gActiveBattler].hp != 0)
+            case ENDTURN_LEECH_SEED:  // leech seed
+                if ((gStatuses3[gActiveBattler] & STATUS3_LEECHSEED)
+                 && gBattleMons[gStatuses3[gActiveBattler] & STATUS3_LEECHSEED_BATTLER].hp != 0
+                 && gBattleMons[gActiveBattler].hp != 0)
                 {
-                    gBattlerTarget = gStatuses3[gActiveBattler] & STATUS3_LEECHSEED_BANK; //funny how the 'target' is actually the bank that receives HP
+                    gBattlerTarget = gStatuses3[gActiveBattler] & STATUS3_LEECHSEED_BATTLER; // Notice gBattlerTarget is actually the HP receiver.
                     gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8;
                     if (gBattleMoveDamage == 0)
                         gBattleMoveDamage = 1;
@@ -908,8 +951,8 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 4:  // poison
-                if ((gBattleMons[gActiveBattler].status1 & STATUS_POISON) && gBattleMons[gActiveBattler].hp != 0)
+            case ENDTURN_POISON:  // poison
+                if ((gBattleMons[gActiveBattler].status1 & STATUS1_POISON) && gBattleMons[gActiveBattler].hp != 0)
                 {
                     gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8;
                     if (gBattleMoveDamage == 0)
@@ -919,13 +962,13 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 5:  // toxic poison
-                if ((gBattleMons[gActiveBattler].status1 & STATUS_TOXIC_POISON) && gBattleMons[gActiveBattler].hp != 0)
+            case ENDTURN_BAD_POISON:  // toxic poison
+                if ((gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_POISON) && gBattleMons[gActiveBattler].hp != 0)
                 {
                     gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 16;
                     if (gBattleMoveDamage == 0)
                         gBattleMoveDamage = 1;
-                    if ((gBattleMons[gActiveBattler].status1 & 0xF00) != 0xF00) //not 16 turns
+                    if ((gBattleMons[gActiveBattler].status1 & 0xF00) != 0xF00) // not 16 turns
                         gBattleMons[gActiveBattler].status1 += 0x100;
                     gBattleMoveDamage *= (gBattleMons[gActiveBattler].status1 & 0xF00) >> 8;
                     BattleScriptExecute(BattleScript_PoisonTurnDmg);
@@ -933,8 +976,8 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 6:  // burn
-                if ((gBattleMons[gActiveBattler].status1 & STATUS_BURN) && gBattleMons[gActiveBattler].hp != 0)
+            case ENDTURN_BURN:  // burn
+                if ((gBattleMons[gActiveBattler].status1 & STATUS1_BURN) && gBattleMons[gActiveBattler].hp != 0)
                 {
                     gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8;
                     if (gBattleMoveDamage == 0)
@@ -944,7 +987,7 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 7:  // spooky nightmares
+            case ENDTURN_NIGHTMARES:  // spooky nightmares
                 if ((gBattleMons[gActiveBattler].status2 & STATUS2_NIGHTMARE) && gBattleMons[gActiveBattler].hp != 0)
                 {
                     // missing sleep check
@@ -956,7 +999,7 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 8:  // curse
+            case ENDTURN_CURSE:  // curse
                 if ((gBattleMons[gActiveBattler].status2 & STATUS2_CURSED) && gBattleMons[gActiveBattler].hp != 0)
                 {
                     gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 4;
@@ -967,7 +1010,7 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 9:  // wrap
+            case ENDTURN_WRAP:  // wrap
                 if ((gBattleMons[gActiveBattler].status2 & STATUS2_WRAPPED) && gBattleMons[gActiveBattler].hp != 0)
                 {
                     gBattleMons[gActiveBattler].status2 -= 0x2000;
@@ -975,8 +1018,8 @@ u8 TurnBasedEffects(void)
                     {
                         gBattleStruct->animArg1 = ewram16004arr(0, gActiveBattler);
                         gBattleStruct->animArg2 = ewram16004arr(1, gActiveBattler);
-                        gBattleTextBuff1[0] = 0xFD;
-                        gBattleTextBuff1[1] = 2;
+                        gBattleTextBuff1[0] = B_BUFF_PLACEHOLDER_BEGIN;
+                        gBattleTextBuff1[1] = B_BUFF_MOVE;
                         gBattleTextBuff1[2] = ewram16004arr(0, gActiveBattler);
                         gBattleTextBuff1[3] = ewram16004arr(1, gActiveBattler);
                         gBattleTextBuff1[4] = EOS;
@@ -999,15 +1042,15 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 10:  // uproar
+            case ENDTURN_UPROAR:  // uproar
                 if (gBattleMons[gActiveBattler].status2 & STATUS2_UPROAR)
                 {
                     for (gBattlerAttacker = 0; gBattlerAttacker < gBattlersCount; gBattlerAttacker++)
                     {
-                        if ((gBattleMons[gBattlerAttacker].status1 & STATUS_SLEEP)
+                        if ((gBattleMons[gBattlerAttacker].status1 & STATUS1_SLEEP)
                          && gBattleMons[gBattlerAttacker].ability != ABILITY_SOUNDPROOF)
                         {
-                            gBattleMons[gBattlerAttacker].status1 &= ~(STATUS_SLEEP);
+                            gBattleMons[gBattlerAttacker].status1 &= ~(STATUS1_SLEEP);
                             gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_NIGHTMARE);
                             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
                             BattleScriptExecute(BattleScript_MonWokeUpInUproar);
@@ -1048,7 +1091,7 @@ u8 TurnBasedEffects(void)
                 if (effect != 2)
                     gBattleStruct->turnEffectsTracker++;
                 break;
-            case 11:  // thrash
+            case ENDTURN_THRASH:  // thrash
                 if (gBattleMons[gActiveBattler].status2 & STATUS2_LOCK_CONFUSE)
                 {
                     gBattleMons[gActiveBattler].status2 -= 0x400;
@@ -1070,11 +1113,11 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 12:  // disable
+            case ENDTURN_DISABLE:  // disable
                 if (gDisableStructs[gActiveBattler].disableTimer1 != 0)
                 {
-                    int i;
-                    for (i = 0; i < 4; i++)
+                    s32 i;
+                    for (i = 0; i < MAX_MON_MOVES; i++)
                     {
                         if (gDisableStructs[gActiveBattler].disabledMove == gBattleMons[gActiveBattler].moves[i])
                             break;
@@ -1093,7 +1136,7 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 13:  // encore
+            case ENDTURN_ENCORE:  // encore
                 if (gDisableStructs[gActiveBattler].encoreTimer1 != 0)
                 {
                     if (gBattleMons[gActiveBattler].moves[gDisableStructs[gActiveBattler].encoredMovePos] != gDisableStructs[gActiveBattler].encoredMove)  // pokemon does not have the encored move anymore
@@ -1112,26 +1155,26 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 14:  // lock-on decrement
+            case ENDTURN_LOCK_ON:  // lock-on decrement
                 if (gStatuses3[gActiveBattler] & STATUS3_ALWAYS_HITS)
                     gStatuses3[gActiveBattler] -= 0x8;
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 15:  // charge
+            case ENDTURN_CHARGE:  // charge
                 if (gDisableStructs[gActiveBattler].chargeTimer1 && --gDisableStructs[gActiveBattler].chargeTimer1 == 0)
                     gStatuses3[gActiveBattler] &= ~STATUS3_CHARGED_UP;
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 16:  // taunt
+            case ENDTURN_TAUNT:  // taunt
                 if (gDisableStructs[gActiveBattler].tauntTimer1)
                     gDisableStructs[gActiveBattler].tauntTimer1--;
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 17:  // yawn
+            case ENDTURN_YAWN:  // yawn
                 if (gStatuses3[gActiveBattler] & STATUS3_YAWN)
                 {
                     gStatuses3[gActiveBattler] -= 0x800;
-                    if (!(gStatuses3[gActiveBattler] & STATUS3_YAWN) && !(gBattleMons[gActiveBattler].status1 & STATUS_ANY)
+                    if (!(gStatuses3[gActiveBattler] & STATUS3_YAWN) && !(gBattleMons[gActiveBattler].status1 & STATUS1_ANY)
                      && gBattleMons[gActiveBattler].ability != ABILITY_VITAL_SPIRIT
                      && gBattleMons[gActiveBattler].ability != ABILITY_INSOMNIA && !UproarWakeUpCheck(gActiveBattler))
                     {
@@ -1146,9 +1189,9 @@ u8 TurnBasedEffects(void)
                 }
                 gBattleStruct->turnEffectsTracker++;
                 break;
-            case 19:  // done
+            case ENDTURN_BATTLER_COUNT:  // done
                 gBattleStruct->turnEffectsTracker = 0;
-                gBattleStruct->turnEffectsBank++;
+                gBattleStruct->turnEffectsBattlerId++;
                 break;
             }
             if (effect != 0)
@@ -1162,17 +1205,20 @@ u8 TurnBasedEffects(void)
 bool8 HandleWishPerishSongOnTurnEnd(void)
 {
     gHitMarker |= (HITMARKER_GRUDGE | HITMARKER_x20);
-    switch (gBattleStruct->sub80170DC_Tracker)
+
+    switch (gBattleStruct->wishPerishSongState)
     {
     case 0: // future sight
-        while (gBattleStruct->sub80170DC_Bank < gBattlersCount)
+        while (gBattleStruct->wishPerishSongBattlerId < gBattlersCount)
         {
-            gActiveBattler = gBattleStruct->sub80170DC_Bank;
+            gActiveBattler = gBattleStruct->wishPerishSongBattlerId;
             if (gAbsentBattlerFlags & gBitTable[gActiveBattler])
-                gBattleStruct->sub80170DC_Bank++;
+            {
+                gBattleStruct->wishPerishSongBattlerId++;
+            }
             else
             {
-                gBattleStruct->sub80170DC_Bank++;
+                gBattleStruct->wishPerishSongBattlerId++;
                 if (gWishFutureKnock.futureSightCounter[gActiveBattler] && --gWishFutureKnock.futureSightCounter[gActiveBattler] == 0 && gBattleMons[gActiveBattler].hp)
                 {
                     if (gWishFutureKnock.futureSightMove[gActiveBattler] == MOVE_FUTURE_SIGHT)
@@ -1193,17 +1239,17 @@ bool8 HandleWishPerishSongOnTurnEnd(void)
                 }
             }
         }
-        gBattleStruct->sub80170DC_Tracker = 1;
-        gBattleStruct->sub80170DC_Bank = 0;
+        gBattleStruct->wishPerishSongState = 1;
+        gBattleStruct->wishPerishSongBattlerId = 0;
     case 1: // perish song
-        while (gBattleStruct->sub80170DC_Bank < gBattlersCount)
+        while (gBattleStruct->wishPerishSongBattlerId < gBattlersCount)
         {
-            gActiveBattler = gBattlerAttacker = gBanksByTurnOrder[gBattleStruct->sub80170DC_Bank];
+            gActiveBattler = gBattlerAttacker = gBattlerByTurnOrder[gBattleStruct->wishPerishSongBattlerId];
             if (gAbsentBattlerFlags & gBitTable[gActiveBattler])
-                gBattleStruct->sub80170DC_Bank++;
+                gBattleStruct->wishPerishSongBattlerId++;
             else
             {
-                gBattleStruct->sub80170DC_Bank++;
+                gBattleStruct->wishPerishSongBattlerId++;
                 if (gStatuses3[gActiveBattler] & STATUS3_PERISH_SONG)
                 {
                     gBattleTextBuff1[0] = 0xFD;
@@ -1333,11 +1379,11 @@ u8 AtkCanceller_UnableToUseMove(void)
             gBattleStruct->atkCancellerTracker++;
             break;
         case 1: // check being asleep
-            if (gBattleMons[gBattlerAttacker].status1 & STATUS_SLEEP)
+            if (gBattleMons[gBattlerAttacker].status1 & STATUS1_SLEEP)
             {
                 if (UproarWakeUpCheck(gBattlerAttacker))
                 {
-                    gBattleMons[gBattlerAttacker].status1 &= ~(STATUS_SLEEP);
+                    gBattleMons[gBattlerAttacker].status1 &= ~(STATUS1_SLEEP);
                     gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_NIGHTMARE);
                     BattleScriptPushCursor();
                     gBattleCommunication[MULTISTRING_CHOOSER] = 1;
@@ -1351,11 +1397,11 @@ u8 AtkCanceller_UnableToUseMove(void)
                         toSub = 2;
                     else
                         toSub = 1;
-                    if ((gBattleMons[gBattlerAttacker].status1 & STATUS_SLEEP) < toSub)
-                        gBattleMons[gBattlerAttacker].status1 &= ~(STATUS_SLEEP);
+                    if ((gBattleMons[gBattlerAttacker].status1 & STATUS1_SLEEP) < toSub)
+                        gBattleMons[gBattlerAttacker].status1 &= ~(STATUS1_SLEEP);
                     else
                         gBattleMons[gBattlerAttacker].status1 -= toSub;
-                    if (gBattleMons[gBattlerAttacker].status1 & STATUS_SLEEP)
+                    if (gBattleMons[gBattlerAttacker].status1 & STATUS1_SLEEP)
                     {
                         if (gCurrentMove != MOVE_SNORE && gCurrentMove != MOVE_SLEEP_TALK)
                         {
@@ -1377,7 +1423,7 @@ u8 AtkCanceller_UnableToUseMove(void)
             gBattleStruct->atkCancellerTracker++;
             break;
         case 2: // check being frozen
-            if (gBattleMons[gBattlerAttacker].status1 & STATUS_FREEZE)
+            if (gBattleMons[gBattlerAttacker].status1 & STATUS1_FREEZE)
             {
                 if (Random() % 5)
                 {
@@ -1394,7 +1440,7 @@ u8 AtkCanceller_UnableToUseMove(void)
                 }
                 else // unfreeze
                 {
-                    gBattleMons[gBattlerAttacker].status1 &= ~(STATUS_FREEZE);
+                    gBattleMons[gBattlerAttacker].status1 &= ~(STATUS1_FREEZE);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_MoveUsedUnfroze;
                     gBattleCommunication[MULTISTRING_CHOOSER] = 0;
@@ -1504,7 +1550,7 @@ u8 AtkCanceller_UnableToUseMove(void)
             gBattleStruct->atkCancellerTracker++;
             break;
         case 10: // paralysis
-            if (gBattleMons[gBattlerAttacker].status1 & STATUS_PARALYSIS && (Random() % 4) == 0)
+            if (gBattleMons[gBattlerAttacker].status1 & STATUS1_PARALYSIS && (Random() % 4) == 0)
             {
                 gProtectStructs[gBattlerAttacker].prlzImmobility = 1;
                 CancelMultiTurnMoves(gBattlerAttacker);
@@ -1545,7 +1591,7 @@ u8 AtkCanceller_UnableToUseMove(void)
                     {
                         gCurrentMove = MOVE_BIDE;
                         *bideDmg = gTakenDmg[gBattlerAttacker] * 2;
-                        gBattlerTarget = gTakenDmgBanks[gBattlerAttacker];
+                        gBattlerTarget = gTakenDmgByBattler[gBattlerAttacker];
                         if (gAbsentBattlerFlags & gBitTable[gBattlerTarget])
                             gBattlerTarget = GetMoveTarget(MOVE_BIDE, 1);
                         gBattlescriptCurrInstr = BattleScript_BideAttack;
@@ -1558,11 +1604,11 @@ u8 AtkCanceller_UnableToUseMove(void)
             gBattleStruct->atkCancellerTracker++;
             break;
         case 13: // move thawing
-            if (gBattleMons[gBattlerAttacker].status1 & STATUS_FREEZE)
+            if (gBattleMons[gBattlerAttacker].status1 & STATUS1_FREEZE)
             {
                 if (gBattleMoves[gCurrentMove].effect == EFFECT_THAW_HIT)
                 {
-                    gBattleMons[gBattlerAttacker].status1 &= ~(STATUS_FREEZE);
+                    gBattleMons[gBattlerAttacker].status1 &= ~(STATUS1_FREEZE);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_MoveUsedUnfroze;
                     gBattleCommunication[MULTISTRING_CHOOSER] = 1;
@@ -1873,17 +1919,17 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg)
                     }
                     break;
                 case ABILITY_SHED_SKIN:
-                    if ((gBattleMons[bank].status1 & STATUS_ANY) && (Random() % 3) == 0)
+                    if ((gBattleMons[bank].status1 & STATUS1_ANY) && (Random() % 3) == 0)
                     {
-                        if (gBattleMons[bank].status1 & (STATUS_POISON | STATUS_TOXIC_POISON))
+                        if (gBattleMons[bank].status1 & (STATUS1_POISON | STATUS1_TOXIC_POISON))
                             StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn);
-                        if (gBattleMons[bank].status1 & STATUS_SLEEP)
+                        if (gBattleMons[bank].status1 & STATUS1_SLEEP)
                             StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn);
-                        if (gBattleMons[bank].status1 & STATUS_PARALYSIS)
+                        if (gBattleMons[bank].status1 & STATUS1_PARALYSIS)
                             StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn);
-                        if (gBattleMons[bank].status1 & STATUS_BURN)
+                        if (gBattleMons[bank].status1 & STATUS1_BURN)
                             StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn);
-                        if (gBattleMons[bank].status1 & STATUS_FREEZE)
+                        if (gBattleMons[bank].status1 & STATUS1_FREEZE)
                             StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn);
                         gBattleMons[bank].status1 = 0;
                         // BUG: The nightmare status does not get cleared here. This was fixed in Emerald.
@@ -1955,7 +2001,7 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg)
                     }
                     break;
                 case ABILITY_FLASH_FIRE:
-                    if (moveType == TYPE_FIRE && !(gBattleMons[bank].status1 & STATUS_FREEZE))
+                    if (moveType == TYPE_FIRE && !(gBattleMons[bank].status1 & STATUS1_FREEZE))
                     {
                         if (!(eFlashFireArr.arr[bank] & 1))
                         {
@@ -2232,7 +2278,7 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg)
                     switch (gBattleMons[bank].ability)
                     {
                     case ABILITY_IMMUNITY:
-                        if (gBattleMons[bank].status1 & (STATUS_POISON | STATUS_TOXIC_POISON | 0xF00))  // TODO: what is 0xF00?
+                        if (gBattleMons[bank].status1 & (STATUS1_POISON | STATUS1_TOXIC_POISON | 0xF00))  // TODO: what is 0xF00?
                         {
                             StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn);
                             effect = 1;
@@ -2246,7 +2292,7 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg)
                         }
                         break;
                     case ABILITY_LIMBER:
-                        if (gBattleMons[bank].status1 & STATUS_PARALYSIS)
+                        if (gBattleMons[bank].status1 & STATUS1_PARALYSIS)
                         {
                             StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn);
                             effect = 1;
@@ -2254,7 +2300,7 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg)
                         break;
                     case ABILITY_INSOMNIA:
                     case ABILITY_VITAL_SPIRIT:
-                        if (gBattleMons[bank].status1 & STATUS_SLEEP)
+                        if (gBattleMons[bank].status1 & STATUS1_SLEEP)
                         {
                             gBattleMons[bank].status2 &= ~(STATUS2_NIGHTMARE);
                             StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn);
@@ -2262,14 +2308,14 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg)
                         }
                         break;
                     case ABILITY_WATER_VEIL:
-                        if (gBattleMons[bank].status1 & STATUS_BURN)
+                        if (gBattleMons[bank].status1 & STATUS1_BURN)
                         {
                             StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn);
                             effect = 1;
                         }
                         break;
                     case ABILITY_MAGMA_ARMOR:
-                        if (gBattleMons[bank].status1 & STATUS_FREEZE)
+                        if (gBattleMons[bank].status1 & STATUS1_FREEZE)
                         {
                             StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn);
                             effect = 1;
@@ -2751,7 +2797,7 @@ u8 ItemBattleEffects(u8 caseID, u8 bank, bool8 moveTurn)
                     gBattleMoveDamage *= -1;
                     BattleScriptExecute(BattleScript_ItemHealHP_End2);
                     effect = ITEM_HP_CHANGE;
-                    RecordItemBattle(bank, bankHoldEffect);
+                    RecordItemEffectBattle(bank, bankHoldEffect);
                 }
                 break;
             // nice copy/paste there gamefreak, making a function for confuse berries was too much eh?
@@ -2989,41 +3035,41 @@ u8 ItemBattleEffects(u8 caseID, u8 bank, bool8 moveTurn)
                 }
                 break;
             case HOLD_EFFECT_CURE_PAR:
-                if (gBattleMons[bank].status1 & STATUS_PARALYSIS)
+                if (gBattleMons[bank].status1 & STATUS1_PARALYSIS)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_PARALYSIS);
+                    gBattleMons[bank].status1 &= ~(STATUS1_PARALYSIS);
                     BattleScriptExecute(BattleScript_BerryCurePrlzEnd2);
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_PSN:
-                if (gBattleMons[bank].status1 & STATUS_PSN_ANY)
+                if (gBattleMons[bank].status1 & STATUS1_PSN_ANY)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_PSN_ANY | STATUS_TOXIC_COUNTER);
+                    gBattleMons[bank].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER);
                     BattleScriptExecute(BattleScript_BerryCurePsnEnd2);
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_BRN:
-                if (gBattleMons[bank].status1 & STATUS_BURN)
+                if (gBattleMons[bank].status1 & STATUS1_BURN)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_BURN);
+                    gBattleMons[bank].status1 &= ~(STATUS1_BURN);
                     BattleScriptExecute(BattleScript_BerryCureBrnEnd2);
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_FRZ:
-                if (gBattleMons[bank].status1 & STATUS_FREEZE)
+                if (gBattleMons[bank].status1 & STATUS1_FREEZE)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_FREEZE);
+                    gBattleMons[bank].status1 &= ~(STATUS1_FREEZE);
                     BattleScriptExecute(BattleScript_BerryCureFrzEnd2);
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_SLP:
-                if (gBattleMons[bank].status1 & STATUS_SLEEP)
+                if (gBattleMons[bank].status1 & STATUS1_SLEEP)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_SLEEP);
+                    gBattleMons[bank].status1 &= ~(STATUS1_SLEEP);
                     gBattleMons[bank].status2 &= ~(STATUS2_NIGHTMARE);
                     BattleScriptExecute(BattleScript_BerryCureSlpEnd2);
                     effect = ITEM_STATUS_CHANGE;
@@ -3038,31 +3084,31 @@ u8 ItemBattleEffects(u8 caseID, u8 bank, bool8 moveTurn)
                 }
                 break;
             case HOLD_EFFECT_CURE_STATUS:
-                if (gBattleMons[bank].status1 & STATUS_ANY || gBattleMons[bank].status2 & STATUS2_CONFUSION)
+                if (gBattleMons[bank].status1 & STATUS1_ANY || gBattleMons[bank].status2 & STATUS2_CONFUSION)
                 {
                     i = 0;
-                    if (gBattleMons[bank].status1 & STATUS_PSN_ANY)
+                    if (gBattleMons[bank].status1 & STATUS1_PSN_ANY)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn);
                         i++;
                     }
-                    if (gBattleMons[bank].status1 & STATUS_SLEEP)
+                    if (gBattleMons[bank].status1 & STATUS1_SLEEP)
                     {
                         gBattleMons[bank].status2 &= ~(STATUS2_NIGHTMARE);
                         StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn);
                         i++;
                     }
-                    if (gBattleMons[bank].status1 & STATUS_PARALYSIS)
+                    if (gBattleMons[bank].status1 & STATUS1_PARALYSIS)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn);
                         i++;
                     }
-                    if (gBattleMons[bank].status1 & STATUS_BURN)
+                    if (gBattleMons[bank].status1 & STATUS1_BURN)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn);
                         i++;
                     }
-                    if (gBattleMons[bank].status1 & STATUS_FREEZE)
+                    if (gBattleMons[bank].status1 & STATUS1_FREEZE)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn);
                         i++;
@@ -3105,7 +3151,7 @@ u8 ItemBattleEffects(u8 caseID, u8 bank, bool8 moveTurn)
                     MarkBattlerForControllerExec(gActiveBattler);
                     break;
                 case ITEM_PP_CHANGE:
-                    if (!(gBattleMons[bank].status2 & STATUS2_TRANSFORMED) && !(gDisableStructs[bank].unk18_b & gBitTable[i]))
+                    if (!(gBattleMons[bank].status2 & STATUS2_TRANSFORMED) && !(gDisableStructs[bank].mimickedMoves & gBitTable[i]))
                         gBattleMons[bank].pp[i] = changedPP;
                     break;
                 }
@@ -3131,45 +3177,45 @@ u8 ItemBattleEffects(u8 caseID, u8 bank, bool8 moveTurn)
             switch (bankHoldEffect)
             {
             case HOLD_EFFECT_CURE_PAR:
-                if (gBattleMons[bank].status1 & STATUS_PARALYSIS)
+                if (gBattleMons[bank].status1 & STATUS1_PARALYSIS)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_PARALYSIS);
+                    gBattleMons[bank].status1 &= ~(STATUS1_PARALYSIS);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_BerryCureParRet;
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_PSN:
-                if (gBattleMons[bank].status1 & STATUS_PSN_ANY)
+                if (gBattleMons[bank].status1 & STATUS1_PSN_ANY)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_PSN_ANY | STATUS_TOXIC_COUNTER);
+                    gBattleMons[bank].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_BerryCurePsnRet;
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_BRN:
-                if (gBattleMons[bank].status1 & STATUS_BURN)
+                if (gBattleMons[bank].status1 & STATUS1_BURN)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_BURN);
+                    gBattleMons[bank].status1 &= ~(STATUS1_BURN);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_BerryCureBrnRet;
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_FRZ:
-                if (gBattleMons[bank].status1 & STATUS_FREEZE)
+                if (gBattleMons[bank].status1 & STATUS1_FREEZE)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_FREEZE);
+                    gBattleMons[bank].status1 &= ~(STATUS1_FREEZE);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_BerryCureFrzRet;
                     effect = ITEM_STATUS_CHANGE;
                 }
                 break;
             case HOLD_EFFECT_CURE_SLP:
-                if (gBattleMons[bank].status1 & STATUS_SLEEP)
+                if (gBattleMons[bank].status1 & STATUS1_SLEEP)
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_SLEEP);
+                    gBattleMons[bank].status1 &= ~(STATUS1_SLEEP);
                     gBattleMons[bank].status2 &= ~(STATUS2_NIGHTMARE);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_BerryCureSlpRet;
@@ -3197,26 +3243,26 @@ u8 ItemBattleEffects(u8 caseID, u8 bank, bool8 moveTurn)
                 }
                 break;
             case HOLD_EFFECT_CURE_STATUS:
-                if (gBattleMons[bank].status1 & STATUS_ANY || gBattleMons[bank].status2 & STATUS2_CONFUSION)
+                if (gBattleMons[bank].status1 & STATUS1_ANY || gBattleMons[bank].status2 & STATUS2_CONFUSION)
                 {
-                    if (gBattleMons[bank].status1 & STATUS_PSN_ANY)
+                    if (gBattleMons[bank].status1 & STATUS1_PSN_ANY)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn);
                     }
-                    if (gBattleMons[bank].status1 & STATUS_SLEEP)
+                    if (gBattleMons[bank].status1 & STATUS1_SLEEP)
                     {
                         gBattleMons[bank].status2 &= ~(STATUS2_NIGHTMARE);
                         StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn);
                     }
-                    if (gBattleMons[bank].status1 & STATUS_PARALYSIS)
+                    if (gBattleMons[bank].status1 & STATUS1_PARALYSIS)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn);
                     }
-                    if (gBattleMons[bank].status1 & STATUS_BURN)
+                    if (gBattleMons[bank].status1 & STATUS1_BURN)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn);
                     }
-                    if (gBattleMons[bank].status1 & STATUS_FREEZE)
+                    if (gBattleMons[bank].status1 & STATUS1_FREEZE)
                     {
                         StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn);
                     }
@@ -3340,13 +3386,13 @@ void unref_sub_801B40C(void)
                     {
                         gSideTimers[GetBattlerPosition(bank) & 1].field3 = (bank) | ((bank + 2) << 4);
                         gSideTimers[GetBattlerPosition(bank) & 1].field4 = sCombinedMoves[i].newMove;
-                        gSideAffecting[GetBattlerPosition(bank) & 1] |= SIDE_STATUS_X4;
+                        gSideStatuses[GetBattlerPosition(bank) & 1] |= SIDE_STATUS_X4;
                     }
                     if (sCombinedMoves[i].move1 == gChosenMovesByBanks[bank + 2] && sCombinedMoves[i].move2 == gChosenMovesByBanks[bank])
                     {
                         gSideTimers[GetBattlerPosition(bank) & 1].field3 = (bank + 2) | ((bank) << 4);
                         gSideTimers[GetBattlerPosition(bank) & 1].field4 = sCombinedMoves[i].newMove;
-                        gSideAffecting[GetBattlerPosition(bank) & 1] |= SIDE_STATUS_X4;
+                        gSideStatuses[GetBattlerPosition(bank) & 1] |= SIDE_STATUS_X4;
                     }
                     bank++;
                 }
@@ -3477,7 +3523,7 @@ u8 IsMonDisobedient(void)
     // is not obedient
     if (gCurrentMove == MOVE_RAGE)
         gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_RAGE);
-    if (gBattleMons[gBattlerAttacker].status1 & STATUS_SLEEP && (gCurrentMove == MOVE_SNORE || gCurrentMove == MOVE_SLEEP_TALK))
+    if (gBattleMons[gBattlerAttacker].status1 & STATUS1_SLEEP && (gCurrentMove == MOVE_SNORE || gCurrentMove == MOVE_SLEEP_TALK))
     {
         gBattlescriptCurrInstr = gUnknown_081D995F;
         return 1;
@@ -3515,7 +3561,7 @@ u8 IsMonDisobedient(void)
         obedienceLevel = gBattleMons[gBattlerAttacker].level - obedienceLevel;
 
         calc = (Random() & 255);
-        if (calc < obedienceLevel && !(gBattleMons[gBattlerAttacker].status1 & STATUS_ANY) && gBattleMons[gBattlerAttacker].ability != ABILITY_VITAL_SPIRIT && gBattleMons[gBattlerAttacker].ability != ABILITY_INSOMNIA)
+        if (calc < obedienceLevel && !(gBattleMons[gBattlerAttacker].status1 & STATUS1_ANY) && gBattleMons[gBattlerAttacker].ability != ABILITY_VITAL_SPIRIT && gBattleMons[gBattlerAttacker].ability != ABILITY_INSOMNIA)
         {
             // try putting asleep
             int i;
diff --git a/src/berry_blender.c b/src/berry_blender.c
index 8d7a7faab..e55a391f5 100644
--- a/src/berry_blender.c
+++ b/src/berry_blender.c
@@ -1258,7 +1258,7 @@ static void sub_804E9F8(void)
         break;
     case 102:
         if (!gPaletteFade.active)
-            SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+            SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
         break;
     }
     RunTasks();
@@ -2480,7 +2480,7 @@ static void sub_8050E30(void)
         break;
     case 12:
         if (gReceivedRemoteLinkPlayers == 0)
-            SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+            SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
         break;
     }
 
@@ -2529,7 +2529,7 @@ static void sub_80510E8(void)
             if (gBerryBlenderData->field_7C == 0)
                 SetMainCallback2(DoBerryBlending);
             else
-                SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+                SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
         }
         break;
     }
diff --git a/src/bike.c b/src/bike.c
index b1176997b..1f5d45418 100644
--- a/src/bike.c
+++ b/src/bike.c
@@ -20,6 +20,7 @@ extern u8 gUnknown_020297ED;
 u8 debug_sub_805F2B0(u8);
 #endif
 
+// this file's functions
 static void MovePlayerOnMachBike(u8, u16, u16);
 static u8 GetMachBikeTransition(u8 *);
 static void MachBikeTransition_FaceDirection(u8);
@@ -61,6 +62,8 @@ static u8 CanBikeFaceDirOnMetatile(u8, u8);
 static bool8 WillPlayerCollideWithCollision(u8, u8);
 static void Bike_SetBikeStill(void);
 
+// const rom data
+
 /*
     A bike transition is a type of callback for the bike that actually
     modifies the bicycle's direction or momentum or otherwise movement.
@@ -123,7 +126,7 @@ static const u8 sAcroBikeJumpTimerList[] = {4, 0};
 // this is a list of history inputs to do in order to do the check to retrieve a jump direction for acro bike. it seems to be an extensible list, so its possible that Game Freak may have intended for the Acro Bike to have more complex tricks at some point. The final list only has the acro jump.
 static const struct BikeHistoryInputInfo sAcroBikeTricksList[] =
 {
-    // the 0xF is a mask performed with each byte of the array in order to perform the check on only the last entry of the history list, otherwise the check wouldnt work as there can be 0xF0 as opposed to 0x0F.
+    // the 0xF is a mask performed with each byte of the array in order to perform the check on only the last entry of the history list, otherwise the check wouldn't work as there can be 0xF0 as opposed to 0x0F.
     {DIR_SOUTH, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_SOUTH},
     {DIR_NORTH, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_NORTH},
     {DIR_WEST, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_WEST},
@@ -630,7 +633,7 @@ static void AcroBikeTransition_WheelieHoppingMoving(u8 direction)
         return;
     }
     collision = get_some_collision(direction);
-    //TODO: Try to get rid of this goto
+    // TODO: Try to get rid of this goto
     if (collision == 0 || collision == 9)
     {
         goto derp;
@@ -647,7 +650,7 @@ static void AcroBikeTransition_WheelieHoppingMoving(u8 direction)
         }
         else
         {
-          derp:
+        derp:
             PlayerMovingHoppingWheelie(direction);
         }
     }
@@ -755,7 +758,7 @@ static void AcroBikeTransition_WheelieRisingMoving(u8 direction)
 
 static void AcroBikeTransition_WheelieLoweringMoving(u8 direction)
 {
-    u8 var;
+    u8 collision;
     struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
 
     if (CanBikeFaceDirOnMetatile(direction, playerEventObj->currentMetatileBehavior) == 0)
@@ -763,12 +766,12 @@ static void AcroBikeTransition_WheelieLoweringMoving(u8 direction)
         PlayerEndWheelie(playerEventObj->movementDirection);
         return;
     }
-    var = get_some_collision(direction);
-    if (var > 0 && var < 12)
+    collision = get_some_collision(direction);
+    if (collision > 0 && collision < 12)
     {
-        if (var == 6)
+        if (collision == 6)
             PlayerJumpLedge(direction);
-        else if (var < 5 || var > 8)
+        else if (collision < 5 || collision > 8)
             PlayerEndWheelie(direction);
         return;
     }
diff --git a/src/cable_club.c b/src/cable_club.c
index b030d8cc2..28bf3b759 100644
--- a/src/cable_club.c
+++ b/src/cable_club.c
@@ -940,7 +940,7 @@ void unref_sub_8083BB0(void)
 
 void sub_8083BDC(void)
 {
-    TrainerCard_ShowLinkCard(gSpecialVar_0x8006, c2_exit_to_overworld_1_continue_scripts_restart_music);
+    TrainerCard_ShowLinkCard(gSpecialVar_0x8006, CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 bool32 sub_8083BF4(u8 linkPlayerIndex)
diff --git a/src/calculate_base_damage.c b/src/calculate_base_damage.c
index e4ae70c0b..760887834 100644
--- a/src/calculate_base_damage.c
+++ b/src/calculate_base_damage.c
@@ -153,7 +153,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de
         if (attackerHoldEffect == gHoldEffectToType[i][0]
             && type == gHoldEffectToType[i][1])
         {
-            if (TYPE_IS_PHYSICAL(type))
+            if (IS_TYPE_PHYSICAL(type))
                 attack = (attack * (attackerHoldEffectParam + 100)) / 100;
             else
                 spAttack = (spAttack * (attackerHoldEffectParam + 100)) / 100;
@@ -204,7 +204,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de
     if (gBattleMoves[gCurrentMove].effect == EFFECT_EXPLOSION)
         defense /= 2;
 
-    if (TYPE_IS_PHYSICAL(type)) // type < TYPE_MYSTERY
+    if (IS_TYPE_PHYSICAL(type)) // type < TYPE_MYSTERY
     {
         if (gCritMultiplier == 2)
         {
@@ -232,7 +232,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de
         damage = damage / damageHelper;
         damage /= 50;
 
-        if ((attacker->status1 & STATUS_BURN) && attacker->ability != ABILITY_GUTS)
+        if ((attacker->status1 & STATUS1_BURN) && attacker->ability != ABILITY_GUTS)
             damage /= 2;
 
         if ((sideStatus & SIDE_STATUS_REFLECT) && gCritMultiplier == 1)
@@ -254,7 +254,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de
     if (type == TYPE_MYSTERY)
         damage = 0; // is ??? type. does 0 damage.
 
-    if (TYPE_IS_SPECIAL(type)) // type > TYPE_MYSTERY
+    if (IS_TYPE_SPECIAL(type)) // type > TYPE_MYSTERY
     {
         if (gCritMultiplier == 2)
         {
diff --git a/src/clock.c b/src/clock.c
index fceccdfcb..3bea39754 100644
--- a/src/clock.c
+++ b/src/clock.c
@@ -1,21 +1,20 @@
 #include "global.h"
 #include "clock.h"
-#include "berry.h"
-#include "dewford_trend.h"
 #include "event_data.h"
+#include "rtc.h"
+#include "time_events.h"
 #include "field_specials.h"
-#include "field_weather.h"
 #include "lottery_corner.h"
+#include "dewford_trend.h"
+#include "tv.h"
+#include "field_weather.h"
+#include "berry.h"
 #include "main.h"
 #include "overworld.h"
-#include "rtc.h"
-#include "time_events.h"
-#include "tv.h"
 #include "wallclock.h"
 
-static void UpdatePerDay(struct Time *time);
-static void UpdatePerMinute(struct Time *time);
-static void ReturnFromStartWallClock(void);
+static void UpdatePerDay(struct Time *localTime);
+static void UpdatePerMinute(struct Time *localTime);
 
 void InitTimeBasedEvents(void)
 {
@@ -35,50 +34,49 @@ void DoTimeBasedEvents(void)
     }
 }
 
-static void UpdatePerDay(struct Time *time)
+static void UpdatePerDay(struct Time *localTime)
 {
     u16 *varPtr = GetVarPointer(VAR_DAYS);
     int days = *varPtr;
-    u16 newDays;
+    u16 daysSince;
 
-    if (days != time->days && days <= time->days)
+    if (days != localTime->days && days <= localTime->days)
     {
-        newDays = time->days - days;
+        daysSince = localTime->days - days;
         ClearDailyFlags();
-        UpdateDewfordTrendPerDay(newDays);
-        UpdateTVShowsPerDay(newDays);
-        UpdateWeatherPerDay(newDays);
-        UpdatePartyPokerusTime(newDays);
-        UpdateMirageRnd(newDays);
-        UpdateBirchState(newDays);
-        SetShoalItemFlag(newDays);
-        SetRandomLotteryNumber(newDays);
-        *varPtr = time->days;
+        UpdateDewfordTrendPerDay(daysSince);
+        UpdateTVShowsPerDay(daysSince);
+        UpdateWeatherPerDay(daysSince);
+        UpdatePartyPokerusTime(daysSince);
+        UpdateMirageRnd(daysSince);
+        UpdateBirchState(daysSince);
+        SetShoalItemFlag(daysSince);
+        SetRandomLotteryNumber(daysSince);
+        *varPtr = localTime->days;
     }
 }
 
-static void UpdatePerMinute(struct Time *time)
+static void UpdatePerMinute(struct Time *localTime)
 {
-    struct Time newTime;
-    s32 minutesPassed;
-
-    CalcTimeDifference(&newTime, &gSaveBlock2.lastBerryTreeUpdate, time);
-    minutesPassed = 1440 * newTime.days + 60 * newTime.hours + newTime.minutes;
-
-    if (minutesPassed == 0) // do not do the update for the first minute.
-        return;
+    struct Time difference;
+    int minutes;
 
-    if (minutesPassed > -1) // do not perform an update on invalid minutesPassed.
+    CalcTimeDifference(&difference, &gSaveBlock2.lastBerryTreeUpdate, localTime);
+    minutes = 24 * 60 * difference.days + 60 * difference.hours + difference.minutes;
+    if (minutes != 0)
     {
-        BerryTreeTimeUpdate(minutesPassed);
-        gSaveBlock2.lastBerryTreeUpdate = *time;
+        if (minutes >= 0)
+        {
+            BerryTreeTimeUpdate(minutes);
+            gSaveBlock2.lastBerryTreeUpdate = *localTime;
+        }
     }
 }
 
 static void ReturnFromStartWallClock(void)
 {
     InitTimeBasedEvents();
-    SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+    SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 void StartWallClock(void)
diff --git a/src/contest.c b/src/contest.c
index 54294fdfa..9fb17a86b 100644
--- a/src/contest.c
+++ b/src/contest.c
@@ -46,7 +46,7 @@ extern u8 gDisplayedStringBattle[];
 extern u16 gBattleTypeFlags;
 extern u8 gBattlerAttacker;
 extern u8 gBattlerTarget;
-extern u8 gBanksBySide[];
+extern u8 gBattlerPositions[];
 extern u8 gBattlerSpriteIds[];
 extern struct Window gUnknown_03004210;
 extern u32 gContestRngValue;
@@ -528,10 +528,10 @@ u8 sub_80AB70C(u8 *a)
         CreateApplauseMeterSprite();
         sub_80B0324();
         sub_80B0518();
-        gBanksBySide[0] = 0;
-        gBanksBySide[1] = 1;
-        gBanksBySide[2] = 3;
-        gBanksBySide[3] = 2;
+        gBattlerPositions[0] = 0;
+        gBattlerPositions[1] = 1;
+        gBattlerPositions[2] = 3;
+        gBattlerPositions[3] = 2;
         gBattleTypeFlags = 0;
         gBattlerAttacker = 2;
         gBattlerTarget = 3;
diff --git a/src/contest_link_80C2020.c b/src/contest_link_80C2020.c
index 8269f424b..f4203dd42 100644
--- a/src/contest_link_80C2020.c
+++ b/src/contest_link_80C2020.c
@@ -753,7 +753,7 @@ static void sub_80C2EA0(u8 taskId)
             REG_BLDCNT = 0;
             REG_BLDY = 0;
             DestroyTask(taskId);
-            SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+            SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
         }
     }
 }
diff --git a/src/debug/tomomichi_debug_menu.c b/src/debug/tomomichi_debug_menu.c
index 7bf23a05c..c9804c638 100644
--- a/src/debug/tomomichi_debug_menu.c
+++ b/src/debug/tomomichi_debug_menu.c
@@ -1889,7 +1889,7 @@ bool8 InitTomomichiDebugWindow(void)
 
 static void debug_sub_808B868(void)
 {
-    c2_exit_to_overworld_1_continue_scripts_restart_music();
+    CB2_ReturnToFieldContinueScriptPlayMapMusic();
 }
 
 static bool8 InitDebugWindow(void)
diff --git a/src/field_specials.c b/src/field_specials.c
index c23a8c44c..5e0315e73 100644
--- a/src/field_specials.c
+++ b/src/field_specials.c
@@ -769,7 +769,7 @@ u8 GetLeadMonFriendshipScore(void)
 
 void CB2_FieldShowRegionMap(void)
 {
-    FieldInitRegionMap(c2_exit_to_overworld_1_continue_scripts_restart_music);
+    FieldInitRegionMap(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 void FieldShowRegionMap(void)
diff --git a/src/main.c b/src/main.c
index ad4a669b7..972c8486f 100644
--- a/src/main.c
+++ b/src/main.c
@@ -2,13 +2,13 @@
 #include "gba/flash_internal.h"
 #include "gba/m4a_internal.h"
 #include "main.h"
+#include "battle_controllers.h"
 #include "intro.h"
 #include "link.h"
 #include "load_save.h"
 #include "m4a.h"
 #include "play_time.h"
 #include "random.h"
-#include "rom3.h"
 #include "overworld.h"
 #include "rtc.h"
 #include "siirtc.h"
diff --git a/src/overworld.c b/src/overworld.c
index 19fe5f377..934b09dbc 100644
--- a/src/overworld.c
+++ b/src/overworld.c
@@ -1441,7 +1441,7 @@ void sub_80546B8(void)
     CB2_ReturnToField();
 }
 
-void c2_exit_to_overworld_1_continue_scripts_restart_music(void)
+void CB2_ReturnToFieldContinueScriptPlayMapMusic(void)
 {
     FieldClearVBlankHBlankCallbacks();
     gFieldCallback = sub_8080990;
diff --git a/src/pokemon_item_effect.c b/src/pokemon_item_effect.c
index 2542e42c3..d59e8d77c 100644
--- a/src/pokemon_item_effect.c
+++ b/src/pokemon_item_effect.c
@@ -367,7 +367,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *pkmn, u16 item, u8 partyIndex, u8 mo
                                     SetMonData(pkmn, MON_DATA_PP1 + r5, &data);
                                     if (gMain.inBattle
                                      && sp34 != 4 && !(gBattleMons[sp34].status2 & 0x200000)
-                                     && !(gDisableStructs[sp34].unk18_b & gBitTable[r5]))
+                                     && !(gDisableStructs[sp34].mimickedMoves & gBitTable[r5]))
                                         gBattleMons[sp34].pp[r5] = data;
                                     retVal = FALSE;
                                 }
@@ -392,7 +392,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *pkmn, u16 item, u8 partyIndex, u8 mo
                                 SetMonData(pkmn, MON_DATA_PP1 + moveIndex, &data);
                                 if (gMain.inBattle
                                  && sp34 != 4 && !(gBattleMons[sp34].status2 & 0x200000)
-                                 && !(gDisableStructs[sp34].unk18_b & gBitTable[moveIndex]))
+                                 && !(gDisableStructs[sp34].mimickedMoves & gBitTable[moveIndex]))
                                     gBattleMons[sp34].pp[moveIndex] = data;
                                 retVal = FALSE;
                             }
diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c
index e970cc3bc..ef8360681 100644
--- a/src/pokemon_summary_screen.c
+++ b/src/pokemon_summary_screen.c
@@ -4772,15 +4772,15 @@ void sub_80A1C30(u8 a)
 
 u8 GetPrimaryStatus(u32 status)
 {
-    if (status & (STATUS_POISON | STATUS_TOXIC_POISON))
+    if (status & (STATUS1_POISON | STATUS1_TOXIC_POISON))
         return STATUS_PRIMARY_POISON;
-    if (status & STATUS_PARALYSIS)
+    if (status & STATUS1_PARALYSIS)
         return STATUS_PRIMARY_PARALYSIS;
-    if (status & STATUS_SLEEP)
+    if (status & STATUS1_SLEEP)
         return STATUS_PRIMARY_SLEEP;
-    if (status & STATUS_FREEZE)
+    if (status & STATUS1_FREEZE)
         return STATUS_PRIMARY_FREEZE;
-    if (status & STATUS_BURN)
+    if (status & STATUS1_BURN)
         return STATUS_PRIMARY_BURN;
 
     return STATUS_PRIMARY_NONE;
diff --git a/src/rom_8077ABC.c b/src/rom_8077ABC.c
index e7c49144e..036209fbf 100644
--- a/src/rom_8077ABC.c
+++ b/src/rom_8077ABC.c
@@ -62,7 +62,7 @@ extern u8 gBattleMonSprites[NUM_BATTLE_SLOTS];
 extern u8 gBattleAnimAttacker;
 extern u8 gBattleAnimTarget;
 extern s16 gBattleAnimArgs[8];
-extern u8 gBanksBySide[NUM_BATTLE_SLOTS];
+extern u8 gBattlerPositions[NUM_BATTLE_SLOTS];
 extern u8 gBattlersCount; // gNumBattleMons?
 extern struct OamMatrix gOamMatrices[];
 extern struct Struct_2017810 unk_2017810[];
@@ -815,12 +815,12 @@ void InitAnimSpritePos(struct Sprite *sprite, u8 a2)
 
 u8 GetBattlerSide(u8 slot)
 {
-    return gBanksBySide[slot] & 1;
+    return gBattlerPositions[slot] & 1;
 }
 
 u8 GetBattlerPosition(u8 slot)
 {
-    return gBanksBySide[slot];
+    return gBattlerPositions[slot];
 }
 
 u8 GetBattlerAtPosition(u8 slot)
@@ -829,7 +829,7 @@ u8 GetBattlerAtPosition(u8 slot)
 
     for (i = 0; i < gBattlersCount; i++)
     {
-        if (gBanksBySide[i] == slot)
+        if (gBattlerPositions[i] == slot)
             break;
     }
     return i;
@@ -847,7 +847,7 @@ bool8 IsBankSpritePresent(u8 slot)
     }
     else
     {
-        if (gBanksBySide[slot] == 0xff)
+        if (gBattlerPositions[slot] == 0xff)
             return FALSE;
         if (GetBattlerSide(slot) != B_SIDE_PLAYER)
         {
diff --git a/src/safari_zone.c b/src/safari_zone.c
index 7aa05c7dc..8e5f3c692 100644
--- a/src/safari_zone.c
+++ b/src/safari_zone.c
@@ -110,7 +110,7 @@ void sub_80C824C(void)
     {
         ScriptContext1_SetupScript(&gUnknown_081C3459);
         ScriptContext1_Stop();
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+        SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
     }
 }
 
diff --git a/src/scrcmd.c b/src/scrcmd.c
index 6084cfc5d..4dd5d08a2 100644
--- a/src/scrcmd.c
+++ b/src/scrcmd.c
@@ -1782,7 +1782,7 @@ bool8 ScrCmd_playslotmachine(struct ScriptContext *ctx)
 {
     u8 v2 = VarGet(ScriptReadHalfword(ctx));
 
-    PlaySlotMachine(v2, c2_exit_to_overworld_1_continue_scripts_restart_music);
+    PlaySlotMachine(v2, CB2_ReturnToFieldContinueScriptPlayMapMusic);
     ScriptContext1_Stop();
     return TRUE;
 }
diff --git a/src/script_pokemon_util_80C4BF0.c b/src/script_pokemon_util_80C4BF0.c
index f6cb8ae0a..ce6c01439 100644
--- a/src/script_pokemon_util_80C4BF0.c
+++ b/src/script_pokemon_util_80C4BF0.c
@@ -214,7 +214,7 @@ void sub_80C4D80(void)
 
 void ShowContestWinnerCleanup(void)
 {
-    SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+    SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 void ShowContestWinner(void)
@@ -521,7 +521,7 @@ void sub_80C5580(void)
         break;
     }
 
-    SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+    SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 void ChooseBattleTowerPlayerParty(void)
@@ -546,7 +546,7 @@ void SetBattleTowerPlayerParty(void)
         break;
     }
 
-    SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
+    SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
 void ReducePlayerPartyToThree(void)
diff --git a/src/tv.c b/src/tv.c
index 9cd8d7eea..8badfd405 100644
--- a/src/tv.c
+++ b/src/tv.c
@@ -635,7 +635,7 @@ void GabbyAndTyBeforeInterview(void)
     gSaveBlock1.gabbyAndTyData.lastMove = gBattleResults.lastUsedMove;
     if (gSaveBlock1.gabbyAndTyData.battleNum != 0xff)
         gSaveBlock1.gabbyAndTyData.battleNum ++;
-    gSaveBlock1.gabbyAndTyData.valA_0 = gBattleResults.unk5_0;
+    gSaveBlock1.gabbyAndTyData.valA_0 = gBattleResults.playerMonWasDamaged;
 
     if (gBattleResults.playerFaintCounter)
         gSaveBlock1.gabbyAndTyData.valA_1 = 1;
@@ -2074,7 +2074,7 @@ void ChangePokemonNickname(void)
 void ChangePokemonNickname_CB(void)
 {
     SetMonData(&(gPlayerParty[gSpecialVar_0x8004]), MON_DATA_NICKNAME, gStringVar2);
-    c2_exit_to_overworld_1_continue_scripts_restart_music();
+    CB2_ReturnToFieldContinueScriptPlayMapMusic();
 }
 
 void TV_CopyNicknameToStringVar1AndEnsureTerminated(void)