Merge branch 'master' into record_mixing

1 files changed, 2429 insertions, 2885 deletions

diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index c6cec7f0d..4d40d83a8 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -1,20 +1,25 @@
 #include "global.h"
 #include "battle.h"
-#include "battle_move_effects.h"
+#include "constants/battle_move_effects.h"
+#include "constants/battle_script_commands.h"
 #include "battle_message.h"
 #include "battle_ai_script_commands.h"
-#include "moves.h"
-#include "abilities.h"
+#include "battle_scripts.h"
+#include "constants/moves.h"
+#include "constants/abilities.h"
 #include "item.h"
-#include "items.h"
-#include "hold_effects.h"
+#include "constants/items.h"
+#include "constants/hold_effects.h"
 #include "util.h"
 #include "pokemon.h"
 #include "calculate_base_damage.h"
-#include "rng.h"
+#include "random.h"
 #include "battle_controllers.h"
-#include "species.h"
-#include "songs.h"
+#include "battle_interface.h"
+#include "constants/species.h"
+#include "constants/songs.h"
+#include "constants/trainers.h"
+#include "constants/battle_anim.h"
 #include "text.h"
 #include "sound.h"
 #include "pokedex.h"
@@ -34,81 +39,16 @@
 #include "pokemon_storage_system.h"
 #include "task.h"
 #include "naming_screen.h"
-#include "battle_string_ids.h"
-
-// variables
-
-extern u8 gCritMultiplier;
-extern s32 gBattleMoveDamage;
-extern u32 gStatuses3[BATTLE_BANKS_COUNT];
-extern u32 gBattleTypeFlags;
-extern struct BattleEnigmaBerry gEnigmaBerries[BATTLE_BANKS_COUNT];
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
-extern u8 gActiveBank;
-extern u32 gBattleExecBuffer;
-extern u8 gNoOfAllBanks;
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern u8 gBanksByTurnOrder[BATTLE_BANKS_COUNT];
-extern u8 gActionsByTurnOrder[BATTLE_BANKS_COUNT];
-extern u16 gCurrentMove;
-extern u8 gLastUsedAbility;
-extern u16 gBattleWeather;
-extern u8 gStringBank;
-extern u8 gEffectBank;
-extern u8 gAbsentBankFlags;
-extern u8 gMultiHitCounter;
-extern u16 gChosenMovesByBanks[BATTLE_BANKS_COUNT];
-extern u16 gSideAffecting[2];
-extern u16 gPauseCounterBattle;
-extern u16 gPaydayMoney;
-extern u16 gRandomTurnNumber;
-extern u8 gBattleOutcome;
-extern u8 gBattleTerrain;
-extern u8 gBankAttacker;
-extern u8 gBankTarget;
-extern const u8* gBattlescriptCurrInstr;
-extern u8 gCurrMovePos;
-extern u8 gCurrentActionFuncId;
-extern u32 gHitMarker;
-extern u8 gBattleMoveFlags;
-extern u8 gBattleCommunication[];
-extern u16 gUnknown_02024250[4];
-extern u16 gUnknown_02024258[4];
-extern u16 gUnknown_02024260[4];
-extern u8 gUnknown_02024270[4];
-extern u8 gStringBank;
-extern u16 gDynamicBasePower;
-extern u16 gLastUsedItem;
-extern u16 gBattleMovePower;
-extern s32 gHpDealt;
-extern s32 gTakenDmg[BATTLE_BANKS_COUNT];
-extern u8 gTakenDmgBanks[BATTLE_BANKS_COUNT];
-extern u8 gSentPokesToOpponent[2];
-extern u8 gBank1;
-extern u16 gExpShareExp;
-extern u8 gLeveledUpInBattle;
-extern void (*gBattleMainFunc)(void);
-extern u8 gPlayerPartyCount;
-extern u16 gMoveToLearn;
-extern u16 gRandomMove;
-extern u8 gBankInMenu;
-extern u8 gActionForBanks[BATTLE_BANKS_COUNT];
-extern u8 gCurrentTurnActionNumber;
-extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200];
-extern u16 gLockedMoves[BATTLE_BANKS_COUNT];
-extern u16 gPartnerTrainerId;
-extern u16 gLastUsedMove;
-extern u16 gUnknownMovesUsedByBanks[BATTLE_BANKS_COUNT];
-extern u16 gLastUsedMovesByBanks[BATTLE_BANKS_COUNT];
-extern u16 gTrainerBattleOpponent_A;
-extern u16 gTrainerBattleOpponent_B;
-extern u8 gUnknown_020241E9;
+#include "constants/battle_string_ids.h"
+#include "battle_setup.h"
+#include "overworld.h"
+
 extern u16 gBattle_BG1_X;
 extern u16 gBattle_BG1_Y;
 extern u16 gBattle_BG2_X;
 extern u16 gBattle_BG2_Y;
 extern u16 gBattle_BG3_X;
-extern struct MusicPlayerInfo gMPlay_BGM;
+extern struct MusicPlayerInfo gMPlayInfo_BGM;
 
 struct TrainerMoney
 {
@@ -117,19 +57,15 @@ struct TrainerMoney
 };
 
 extern const struct BattleMove gBattleMoves[];
-extern const struct BaseStats gBaseStats[];
-extern const u8 gTypeEffectiveness[];
-extern const u16 gMissStringIds[];
-extern const u16 gTrappingMoves[];
+extern const u8 gTypeEffectiveness[336];
 extern const struct TrainerMoney gTrainerMoneyTable[];
 extern const u8* const gBattleScriptsForMoveEffects[];
 
 // functions
-extern void sub_81A5718(u8 bank); // battle frontier 2
+extern void sub_81A5718(u8 battlerId); // battle frontier 2
 extern void sub_81A56B4(void); // battle frontier 2
 extern void sub_81BFA38(struct Pokemon* party, u8 monPartyId, u8 monCount, void (*callback)(void), u16 move); // pokemon summary screen
 extern u8 sub_81C1B94(void); // pokemon summary screen
-extern void IncrementGameStat(u8 statId); // rom_4
 extern void sub_81D388C(struct Pokemon* mon, void* statStoreLocation); // pokenav.s
 extern void sub_81D3640(u8 arg0, void* statStoreLocation1, void* statStoreLocation2, u8 arg3, u8 arg4, u8 arg5); // pokenav.s
 extern void sub_81D3784(u8 arg0, void* statStoreLocation1, u8 arg2, u8 arg3, u8 arg4); // pokenav.s
@@ -137,98 +73,14 @@ extern u8* GetMonNickname(struct Pokemon* mon, u8* dst); // party_menu
 extern u8 sub_81A5258(u8* arg0); // battle frontier 2
 extern void sub_81A5BF8(void); // battle frontier 2
 extern void sub_81A5D44(void); // battle frontier 2
-extern void sub_81B8E80(u8 bank, u8, u8); // party menu
+extern void sub_81B8E80(u8 battlerId, u8, u8); // party menu
 extern bool8 sub_81B1250(void); // ?
-extern u8 GetScaledHPFraction(s16 hp, s16 maxhp, u8 scale); // battle interface
 extern bool8 InBattlePike(void);
 extern bool8 InBattlePyramid(void);
 extern u16 GetBattlePyramidPickupItemId(void);
 extern u8 sav1_map_get_light_level(void);
 extern u8 sub_813B21C(void);
 extern u16 get_unknown_box_id(void);
-extern void sub_80356D0(void);
-
-// BattleScripts
-extern const u8 BattleScript_MoveEnd[];
-extern const u8 BattleScript_NoPPForMove[];
-extern const u8 BattleScript_MagicCoatBounce[];
-extern const u8 BattleScript_TookAttack[];
-extern const u8 BattleScript_SnatchedMove[];
-extern const u8 BattleScript_Pausex20[];
-extern const u8 BattleScript_SubstituteFade[];
-extern const u8 BattleScript_HangedOnMsg[];
-extern const u8 BattleScript_OneHitKOMsg[];
-extern const u8 BattleScript_EnduredMsg[];
-extern const u8 BattleScript_PSNPrevention[];
-extern const u8 BattleScript_BRNPrevention[];
-extern const u8 BattleScript_PRLZPrevention[];
-extern const u8 BattleScript_FlinchPrevention[];
-extern const u8 BattleScript_StatUp[];
-extern const u8 BattleScript_StatDown[];
-extern const u8 BattleScript_NoItemSteal[];
-extern const u8 BattleScript_ItemSteal[];
-extern const u8 BattleScript_RapidSpinAway[];
-extern const u8 BattleScript_TargetPRLZHeal[];
-extern const u8 BattleScript_KnockedOff[];
-extern const u8 BattleScript_StickyHoldActivates[];
-extern const u8 BattleScript_AllStatsUp[];
-extern const u8 BattleScript_AtkDefDown[];
-extern const u8 BattleScript_SAtkDown2[];
-extern const u8 BattleScript_LevelUp[];
-extern const u8 BattleScript_WrapFree[];
-extern const u8 BattleScript_LeechSeedFree[];
-extern const u8 BattleScript_SpikesFree[];
-extern const u8 BattleScript_ButItFailed[];
-extern const u8 BattleScript_ObliviousPreventsAttraction[];
-extern const u8 BattleScript_MistProtected[];
-extern const u8 BattleScript_AbilityNoStatLoss[];
-extern const u8 BattleScript_AbilityNoSpecificStatLoss[];
-extern const u8 BattleScript_TrainerBallBlock[];
-extern const u8 BattleScript_WallyBallThrow[];
-extern const u8 BattleScript_SuccessBallThrow[];
-extern const u8 BattleScript_ShakeBallThrow[];
-extern const u8 BattleScript_FaintAttacker[];
-extern const u8 BattleScript_FaintTarget[];
-extern const u8 BattleScript_DestinyBondTakesLife[];
-extern const u8 BattleScript_GrudgeTakesPp[];
-extern const u8 BattleScript_RageIsBuilding[];
-extern const u8 BattleScript_DefrostedViaFireMove[];
-extern const u8 gUnknown_082DB87D[];
-extern const u8 gUnknown_082DAE90[];
-extern const u8 gUnknown_082DAE59[];
-extern const u8 gUnknown_082DAEC7[];
-extern const u8 BattleScript_MoveEffectSleep[];
-extern const u8 BattleScript_MoveEffectPoison[];
-extern const u8 BattleScript_MoveEffectBurn[];
-extern const u8 BattleScript_MoveEffectFreeze[];
-extern const u8 BattleScript_MoveEffectParalysis[];
-extern const u8 BattleScript_MoveEffectToxic[];
-extern const u8 BattleScript_MoveEffectConfusion[];
-extern const u8 BattleScript_MoveEffectUproar[];
-extern const u8 BattleScript_MoveEffectPayDay[];
-extern const u8 BattleScript_MoveEffectWrap[];
-extern const u8 BattleScript_MoveEffectRecoil33[];
-extern const u8 BattleScript_DampStopsExplosion[];
-extern const u8 BattleScript_MistProtected[];
-extern const u8 BattleScript_AbilityNoStatLoss[];
-extern const u8 BattleScript_AbilityNoSpecificStatLoss[];
-extern const u8 BattleScript_ButItFailed[];
-extern const u8 gUnknown_082DADD8[];
-extern const u8 BattleScript_PrintPayDayMoneyString[];
-extern const u8 BattleScript_SturdyPreventsOHKO[];
-extern const u8 BattleScript_ObliviousPreventsAttraction[];
-extern const u8 BattleScript_PauseEffectivenessSoundResultMsgEndMove[];
-extern const u8 BattleScript_CastformChange[];
-extern const u8 BattleScript_TrainerBallBlock[];
-extern const u8 BattleScript_WallyBallThrow[];
-extern const u8 BattleScript_SuccessBallThrow[];
-extern const u8 BattleScript_ShakeBallThrow[];
-extern const u8 BattleScript_PresentDamageTarget[];
-extern const u8 BattleScript_AlreadyAtFullHp[];
-extern const u8 BattleScript_PresentHealTarget[];
-extern const u8 BattleScript_WrapFree[];
-extern const u8 BattleScript_LeechSeedFree[];
-extern const u8 BattleScript_SpikesFree[];
 
 // strings
 extern const u8 gText_BattleYesNoChoice[];
@@ -243,14 +95,15 @@ extern const u8 gText_BattleYesNoChoice[];
 #define BS2ScriptRead16(ptr) ((ptr)[0] + ((ptr)[1] << 8))
 #define BS2ScriptReadPtr(ptr) ((void *)BS2ScriptRead32(ptr))
 
-#define TARGET_PROTECT_AFFECTED ((gProtectStructs[gBankTarget].protected && gBattleMoves[gCurrentMove].flags & FLAG_PROTECT_AFFECTED))
+#define DEFENDER_IS_PROTECTED ((gProtectStructs[gBattlerTarget].protected) && (gBattleMoves[gCurrentMove].flags & FLAG_PROTECT_AFFECTED))
 
-#define TARGET_TURN_DAMAGED (((gSpecialStatuses[gBankTarget].moveturnLostHP_physical || gSpecialStatuses[gBankTarget].moveturnLostHP_special)))
+#define TARGET_TURN_DAMAGED (gSpecialStatuses[gBattlerTarget].physicalDmg != 0 \
+                          || gSpecialStatuses[gBattlerTarget].specialDmg != 0)
 
 // this file's functions
 static bool8 IsTwoTurnsMove(u16 move);
-static void DestinyBondFlagUpdate(void);
-static u8 AttacksThisTurn(u8 bank, u16 move); // Note: returns 1 if it's a charging turn, otherwise 2.
+static void TrySetDestinyBondToHappen(void);
+static u8 AttacksThisTurn(u8 battlerId, u16 move); // Note: returns 1 if it's a charging turn, otherwise 2.
 static void CheckWonderGuardAndLevitate(void);
 static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8, const u8* BS_ptr);
 static bool32 IsMonGettingExpSentOut(void);
@@ -269,41 +122,41 @@ static void atk01_accuracycheck(void);
 static void atk02_attackstring(void);
 static void atk03_ppreduce(void);
 static void atk04_critcalc(void);
-static void atk05_damagecalc1(void);
+static void atk05_damagecalc(void);
 static void atk06_typecalc(void);
-static void atk07_dmg_adjustment(void);
-static void atk08_dmg_adjustment2(void);
+static void atk07_adjustnormaldamage(void);
+static void atk08_adjustnormaldamage2(void);
 static void atk09_attackanimation(void);
 static void atk0A_waitanimation(void);
 static void atk0B_healthbarupdate(void);
 static void atk0C_datahpupdate(void);
 static void atk0D_critmessage(void);
-static void atk0E_effectiveness_sound(void);
+static void atk0E_effectivenesssound(void);
 static void atk0F_resultmessage(void);
 static void atk10_printstring(void);
-static void atk11_printstring_playeronly(void);
+static void atk11_printselectionstring(void);
 static void atk12_waitmessage(void);
 static void atk13_printfromtable(void);
-static void atk14_printfromtable_playeronly(void);
+static void atk14_printselectionstringfromtable(void);
 static void atk15_seteffectwithchance(void);
 static void atk16_seteffectprimary(void);
 static void atk17_seteffectsecondary(void);
-static void atk18_status_effect_clear(void);
-static void atk19_faint_pokemon(void);
-static void atk1A_faint_animation(void);
-static void atk1B_faint_effects_clear(void);
+static void atk18_clearstatusfromeffect(void);
+static void atk19_tryfaintmon(void);
+static void atk1A_dofaintanimation(void);
+static void atk1B_cleareffectsonfaint(void);
 static void atk1C_jumpifstatus(void);
 static void atk1D_jumpifstatus2(void);
 static void atk1E_jumpifability(void);
 static void atk1F_jumpifsideaffecting(void);
 static void atk20_jumpifstat(void);
-static void atk21_jumpifstatus3(void);
+static void atk21_jumpifstatus3condition(void);
 static void atk22_jumpiftype(void);
 static void atk23_getexp(void);
 static void atk24(void);
-static void atk25_move_values_cleanup(void);
-static void atk26_set_multihit(void);
-static void atk27_decrement_multihit(void);
+static void atk25_movevaluescleanup(void);
+static void atk26_setmultihit(void);
+static void atk27_decrementmultihit(void);
 static void atk28_goto(void);
 static void atk29_jumpifbyte(void);
 static void atk2A_jumpifhalfword(void);
@@ -314,7 +167,7 @@ static void atk2E_setbyte(void);
 static void atk2F_addbyte(void);
 static void atk30_subbyte(void);
 static void atk31_copyarray(void);
-static void atk32_copyarray_withindex(void);
+static void atk32_copyarraywithindex(void);
 static void atk33_orbyte(void);
 static void atk34_orhalfword(void);
 static void atk35_orword(void);
@@ -328,75 +181,75 @@ static void atk3C_return(void);
 static void atk3D_end(void);
 static void atk3E_end2(void);
 static void atk3F_end3(void);
-static void atk40_jump_if_move_affected_by_protect(void);
+static void atk40_jumpifaffectedbyprotect(void);
 static void atk41_call(void);
 static void atk42_jumpiftype2(void);
 static void atk43_jumpifabilitypresent(void);
-static void atk44_end_selection_script(void);
+static void atk44_endselectionscript(void);
 static void atk45_playanimation(void);
 static void atk46_playanimation2(void);
 static void atk47_setgraphicalstatchangevalues(void);
 static void atk48_playstatchangeanimation(void);
 static void atk49_moveend(void);
 static void atk4A_typecalc2(void);
-static void atk4B_return_atk_to_ball(void);
-static void atk4C_copy_poke_data(void);
-static void atk4D_switch_data_update(void);
-static void atk4E_switchin_anim(void);
-static void atk4F_jump_if_cannot_switch(void);
+static void atk4B_returnatktoball(void);
+static void atk4C_getswitchedmondata(void);
+static void atk4D_switchindataupdate(void);
+static void atk4E_switchinanim(void);
+static void atk4F_jumpifcantswitch(void);
 static void atk50_openpartyscreen(void);
-static void atk51_switch_handle_order(void);
-static void atk52_switch_in_effects(void);
-static void atk53_trainer_slide(void);
-static void atk54_effectiveness_sound(void);
-static void atk55_play_fanfare(void);
-static void atk56_fainting_cry(void);
+static void atk51_switchhandleorder(void);
+static void atk52_switchineffects(void);
+static void atk53_trainerslidein(void);
+static void atk54_playse(void);
+static void atk55_fanfare(void);
+static void atk56_playfaintcry(void);
 static void atk57(void);
-static void atk58_return_to_ball(void);
-static void atk59_learnmove_inbattle(void);
+static void atk58_returntoball(void);
+static void atk59_handlelearnnewmove(void);
 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 atk60_increment_gamestat(void);
-static void atk61_draw_party_status_summary(void);
-static void atk62_08025C6C(void);
+static void atk5E(void);
+static void atk5F(void);
+static void atk60_incrementgamestat(void);
+static void atk61_drawpartystatussummary(void);
+static void atk62(void);
 static void atk63_jumptorandomattack(void);
 static void atk64_statusanimation(void);
 static void atk65_status2animation(void);
 static void atk66_chosenstatusanimation(void);
 static void atk67_yesnobox(void);
-static void atk68_80246A0(void);
-static void atk69_dmg_adjustment3(void);
+static void atk68_cancelallactions(void);
+static void atk69_adjustsetdamage(void);
 static void atk6A_removeitem(void);
 static void atk6B_atknameinbuff1(void);
-static void atk6C_draw_lvlupbox(void);
-static void atk6D_reset_sentpokes_value(void);
-static void atk6E_set_atk_to_player0(void);
-static void atk6F_set_visible(void);
-static void atk70_record_last_used_ability(void);
-static void atk71_buffer_move_to_learn(void);
-static void atk72_jump_if_run_attempt_success(void);
-static void atk73_hp_thresholds(void);
-static void atk74_hp_thresholds2(void);
-static void atk75_item_effect_on_opponent(void);
+static void atk6C_drawlvlupbox(void);
+static void atk6D_resetsentmonsvalue(void);
+static void atk6E_setatktoplayer0(void);
+static void atk6F_makevisible(void);
+static void atk70_recordlastability(void);
+static void atk71_buffermovetolearn(void);
+static void atk72_jumpifplayerran(void);
+static void atk73_hpthresholds(void);
+static void atk74_hpthresholds2(void);
+static void atk75_useitemonopponent(void);
 static void atk76_various(void);
-static void atk77_set_protect_like(void);
+static void atk77_setprotectlike(void);
 static void atk78_faintifabilitynotdamp(void);
 static void atk79_setatkhptozero(void);
-static void atk7A_jumpwhiletargetvalid(void);
-static void atk7B_healhalfHP_if_possible(void);
+static void atk7A_jumpifnexttargetvalid(void);
+static void atk7B_tryhealhalfhealth(void);
 static void atk7C_trymirrormove(void);
-static void atk7D_set_rain(void);
+static void atk7D_setrain(void);
 static void atk7E_setreflect(void);
 static void atk7F_setseeded(void);
 static void atk80_manipulatedamage(void);
-static void atk81_setrest(void);
+static void atk81_trysetrest(void);
 static void atk82_jumpifnotfirstturn(void);
 static void atk83_nop(void);
-static void atk84_jump_if_cant_sleep(void);
+static void atk84_jumpifcantmakeasleep(void);
 static void atk85_stockpile(void);
 static void atk86_stockpiletobasedamage(void);
 static void atk87_stockpiletohpheal(void);
@@ -405,22 +258,22 @@ static void atk89_statbuffchange(void);
 static void atk8A_normalisebuffs(void);
 static void atk8B_setbide(void);
 static void atk8C_confuseifrepeatingattackends(void);
-static void atk8D_setmultihit_counter(void);
-static void atk8E_init_multihit_string(void);
+static void atk8D_setmultihitcounter(void);
+static void atk8E_initmultihitstring(void);
 static void atk8F_forcerandomswitch(void);
-static void atk90_conversion_type_change(void);
+static void atk90_tryconversiontypechange(void);
 static void atk91_givepaydaymoney(void);
 static void atk92_setlightscreen(void);
-static void atk93_ko_move(void);
+static void atk93_tryKO(void);
 static void atk94_damagetohalftargethp(void);
 static void atk95_setsandstorm(void);
 static void atk96_weatherdamage(void);
-static void atk97_try_infatuation(void);
-static void atk98_status_icon_update(void);
+static void atk97_tryinfatuating(void);
+static void atk98_updatestatusicon(void);
 static void atk99_setmist(void);
-static void atk9A_set_focusenergy(void);
+static void atk9A_setfocusenergy(void);
 static void atk9B_transformdataexecution(void);
-static void atk9C_set_substitute(void);
+static void atk9C_setsubstitute(void);
 static void atk9D_mimicattackcopy(void);
 static void atk9E_metronome(void);
 static void atk9F_dmgtolevel(void);
@@ -428,39 +281,39 @@ static void atkA0_psywavedamageeffect(void);
 static void atkA1_counterdamagecalculator(void);
 static void atkA2_mirrorcoatdamagecalculator(void);
 static void atkA3_disablelastusedattack(void);
-static void atkA4_setencore(void);
+static void atkA4_trysetencore(void);
 static void atkA5_painsplitdmgcalc(void);
 static void atkA6_settypetorandomresistance(void);
 static void atkA7_setalwayshitflag(void);
 static void atkA8_copymovepermanently(void);
-static void atkA9_sleeptalk_choose_move(void);
-static void atkAA_set_destinybond(void);
-static void atkAB_DestinyBondFlagUpdate(void);
+static void atkA9_trychoosesleeptalkmove(void);
+static void atkAA_setdestinybond(void);
+static void atkAB_trysetdestinybondtohappen(void);
 static void atkAC_remaininghptopower(void);
-static void atkAD_spite_ppreduce(void);
-static void atkAE_heal_party_status(void);
+static void atkAD_tryspiteppreduce(void);
+static void atkAE_healpartystatus(void);
 static void atkAF_cursetarget(void);
-static void atkB0_set_spikes(void);
-static void atkB1_set_foresight(void);
-static void atkB2_setperishsong(void);
+static void atkB0_trysetspikes(void);
+static void atkB1_setforesight(void);
+static void atkB2_trysetperishsong(void);
 static void atkB3_rolloutdamagecalculation(void);
 static void atkB4_jumpifconfusedandstatmaxed(void);
 static void atkB5_furycuttercalc(void);
 static void atkB6_happinesstodamagecalculation(void);
 static void atkB7_presentdamagecalculation(void);
-static void atkB8_set_safeguard(void);
+static void atkB8_setsafeguard(void);
 static void atkB9_magnitudedamagecalculation(void);
 static void atkBA_jumpifnopursuitswitchdmg(void);
 static void atkBB_setsunny(void);
 static void atkBC_maxattackhalvehp(void);
 static void atkBD_copyfoestats(void);
 static void atkBE_rapidspinfree(void);
-static void atkBF_set_defense_curl(void);
+static void atkBF_setdefensecurlbit(void);
 static void atkC0_recoverbasedonsunlight(void);
-static void atkC1_hidden_power(void);
-static void atkC2_selectnexttarget(void);
-static void atkC3_setfutureattack(void);
-static void atkC4_beat_up(void);
+static void atkC1_hiddenpowercalc(void);
+static void atkC2_selectfirstvalidtarget(void);
+static void atkC3_trysetfutureattack(void);
+static void atkC4_trydobeatup(void);
 static void atkC5_setsemiinvulnerablebit(void);
 static void atkC6_clearsemiinvulnerablebit(void);
 static void atkC7_setminimize(void);
@@ -473,46 +326,46 @@ static void atkCD_cureifburnedparalysedorpoisoned(void);
 static void atkCE_settorment(void);
 static void atkCF_jumpifnodamage(void);
 static void atkD0_settaunt(void);
-static void atkD1_set_helpinghand(void);
-static void atkD2_swap_items(void);
-static void atkD3_copy_ability(void);
-static void atkD4_wish_effect(void);
-static void atkD5_setroots(void);
+static void atkD1_trysethelpinghand(void);
+static void atkD2_tryswapitems(void);
+static void atkD3_trycopyability(void);
+static void atkD4_trywish(void);
+static void atkD5_trysetroots(void);
 static void atkD6_doubledamagedealtifdamaged(void);
 static void atkD7_setyawn(void);
 static void atkD8_setdamagetohealthdifference(void);
 static void atkD9_scaledamagebyhealthratio(void);
-static void atkDA_abilityswap(void);
-static void atkDB_imprisoneffect(void);
-static void atkDC_setgrudge(void);
+static void atkDA_tryswapabilities(void);
+static void atkDB_tryimprision(void);
+static void atkDC_trysetgrudge(void);
 static void atkDD_weightdamagecalculation(void);
 static void atkDE_asistattackselect(void);
-static void atkDF_setmagiccoat(void);
-static void atkE0_setstealstatchange(void);
-static void atkE1_intimidate_string_loader(void);
-static void atkE2_switchout_abilities(void);
+static void atkDF_trysetmagiccoat(void);
+static void atkE0_trysetsnatch(void);
+static void atkE1_trygetintimidatetarget(void);
+static void atkE2_switchoutabilities(void);
 static void atkE3_jumpifhasnohp(void);
 static void atkE4_getsecretpowereffect(void);
 static void atkE5_pickup(void);
-static void atkE6_castform_change_animation(void);
-static void atkE7_castform_data_change(void);
+static void atkE6_docastformchangeanimation(void);
+static void atkE7_trycastformdatachange(void);
 static void atkE8_settypebasedhalvers(void);
 static void atkE9_setweatherballtype(void);
-static void atkEA_recycleitem(void);
+static void atkEA_tryrecycleitem(void);
 static void atkEB_settypetoterrain(void);
-static void atkEC_pursuit_sth(void);
-static void atkED_802B4B4(void);
+static void atkEC_pursuitrelated(void);
+static void atkEF_snatchsetbanks(void);
 static void atkEE_removelightscreenreflect(void);
-static void atkEF_pokeball_catch_calculation(void);
-static void atkF0_give_caught_mon(void);
-static void atkF1_set_caught_mon_dex_flags(void);
-static void atkF2_display_dex_info(void);
-static void atkF3_nickname_caught_poke(void);
+static void atkEF_handleballthrow(void);
+static void atkF0_givecaughtmon(void);
+static void atkF1_trysetcaughtmondexflags(void);
+static void atkF2_displaydexinfo(void);
+static void atkF3_trygivecaughtmonnick(void);
 static void atkF4_subattackerhpbydmg(void);
 static void atkF5_removeattackerstatus1(void);
-static void atkF6_action_finished(void);
-static void atkF7_turn_finished(void);
-static void atkF8_trainer_slide_back(void);
+static void atkF6_finishaction(void);
+static void atkF7_finishturn(void);
+static void atkF8_trainerslideout(void);
 
 void (* const gBattleScriptingCommandsTable[])(void) =
 {
@@ -521,41 +374,41 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atk02_attackstring,
     atk03_ppreduce,
     atk04_critcalc,
-    atk05_damagecalc1,
+    atk05_damagecalc,
     atk06_typecalc,
-    atk07_dmg_adjustment,
-    atk08_dmg_adjustment2,
+    atk07_adjustnormaldamage,
+    atk08_adjustnormaldamage2,
     atk09_attackanimation,
     atk0A_waitanimation,
     atk0B_healthbarupdate,
     atk0C_datahpupdate,
     atk0D_critmessage,
-    atk0E_effectiveness_sound,
+    atk0E_effectivenesssound,
     atk0F_resultmessage,
     atk10_printstring,
-    atk11_printstring_playeronly,
+    atk11_printselectionstring,
     atk12_waitmessage,
     atk13_printfromtable,
-    atk14_printfromtable_playeronly,
+    atk14_printselectionstringfromtable,
     atk15_seteffectwithchance,
     atk16_seteffectprimary,
     atk17_seteffectsecondary,
-    atk18_status_effect_clear,
-    atk19_faint_pokemon,
-    atk1A_faint_animation,
-    atk1B_faint_effects_clear,
+    atk18_clearstatusfromeffect,
+    atk19_tryfaintmon,
+    atk1A_dofaintanimation,
+    atk1B_cleareffectsonfaint,
     atk1C_jumpifstatus,
     atk1D_jumpifstatus2,
     atk1E_jumpifability,
     atk1F_jumpifsideaffecting,
     atk20_jumpifstat,
-    atk21_jumpifstatus3,
+    atk21_jumpifstatus3condition,
     atk22_jumpiftype,
     atk23_getexp,
     atk24,
-    atk25_move_values_cleanup,
-    atk26_set_multihit,
-    atk27_decrement_multihit,
+    atk25_movevaluescleanup,
+    atk26_setmultihit,
+    atk27_decrementmultihit,
     atk28_goto,
     atk29_jumpifbyte,
     atk2A_jumpifhalfword,
@@ -566,7 +419,7 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atk2F_addbyte,
     atk30_subbyte,
     atk31_copyarray,
-    atk32_copyarray_withindex,
+    atk32_copyarraywithindex,
     atk33_orbyte,
     atk34_orhalfword,
     atk35_orword,
@@ -580,75 +433,75 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atk3D_end,
     atk3E_end2,
     atk3F_end3,
-    atk40_jump_if_move_affected_by_protect,
+    atk40_jumpifaffectedbyprotect,
     atk41_call,
     atk42_jumpiftype2,
     atk43_jumpifabilitypresent,
-    atk44_end_selection_script,
+    atk44_endselectionscript,
     atk45_playanimation,
     atk46_playanimation2,
     atk47_setgraphicalstatchangevalues,
     atk48_playstatchangeanimation,
     atk49_moveend,
     atk4A_typecalc2,
-    atk4B_return_atk_to_ball,
-    atk4C_copy_poke_data,
-    atk4D_switch_data_update,
-    atk4E_switchin_anim,
-    atk4F_jump_if_cannot_switch,
+    atk4B_returnatktoball,
+    atk4C_getswitchedmondata,
+    atk4D_switchindataupdate,
+    atk4E_switchinanim,
+    atk4F_jumpifcantswitch,
     atk50_openpartyscreen,
-    atk51_switch_handle_order,
-    atk52_switch_in_effects,
-    atk53_trainer_slide,
-    atk54_effectiveness_sound,
-    atk55_play_fanfare,
-    atk56_fainting_cry,
+    atk51_switchhandleorder,
+    atk52_switchineffects,
+    atk53_trainerslidein,
+    atk54_playse,
+    atk55_fanfare,
+    atk56_playfaintcry,
     atk57,
-    atk58_return_to_ball,
-    atk59_learnmove_inbattle,
+    atk58_returntoball,
+    atk59_handlelearnnewmove,
     atk5A_yesnoboxlearnmove,
     atk5B_yesnoboxstoplearningmove,
     atk5C_hitanimation,
     atk5D_getmoneyreward,
-    atk5E_8025A70,
-    atk5F_8025B24,
-    atk60_increment_gamestat,
-    atk61_draw_party_status_summary,
-    atk62_08025C6C,
+    atk5E,
+    atk5F,
+    atk60_incrementgamestat,
+    atk61_drawpartystatussummary,
+    atk62,
     atk63_jumptorandomattack,
     atk64_statusanimation,
     atk65_status2animation,
     atk66_chosenstatusanimation,
     atk67_yesnobox,
-    atk68_80246A0,
-    atk69_dmg_adjustment3,
+    atk68_cancelallactions,
+    atk69_adjustsetdamage,
     atk6A_removeitem,
     atk6B_atknameinbuff1,
-    atk6C_draw_lvlupbox,
-    atk6D_reset_sentpokes_value,
-    atk6E_set_atk_to_player0,
-    atk6F_set_visible,
-    atk70_record_last_used_ability,
-    atk71_buffer_move_to_learn,
-    atk72_jump_if_run_attempt_success,
-    atk73_hp_thresholds,
-    atk74_hp_thresholds2,
-    atk75_item_effect_on_opponent,
+    atk6C_drawlvlupbox,
+    atk6D_resetsentmonsvalue,
+    atk6E_setatktoplayer0,
+    atk6F_makevisible,
+    atk70_recordlastability,
+    atk71_buffermovetolearn,
+    atk72_jumpifplayerran,
+    atk73_hpthresholds,
+    atk74_hpthresholds2,
+    atk75_useitemonopponent,
     atk76_various,
-    atk77_set_protect_like,
+    atk77_setprotectlike,
     atk78_faintifabilitynotdamp,
     atk79_setatkhptozero,
-    atk7A_jumpwhiletargetvalid,
-    atk7B_healhalfHP_if_possible,
+    atk7A_jumpifnexttargetvalid,
+    atk7B_tryhealhalfhealth,
     atk7C_trymirrormove,
-    atk7D_set_rain,
+    atk7D_setrain,
     atk7E_setreflect,
     atk7F_setseeded,
     atk80_manipulatedamage,
-    atk81_setrest,
+    atk81_trysetrest,
     atk82_jumpifnotfirstturn,
     atk83_nop,
-    atk84_jump_if_cant_sleep,
+    atk84_jumpifcantmakeasleep,
     atk85_stockpile,
     atk86_stockpiletobasedamage,
     atk87_stockpiletohpheal,
@@ -657,22 +510,22 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atk8A_normalisebuffs,
     atk8B_setbide,
     atk8C_confuseifrepeatingattackends,
-    atk8D_setmultihit_counter,
-    atk8E_init_multihit_string,
+    atk8D_setmultihitcounter,
+    atk8E_initmultihitstring,
     atk8F_forcerandomswitch,
-    atk90_conversion_type_change,
+    atk90_tryconversiontypechange,
     atk91_givepaydaymoney,
     atk92_setlightscreen,
-    atk93_ko_move,
+    atk93_tryKO,
     atk94_damagetohalftargethp,
     atk95_setsandstorm,
     atk96_weatherdamage,
-    atk97_try_infatuation,
-    atk98_status_icon_update,
+    atk97_tryinfatuating,
+    atk98_updatestatusicon,
     atk99_setmist,
-    atk9A_set_focusenergy,
+    atk9A_setfocusenergy,
     atk9B_transformdataexecution,
-    atk9C_set_substitute,
+    atk9C_setsubstitute,
     atk9D_mimicattackcopy,
     atk9E_metronome,
     atk9F_dmgtolevel,
@@ -680,39 +533,39 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atkA1_counterdamagecalculator,
     atkA2_mirrorcoatdamagecalculator,
     atkA3_disablelastusedattack,
-    atkA4_setencore,
+    atkA4_trysetencore,
     atkA5_painsplitdmgcalc,
     atkA6_settypetorandomresistance,
     atkA7_setalwayshitflag,
     atkA8_copymovepermanently,
-    atkA9_sleeptalk_choose_move,
-    atkAA_set_destinybond,
-    atkAB_DestinyBondFlagUpdate,
+    atkA9_trychoosesleeptalkmove,
+    atkAA_setdestinybond,
+    atkAB_trysetdestinybondtohappen,
     atkAC_remaininghptopower,
-    atkAD_spite_ppreduce,
-    atkAE_heal_party_status,
+    atkAD_tryspiteppreduce,
+    atkAE_healpartystatus,
     atkAF_cursetarget,
-    atkB0_set_spikes,
-    atkB1_set_foresight,
-    atkB2_setperishsong,
+    atkB0_trysetspikes,
+    atkB1_setforesight,
+    atkB2_trysetperishsong,
     atkB3_rolloutdamagecalculation,
     atkB4_jumpifconfusedandstatmaxed,
     atkB5_furycuttercalc,
     atkB6_happinesstodamagecalculation,
     atkB7_presentdamagecalculation,
-    atkB8_set_safeguard,
+    atkB8_setsafeguard,
     atkB9_magnitudedamagecalculation,
     atkBA_jumpifnopursuitswitchdmg,
     atkBB_setsunny,
     atkBC_maxattackhalvehp,
     atkBD_copyfoestats,
     atkBE_rapidspinfree,
-    atkBF_set_defense_curl,
+    atkBF_setdefensecurlbit,
     atkC0_recoverbasedonsunlight,
-    atkC1_hidden_power,
-    atkC2_selectnexttarget,
-    atkC3_setfutureattack,
-    atkC4_beat_up,
+    atkC1_hiddenpowercalc,
+    atkC2_selectfirstvalidtarget,
+    atkC3_trysetfutureattack,
+    atkC4_trydobeatup,
     atkC5_setsemiinvulnerablebit,
     atkC6_clearsemiinvulnerablebit,
     atkC7_setminimize,
@@ -725,46 +578,46 @@ void (* const gBattleScriptingCommandsTable[])(void) =
     atkCE_settorment,
     atkCF_jumpifnodamage,
     atkD0_settaunt,
-    atkD1_set_helpinghand,
-    atkD2_swap_items,
-    atkD3_copy_ability,
-    atkD4_wish_effect,
-    atkD5_setroots,
+    atkD1_trysethelpinghand,
+    atkD2_tryswapitems,
+    atkD3_trycopyability,
+    atkD4_trywish,
+    atkD5_trysetroots,
     atkD6_doubledamagedealtifdamaged,
     atkD7_setyawn,
     atkD8_setdamagetohealthdifference,
     atkD9_scaledamagebyhealthratio,
-    atkDA_abilityswap,
-    atkDB_imprisoneffect,
-    atkDC_setgrudge,
+    atkDA_tryswapabilities,
+    atkDB_tryimprision,
+    atkDC_trysetgrudge,
     atkDD_weightdamagecalculation,
     atkDE_asistattackselect,
-    atkDF_setmagiccoat,
-    atkE0_setstealstatchange,
-    atkE1_intimidate_string_loader,
-    atkE2_switchout_abilities,
+    atkDF_trysetmagiccoat,
+    atkE0_trysetsnatch,
+    atkE1_trygetintimidatetarget,
+    atkE2_switchoutabilities,
     atkE3_jumpifhasnohp,
     atkE4_getsecretpowereffect,
     atkE5_pickup,
-    atkE6_castform_change_animation,
-    atkE7_castform_data_change,
+    atkE6_docastformchangeanimation,
+    atkE7_trycastformdatachange,
     atkE8_settypebasedhalvers,
     atkE9_setweatherballtype,
-    atkEA_recycleitem,
+    atkEA_tryrecycleitem,
     atkEB_settypetoterrain,
-    atkEC_pursuit_sth,
-    atkED_802B4B4,
+    atkEC_pursuitrelated,
+    atkEF_snatchsetbanks,
     atkEE_removelightscreenreflect,
-    atkEF_pokeball_catch_calculation,
-    atkF0_give_caught_mon,
-    atkF1_set_caught_mon_dex_flags,
-    atkF2_display_dex_info,
-    atkF3_nickname_caught_poke,
+    atkEF_handleballthrow,
+    atkF0_givecaughtmon,
+    atkF1_trysetcaughtmondexflags,
+    atkF2_displaydexinfo,
+    atkF3_trygivecaughtmonnick,
     atkF4_subattackerhpbydmg,
     atkF5_removeattackerstatus1,
-    atkF6_action_finished,
-    atkF7_turn_finished,
-    atkF8_trainer_slide_back
+    atkF6_finishaction,
+    atkF7_finishturn,
+    atkF8_trainerslideout
 };
 
 struct StatFractions
@@ -796,12 +649,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,
@@ -828,7 +681,7 @@ static const u32 sStatusFlagsForMoveEffects[] =
     0x00000000,
     0x00000000,
     STATUS2_ESCAPE_PREVENTION,
-    0x08000000,
+    STATUS2_NIGHTMARE,
     0x00000000,
     0x00000000,
     0x00000000,
@@ -1037,11 +890,11 @@ static const u16 sRarePickupItems[] =
 	ITEM_FULL_RESTORE,
 	ITEM_ETHER,
 	ITEM_WHITE_HERB,
-	ITEM_TM44,
+	ITEM_TM44_REST,
 	ITEM_ELIXIR,
-	ITEM_TM01,
+	ITEM_TM01_FOCUS_PUNCH,
 	ITEM_LEFTOVERS,
-	ITEM_TM26,
+	ITEM_TM26_EARTHQUAKE,
 };
 
 static const u8 sPickupProbabilities[] =
@@ -1068,22 +921,33 @@ static const u8 sBallCatchBonuses[] =
     20, 15, 10, 15 // Ultra, Great, Poke, Safari
 };
 
-// could be a 2d array or a struct
-const ALIGNED(4) u8 gUnknown_0831C494[] =
-{
-    0x3d, 0x44, 0x3d, 0x44, 0x14, 0x2d, 0x54, 0x5c,
-    0x46, 0x55, 0x20, 0x5c, 0x26, 0x45, 0x46, 0x55,
-    0x14, 0x5a, 0x46, 0x5c, 0x1e, 0x32, 0x20, 0x5a,
-    0x38, 0x4e, 0x38, 0x4e, 0x19, 0x28, 0x4b, 0x5a,
-    0x45, 0x4b, 0x1c, 0x53, 0x23, 0x2d, 0x1d, 0x23,
-    0x3e, 0x48, 0x1e, 0x32, 0x3a, 0x5f, 0x58, 0x5e,
-    0x22, 0x2d, 0x1d, 0x28, 0x23, 0x28, 0x23, 0x5f,
-    0x38, 0x4e, 0x38, 0x4e, 0x23, 0x50, 0x22, 0x5e,
-    0x2c, 0x5e, 0x22, 0x28, 0x38, 0x4e, 0x38, 0x4e,
-    0x1e, 0x58, 0x1e, 0x58, 0x1e, 0x2b, 0x1b, 0x21,
-    0x28, 0x5a, 0x19, 0x57, 0x12, 0x58, 0x5a, 0x5f,
-    0x58, 0x5e, 0x16, 0x2a, 0x2a, 0x5c, 0x2a, 0x2f,
-    0x38, 0x4e, 0x38, 0x4e
+const ALIGNED(4) u8 gUnknown_0831C494[][4] =
+{
+    {0x3d, 0x44, 0x3d, 0x44},
+    {0x14, 0x2d, 0x54, 0x5c},
+    {0x46, 0x55, 0x20, 0x5c},
+    {0x26, 0x45, 0x46, 0x55},
+    {0x14, 0x5a, 0x46, 0x5c},
+    {0x1e, 0x32, 0x20, 0x5a},
+    {0x38, 0x4e, 0x38, 0x4e},
+    {0x19, 0x28, 0x4b, 0x5a},
+    {0x45, 0x4b, 0x1c, 0x53},
+    {0x23, 0x2d, 0x1d, 0x23},
+    {0x3e, 0x48, 0x1e, 0x32},
+    {0x3a, 0x5f, 0x58, 0x5e},
+    {0x22, 0x2d, 0x1d, 0x28},
+    {0x23, 0x28, 0x23, 0x5f},
+    {0x38, 0x4e, 0x38, 0x4e},
+    {0x23, 0x50, 0x22, 0x5e},
+    {0x2c, 0x5e, 0x22, 0x28},
+    {0x38, 0x4e, 0x38, 0x4e},
+    {0x1e, 0x58, 0x1e, 0x58},
+    {0x1e, 0x2b, 0x1b, 0x21},
+    {0x28, 0x5a, 0x19, 0x57},
+    {0x12, 0x58, 0x5a, 0x5f},
+    {0x58, 0x5e, 0x16, 0x2a},
+    {0x2a, 0x5c, 0x2a, 0x2f},
+    {0x38, 0x4e, 0x38, 0x4e}
 };
 
 static const u8 sUnknown_0831C4F8[] =
@@ -1100,10 +964,10 @@ static void atk00_attackcanceler(void)
 
     if (gBattleOutcome != 0)
     {
-        gCurrentActionFuncId = ACTION_FINISHED;
+        gCurrentActionFuncId = B_ACTION_FINISHED;
         return;
     }
-    if (gBattleMons[gBankAttacker].hp == 0 && !(gHitMarker & HITMARKER_NO_ATTACKSTRING))
+    if (gBattleMons[gBattlerAttacker].hp == 0 && !(gHitMarker & HITMARKER_NO_ATTACKSTRING))
     {
         gHitMarker |= HITMARKER_UNABLE_TO_USE_MOVE;
         gBattlescriptCurrInstr = BattleScript_MoveEnd;
@@ -1111,21 +975,21 @@ static void atk00_attackcanceler(void)
     }
     if (AtkCanceller_UnableToUseMove())
         return;
-    if (AbilityBattleEffects(ABILITYEFFECT_MOVES_BLOCK, gBankTarget, 0, 0, 0))
+    if (AbilityBattleEffects(ABILITYEFFECT_MOVES_BLOCK, gBattlerTarget, 0, 0, 0))
         return;
-    if (!gBattleMons[gBankAttacker].pp[gCurrMovePos] && gCurrentMove != MOVE_STRUGGLE && !(gHitMarker & 0x800200)
-     && !(gBattleMons[gBankAttacker].status2 & STATUS2_MULTIPLETURNS))
+    if (!gBattleMons[gBattlerAttacker].pp[gCurrMovePos] && gCurrentMove != MOVE_STRUGGLE && !(gHitMarker & 0x800200)
+     && !(gBattleMons[gBattlerAttacker].status2 & STATUS2_MULTIPLETURNS))
     {
         gBattlescriptCurrInstr = BattleScript_NoPPForMove;
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         return;
     }
 
     gHitMarker &= ~(HITMARKER_x800000);
 
-    if (!(gHitMarker & HITMARKER_OBEYS) && !(gBattleMons[gBankAttacker].status2 & STATUS2_MULTIPLETURNS))
+    if (!(gHitMarker & HITMARKER_OBEYS) && !(gBattleMons[gBattlerAttacker].status2 & STATUS2_MULTIPLETURNS))
     {
-        i = IsPokeDisobedient(); // why use the 'i' variable...?
+        i = IsMonDisobedient(); // why use the 'i' variable...?
         switch (i)
         {
         case 0:
@@ -1134,51 +998,51 @@ static void atk00_attackcanceler(void)
             gHitMarker |= HITMARKER_OBEYS;
             return;
         default:
-            gBattleMoveFlags |= MOVESTATUS_MISSED;
+            gMoveResultFlags |= MOVE_RESULT_MISSED;
             return;
         }
     }
 
     gHitMarker |= HITMARKER_OBEYS;
 
-    if (gProtectStructs[gBankTarget].bounceMove && gBattleMoves[gCurrentMove].flags & FLAG_MAGICCOAT_AFFECTED)
+    if (gProtectStructs[gBattlerTarget].bounceMove && gBattleMoves[gCurrentMove].flags & FLAG_MAGICCOAT_AFFECTED)
     {
-        PressurePPLose(gBankAttacker, gBankTarget, MOVE_MAGIC_COAT);
-        gProtectStructs[gBankTarget].bounceMove = 0;
+        PressurePPLose(gBattlerAttacker, gBattlerTarget, MOVE_MAGIC_COAT);
+        gProtectStructs[gBattlerTarget].bounceMove = 0;
         BattleScriptPushCursor();
         gBattlescriptCurrInstr = BattleScript_MagicCoatBounce;
         return;
     }
 
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
-        if ((gProtectStructs[gBanksByTurnOrder[i]].stealMove) && gBattleMoves[gCurrentMove].flags & FLAG_SNATCH_AFFECTED)
+        if ((gProtectStructs[gBattleTurnOrder[i]].stealMove) && gBattleMoves[gCurrentMove].flags & FLAG_SNATCH_AFFECTED)
         {
-            PressurePPLose(gBankAttacker, gBanksByTurnOrder[i], MOVE_SNATCH);
-            gProtectStructs[gBanksByTurnOrder[i]].stealMove = 0;
-            gBattleScripting.bank = gBanksByTurnOrder[i];
+            PressurePPLose(gBattlerAttacker, gBattleTurnOrder[i], MOVE_SNATCH);
+            gProtectStructs[gBattleTurnOrder[i]].stealMove = 0;
+            gBattleScripting.battler = gBattleTurnOrder[i];
             BattleScriptPushCursor();
             gBattlescriptCurrInstr = BattleScript_SnatchedMove;
             return;
         }
     }
 
-    if (gSpecialStatuses[gBankTarget].lightningRodRedirected)
+    if (gSpecialStatuses[gBattlerTarget].lightningRodRedirected)
     {
-        gSpecialStatuses[gBankTarget].lightningRodRedirected = 0;
+        gSpecialStatuses[gBattlerTarget].lightningRodRedirected = 0;
         gLastUsedAbility = ABILITY_LIGHTNING_ROD;
         BattleScriptPushCursor();
         gBattlescriptCurrInstr = BattleScript_TookAttack;
-        RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+        RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
-    else if (TARGET_PROTECT_AFFECTED
-     && (gCurrentMove != MOVE_CURSE || (gBattleMons[gBankAttacker].type1 == TYPE_GHOST || gBattleMons[gBankAttacker].type2 == TYPE_GHOST))
-     && ((!IsTwoTurnsMove(gCurrentMove) || (gBattleMons[gBankAttacker].status2 & STATUS2_MULTIPLETURNS))))
+    else if (DEFENDER_IS_PROTECTED
+     && (gCurrentMove != MOVE_CURSE || (gBattleMons[gBattlerAttacker].type1 == TYPE_GHOST || gBattleMons[gBattlerAttacker].type2 == TYPE_GHOST))
+     && ((!IsTwoTurnsMove(gCurrentMove) || (gBattleMons[gBattlerAttacker].status2 & STATUS2_MULTIPLETURNS))))
     {
-        CancelMultiTurnMoves(gBankAttacker);
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
-        gUnknown_02024250[gBankTarget] = 0;
-        gUnknown_02024258[gBankTarget] = 0;
+        CancelMultiTurnMoves(gBattlerAttacker);
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
+        gLastLandedMoves[gBattlerTarget] = 0;
+        gLastHitByType[gBattlerTarget] = 0;
         gBattleCommunication[6] = 1;
         gBattlescriptCurrInstr++;
     }
@@ -1190,27 +1054,27 @@ static void atk00_attackcanceler(void)
 
 static void JumpIfMoveFailed(u8 adder, u16 move)
 {
-    const void* BS_ptr = gBattlescriptCurrInstr + adder;
-    if (gBattleMoveFlags & MOVESTATUS_NOEFFECT)
+    const u8 *BS_ptr = gBattlescriptCurrInstr + adder;
+    if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT)
     {
-        gUnknown_02024250[gBankTarget] = 0;
-        gUnknown_02024258[gBankTarget] = 0;
+        gLastLandedMoves[gBattlerTarget] = 0;
+        gLastHitByType[gBattlerTarget] = 0;
         BS_ptr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        DestinyBondFlagUpdate();
-        if (AbilityBattleEffects(ABILITYEFFECT_ABSORBING, gBankTarget, 0, 0, move))
+        TrySetDestinyBondToHappen();
+        if (AbilityBattleEffects(ABILITYEFFECT_ABSORBING, gBattlerTarget, 0, 0, move))
             return;
     }
     gBattlescriptCurrInstr = BS_ptr;
 }
 
-static void atk40_jump_if_move_affected_by_protect(void)
+static void atk40_jumpifaffectedbyprotect(void)
 {
-    if (TARGET_PROTECT_AFFECTED)
+    if (DEFENDER_IS_PROTECTED)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         JumpIfMoveFailed(5, 0);
         gBattleCommunication[6] = 1;
     }
@@ -1223,9 +1087,9 @@ static void atk40_jump_if_move_affected_by_protect(void)
 bool8 JumpIfMoveAffectedByProtect(u16 move)
 {
     bool8 affected = FALSE;
-    if (TARGET_PROTECT_AFFECTED)
+    if (DEFENDER_IS_PROTECTED)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         JumpIfMoveFailed(7, move);
         gBattleCommunication[6] = 1;
         affected = TRUE;
@@ -1233,35 +1097,35 @@ bool8 JumpIfMoveAffectedByProtect(u16 move)
     return affected;
 }
 
-bool8 AccuracyCalcHelper(u16 move)
+static bool8 AccuracyCalcHelper(u16 move)
 {
-    if (gStatuses3[gBankTarget] & STATUS3_ALWAYS_HITS && gDisableStructs[gBankTarget].bankWithSureHit == gBankAttacker)
+    if (gStatuses3[gBattlerTarget] & STATUS3_ALWAYS_HITS && gDisableStructs[gBattlerTarget].battlerWithSureHit == gBattlerAttacker)
     {
         JumpIfMoveFailed(7, move);
         return TRUE;
     }
 
-    if (!(gHitMarker & HITMARKER_IGNORE_ON_AIR) && gStatuses3[gBankTarget] & STATUS3_ON_AIR)
+    if (!(gHitMarker & HITMARKER_IGNORE_ON_AIR) && gStatuses3[gBattlerTarget] & STATUS3_ON_AIR)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         JumpIfMoveFailed(7, move);
         return TRUE;
     }
 
     gHitMarker &= ~HITMARKER_IGNORE_ON_AIR;
 
-    if (!(gHitMarker & HITMARKER_IGNORE_UNDERGROUND) && gStatuses3[gBankTarget] & STATUS3_UNDERGROUND)
+    if (!(gHitMarker & HITMARKER_IGNORE_UNDERGROUND) && gStatuses3[gBattlerTarget] & STATUS3_UNDERGROUND)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         JumpIfMoveFailed(7, move);
         return TRUE;
     }
 
     gHitMarker &= ~HITMARKER_IGNORE_UNDERGROUND;
 
-    if (!(gHitMarker & HITMARKER_IGNORE_UNDERWATER) && gStatuses3[gBankTarget] & STATUS3_UNDERWATER)
+    if (!(gHitMarker & HITMARKER_IGNORE_UNDERWATER) && gStatuses3[gBattlerTarget] & STATUS3_UNDERWATER)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         JumpIfMoveFailed(7, move);
         return TRUE;
     }
@@ -1284,16 +1148,16 @@ static void atk01_accuracycheck(void)
 
     if (move == 0xFFFE || move == 0xFFFF)
     {
-        if (gStatuses3[gBankTarget] & STATUS3_ALWAYS_HITS && move == 0xFFFF && gDisableStructs[gBankTarget].bankWithSureHit == gBankAttacker)
+        if (gStatuses3[gBattlerTarget] & STATUS3_ALWAYS_HITS && move == 0xFFFF && gDisableStructs[gBattlerTarget].battlerWithSureHit == gBattlerAttacker)
             gBattlescriptCurrInstr += 7;
-        else if (gStatuses3[gBankTarget] & (STATUS3_ON_AIR | STATUS3_UNDERGROUND | STATUS3_UNDERWATER))
+        else if (gStatuses3[gBattlerTarget] & (STATUS3_ON_AIR | STATUS3_UNDERGROUND | STATUS3_UNDERWATER))
             gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
         else if (!JumpIfMoveAffectedByProtect(0))
             gBattlescriptCurrInstr += 7;
     }
     else
     {
-        u8 type, moveAcc, holdEffect, quality;
+        u8 type, moveAcc, holdEffect, param;
         s8 buff;
         u16 calc;
 
@@ -1307,15 +1171,15 @@ static void atk01_accuracycheck(void)
         if (AccuracyCalcHelper(move))
             return;
 
-        if (gBattleMons[gBankTarget].status2 & STATUS2_FORESIGHT)
+        if (gBattleMons[gBattlerTarget].status2 & STATUS2_FORESIGHT)
         {
-            u8 acc = gBattleMons[gBankAttacker].statStages[STAT_STAGE_ACC];
+            u8 acc = gBattleMons[gBattlerAttacker].statStages[STAT_ACC];
             buff = acc;
         }
         else
         {
-            u8 acc = gBattleMons[gBankAttacker].statStages[STAT_STAGE_ACC];
-            buff = acc + 6 - gBattleMons[gBankTarget].statStages[STAT_STAGE_EVASION];
+            u8 acc = gBattleMons[gBattlerAttacker].statStages[STAT_ACC];
+            buff = acc + 6 - gBattleMons[gBattlerTarget].statStages[STAT_EVASION];
         }
 
         if (buff < 0)
@@ -1331,33 +1195,33 @@ static void atk01_accuracycheck(void)
         calc = sAccuracyStageRatios[buff].dividend * moveAcc;
         calc /= sAccuracyStageRatios[buff].divisor;
 
-        if (gBattleMons[gBankAttacker].ability == ABILITY_COMPOUND_EYES)
+        if (gBattleMons[gBattlerAttacker].ability == ABILITY_COMPOUND_EYES)
             calc = (calc * 130) / 100; // 1.3 compound eyes boost
-        if (WEATHER_HAS_EFFECT && gBattleMons[gBankTarget].ability == ABILITY_SAND_VEIL && gBattleWeather & WEATHER_SANDSTORM_ANY)
+        if (WEATHER_HAS_EFFECT && gBattleMons[gBattlerTarget].ability == ABILITY_SAND_VEIL && gBattleWeather & WEATHER_SANDSTORM_ANY)
             calc = (calc * 80) / 100; // 1.2 sand veil loss
-        if (gBattleMons[gBankAttacker].ability == ABILITY_HUSTLE && type < 9)
+        if (gBattleMons[gBattlerAttacker].ability == ABILITY_HUSTLE && type < 9)
             calc = (calc * 80) / 100; // 1.2 hustle loss
 
-        if (gBattleMons[gBankTarget].item == ITEM_ENIGMA_BERRY)
+        if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
         {
-            holdEffect = gEnigmaBerries[gBankTarget].holdEffect;
-            quality = gEnigmaBerries[gBankTarget].holdEffectParam;
+            holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect;
+            param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
         }
         else
         {
-            holdEffect = ItemId_GetHoldEffect(gBattleMons[gBankTarget].item);
-            quality = ItemId_GetHoldEffectParam(gBattleMons[gBankTarget].item);
+            holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+            param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
         }
 
-        gStringBank = gBankTarget;
+        gPotentialItemEffectBattler = gBattlerTarget;
 
         if (holdEffect == HOLD_EFFECT_EVASION_UP)
-            calc = (calc * (100 - quality)) / 100;
+            calc = (calc * (100 - param)) / 100;
 
         // final calculation
         if ((Random() % 100 + 1) > calc)
         {
-            gBattleMoveFlags |= MOVESTATUS_MISSED;
+            gMoveResultFlags |= MOVE_RESULT_MISSED;
             if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE &&
                 (gBattleMoves[move].target == MOVE_TARGET_BOTH || gBattleMoves[move].target == MOVE_TARGET_FOES_AND_ALLY))
                 gBattleCommunication[6] = 2;
@@ -1372,11 +1236,11 @@ static void atk01_accuracycheck(void)
 
 static void atk02_attackstring(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
          return;
     if (!(gHitMarker & (HITMARKER_NO_ATTACKSTRING | HITMARKER_ATTACKSTRING_PRINTED)))
     {
-        PrepareStringBattle(STRINGID_USEDMOVE, gBankAttacker);
+        PrepareStringBattle(STRINGID_USEDMOVE, gBattlerAttacker);
         gHitMarker |= HITMARKER_ATTACKSTRING_PRINTED;
     }
     gBattlescriptCurrInstr++;
@@ -1387,42 +1251,42 @@ static void atk03_ppreduce(void)
 {
     s32 ppToDeduct = 1;
 
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    if (!gSpecialStatuses[gBankAttacker].flag20)
+    if (!gSpecialStatuses[gBattlerAttacker].flag20)
     {
         switch (gBattleMoves[gCurrentMove].target)
         {
         case MOVE_TARGET_FOES_AND_ALLY:
-            ppToDeduct += AbilityBattleEffects(ABILITYEFFECT_COUNT_ON_FIELD, gBankAttacker, ABILITY_PRESSURE, 0, 0);
+            ppToDeduct += AbilityBattleEffects(ABILITYEFFECT_COUNT_ON_FIELD, gBattlerAttacker, ABILITY_PRESSURE, 0, 0);
             break;
         case MOVE_TARGET_BOTH:
         case MOVE_TARGET_OPPONENTS_FIELD:
-            ppToDeduct += AbilityBattleEffects(ABILITYEFFECT_COUNT_OTHER_SIDE, gBankAttacker, ABILITY_PRESSURE, 0, 0);
+            ppToDeduct += AbilityBattleEffects(ABILITYEFFECT_COUNT_OTHER_SIDE, gBattlerAttacker, ABILITY_PRESSURE, 0, 0);
             break;
         default:
-            if (gBankAttacker != gBankTarget && gBattleMons[gBankTarget].ability == ABILITY_PRESSURE)
+            if (gBattlerAttacker != gBattlerTarget && gBattleMons[gBattlerTarget].ability == ABILITY_PRESSURE)
                 ppToDeduct++;
             break;
         }
     }
 
-    if (!(gHitMarker & (HITMARKER_NO_PPDEDUCT | HITMARKER_NO_ATTACKSTRING)) && gBattleMons[gBankAttacker].pp[gCurrMovePos])
+    if (!(gHitMarker & (HITMARKER_NO_PPDEDUCT | HITMARKER_NO_ATTACKSTRING)) && gBattleMons[gBattlerAttacker].pp[gCurrMovePos])
     {
-        gProtectStructs[gBankAttacker].notFirstStrike = 1;
+        gProtectStructs[gBattlerAttacker].notFirstStrike = 1;
 
-        if (gBattleMons[gBankAttacker].pp[gCurrMovePos] > ppToDeduct)
-            gBattleMons[gBankAttacker].pp[gCurrMovePos] -= ppToDeduct;
+        if (gBattleMons[gBattlerAttacker].pp[gCurrMovePos] > ppToDeduct)
+            gBattleMons[gBattlerAttacker].pp[gCurrMovePos] -= ppToDeduct;
         else
-            gBattleMons[gBankAttacker].pp[gCurrMovePos] = 0;
+            gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = 0;
 
-        if (!(gBattleMons[gBankAttacker].status2 & STATUS2_TRANSFORMED)
-            && !((gDisableStructs[gBankAttacker].unk18_b) & gBitTable[gCurrMovePos]))
+        if (!(gBattleMons[gBattlerAttacker].status2 & STATUS2_TRANSFORMED)
+            && !((gDisableStructs[gBattlerAttacker].unk18_b) & gBitTable[gCurrMovePos]))
         {
-            gActiveBank = gBankAttacker;
-            EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + gCurrMovePos, 0, 1, &gBattleMons[gBankAttacker].pp[gCurrMovePos]);
-            MarkBufferBankForExecution(gBankAttacker);
+            gActiveBattler = gBattlerAttacker;
+            BtlController_EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + gCurrMovePos, 0, 1, &gBattleMons[gBattlerAttacker].pp[gCurrMovePos]);
+            MarkBattlerForControllerExec(gBattlerAttacker);
         }
     }
 
@@ -1435,29 +1299,29 @@ static void atk04_critcalc(void)
     u8 holdEffect;
     u16 item, critChance;
 
-    item = gBattleMons[gBankAttacker].item;
+    item = gBattleMons[gBattlerAttacker].item;
 
     if (item == ITEM_ENIGMA_BERRY)
-        holdEffect = gEnigmaBerries[gBankAttacker].holdEffect;
+        holdEffect = gEnigmaBerries[gBattlerAttacker].holdEffect;
     else
         holdEffect = ItemId_GetHoldEffect(item);
 
-    gStringBank = gBankAttacker;
+    gPotentialItemEffectBattler = gBattlerAttacker;
 
-    critChance  = 2 * ((gBattleMons[gBankAttacker].status2 & STATUS2_FOCUS_ENERGY) != 0)
+    critChance  = 2 * ((gBattleMons[gBattlerAttacker].status2 & STATUS2_FOCUS_ENERGY) != 0)
                 + (gBattleMoves[gCurrentMove].effect == EFFECT_HIGH_CRITICAL)
                 + (gBattleMoves[gCurrentMove].effect == EFFECT_SKY_ATTACK)
                 + (gBattleMoves[gCurrentMove].effect == EFFECT_BLAZE_KICK)
                 + (gBattleMoves[gCurrentMove].effect == EFFECT_POISON_TAIL)
                 + (holdEffect == HOLD_EFFECT_SCOPE_LENS)
-                + 2 * (holdEffect == HOLD_EFFECT_LUCKY_PUNCH && gBattleMons[gBankAttacker].species == SPECIES_CHANSEY)
-                + 2 * (holdEffect == HOLD_EFFECT_STICK && gBattleMons[gBankAttacker].species == SPECIES_FARFETCHD);
+                + 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 ((gBattleMons[gBankTarget].ability != ABILITY_BATTLE_ARMOR && gBattleMons[gBankTarget].ability != ABILITY_SHELL_ARMOR)
-     && !(gStatuses3[gBankAttacker] & STATUS3_CANT_SCORE_A_CRIT)
+    if ((gBattleMons[gBattlerTarget].ability != ABILITY_BATTLE_ARMOR && gBattleMons[gBattlerTarget].ability != ABILITY_SHELL_ARMOR)
+     && !(gStatuses3[gBattlerAttacker] & STATUS3_CANT_SCORE_A_CRIT)
      && !(gBattleTypeFlags & (BATTLE_TYPE_WALLY_TUTORIAL | BATTLE_TYPE_FIRST_BATTLE))
      && !(Random() % sCriticalHitChance[critChance]))
         gCritMultiplier = 2;
@@ -1467,34 +1331,34 @@ static void atk04_critcalc(void)
     gBattlescriptCurrInstr++;
 }
 
-static void atk05_damagecalc1(void)
+static void atk05_damagecalc(void)
 {
-    u16 sideStatus = gSideAffecting[GET_BANK_SIDE(gBankTarget)];
-    gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[gBankAttacker], &gBattleMons[gBankTarget], gCurrentMove,
+    u16 sideStatus = gSideStatuses[GET_BATTLER_SIDE(gBattlerTarget)];
+    gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[gBattlerAttacker], &gBattleMons[gBattlerTarget], gCurrentMove,
                                             sideStatus, gDynamicBasePower,
-                                            gBattleStruct->dynamicMoveType, gBankAttacker, gBankTarget);
+                                            gBattleStruct->dynamicMoveType, gBattlerAttacker, gBattlerTarget);
     gBattleMoveDamage = gBattleMoveDamage * gCritMultiplier * gBattleScripting.dmgMultiplier;
 
-    if (gStatuses3[gBankAttacker] & STATUS3_CHARGED_UP && gBattleMoves[gCurrentMove].type == TYPE_ELECTRIC)
+    if (gStatuses3[gBattlerAttacker] & STATUS3_CHARGED_UP && gBattleMoves[gCurrentMove].type == TYPE_ELECTRIC)
         gBattleMoveDamage *= 2;
-    if (gProtectStructs[gBankAttacker].helpingHand)
+    if (gProtectStructs[gBattlerAttacker].helpingHand)
         gBattleMoveDamage = gBattleMoveDamage * 15 / 10;
 
     gBattlescriptCurrInstr++;
 }
 
-void AI_CalcDmg(u8 bankAtk, u8 bankDef)
+void AI_CalcDmg(u8 attacker, u8 defender)
 {
-    u16 sideStatus = gSideAffecting[GET_BANK_SIDE(bankDef)];
-    gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[bankAtk], &gBattleMons[bankDef], gCurrentMove,
+    u16 sideStatus = gSideStatuses[GET_BATTLER_SIDE(defender)];
+    gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[attacker], &gBattleMons[defender], gCurrentMove,
                                             sideStatus, gDynamicBasePower,
-                                            gBattleStruct->dynamicMoveType, bankAtk, bankDef);
+                                            gBattleStruct->dynamicMoveType, attacker, defender);
     gDynamicBasePower = 0;
     gBattleMoveDamage = gBattleMoveDamage * gCritMultiplier * gBattleScripting.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;
 }
 
@@ -1507,34 +1371,31 @@ static void ModulateDmgByType(u8 multiplier)
     switch (multiplier)
     {
     case TYPE_MUL_NO_EFFECT:
-        gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
-        gBattleMoveFlags &= ~MOVESTATUS_NOTVERYEFFECTIVE;
-        gBattleMoveFlags &= ~MOVESTATUS_SUPEREFFECTIVE;
+        gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
+        gMoveResultFlags &= ~MOVE_RESULT_NOT_VERY_EFFECTIVE;
+        gMoveResultFlags &= ~MOVE_RESULT_SUPER_EFFECTIVE;
         break;
     case TYPE_MUL_NOT_EFFECTIVE:
-        if (gBattleMoves[gCurrentMove].power && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+        if (gBattleMoves[gCurrentMove].power && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
         {
-            if (gBattleMoveFlags & MOVESTATUS_SUPEREFFECTIVE)
-                gBattleMoveFlags &= ~MOVESTATUS_SUPEREFFECTIVE;
+            if (gMoveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE)
+                gMoveResultFlags &= ~MOVE_RESULT_SUPER_EFFECTIVE;
             else
-                gBattleMoveFlags |= MOVESTATUS_NOTVERYEFFECTIVE;
+                gMoveResultFlags |= MOVE_RESULT_NOT_VERY_EFFECTIVE;
         }
         break;
     case TYPE_MUL_SUPER_EFFECTIVE:
-        if (gBattleMoves[gCurrentMove].power && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+        if (gBattleMoves[gCurrentMove].power && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
         {
-            if (gBattleMoveFlags & MOVESTATUS_NOTVERYEFFECTIVE)
-                gBattleMoveFlags &= ~MOVESTATUS_NOTVERYEFFECTIVE;
+            if (gMoveResultFlags & MOVE_RESULT_NOT_VERY_EFFECTIVE)
+                gMoveResultFlags &= ~MOVE_RESULT_NOT_VERY_EFFECTIVE;
             else
-                gBattleMoveFlags |= MOVESTATUS_SUPEREFFECTIVE;
+                gMoveResultFlags |= MOVE_RESULT_SUPER_EFFECTIVE;
         }
         break;
     }
 }
 
-#define TYPE_FORESIGHT  0xFE
-#define TYPE_ENDTABLE   0xFF
-
 static void atk06_typecalc(void)
 {
     s32 i = 0;
@@ -1549,59 +1410,59 @@ static void atk06_typecalc(void)
     GET_MOVE_TYPE(gCurrentMove, moveType);
 
     // check stab
-    if (gBattleMons[gBankAttacker].type1 == moveType || gBattleMons[gBankAttacker].type2 == moveType)
+    if (gBattleMons[gBattlerAttacker].type1 == moveType || gBattleMons[gBattlerAttacker].type2 == moveType)
     {
         gBattleMoveDamage = gBattleMoveDamage * 15;
         gBattleMoveDamage = gBattleMoveDamage / 10;
     }
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
-        gLastUsedAbility = gBattleMons[gBankTarget].ability;
-        gBattleMoveFlags |= (MOVESTATUS_MISSED | MOVESTATUS_NOTAFFECTED);
-        gUnknown_02024250[gBankTarget] = 0;
-        gUnknown_02024258[gBankTarget] = 0;
+        gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
+        gMoveResultFlags |= (MOVE_RESULT_MISSED | MOVE_RESULT_DOESNT_AFFECT_FOE);
+        gLastLandedMoves[gBattlerTarget] = 0;
+        gLastHitByType[gBattlerTarget] = 0;
         gBattleCommunication[6] = moveType;
-        RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+        RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
     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)
             {
-                if (gBattleMons[gBankTarget].status2 & STATUS2_FORESIGHT)
+                if (gBattleMons[gBattlerTarget].status2 & STATUS2_FORESIGHT)
                     break;
                 i += 3;
                 continue;
             }
-            else if (gTypeEffectiveness[i] == moveType)
+            else if (TYPE_EFFECT_ATK_TYPE(i) == moveType)
             {
                 // check type1
-                if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type1)
-                    ModulateDmgByType(gTypeEffectiveness[i + 2]);
+                if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type1)
+                    ModulateDmgByType(TYPE_EFFECT_MULTIPLIER(i));
                 // check type2
-                if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2 &&
-                    gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2)
-                    ModulateDmgByType(gTypeEffectiveness[i + 2]);
+                if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type2 &&
+                    gBattleMons[gBattlerTarget].type1 != gBattleMons[gBattlerTarget].type2)
+                    ModulateDmgByType(TYPE_EFFECT_MULTIPLIER(i));
             }
             i += 3;
         }
     }
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_WONDER_GUARD && AttacksThisTurn(gBankAttacker, gCurrentMove) == 2
-     && (!(gBattleMoveFlags & MOVESTATUS_SUPEREFFECTIVE) || ((gBattleMoveFlags & (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)) == (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)))
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_WONDER_GUARD && AttacksThisTurn(gBattlerAttacker, gCurrentMove) == 2
+     && (!(gMoveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE) || ((gMoveResultFlags & (MOVE_RESULT_SUPER_EFFECTIVE | MOVE_RESULT_NOT_VERY_EFFECTIVE)) == (MOVE_RESULT_SUPER_EFFECTIVE | MOVE_RESULT_NOT_VERY_EFFECTIVE)))
      && gBattleMoves[gCurrentMove].power)
     {
         gLastUsedAbility = ABILITY_WONDER_GUARD;
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
-        gUnknown_02024250[gBankTarget] = 0;
-        gUnknown_02024258[gBankTarget] = 0;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
+        gLastLandedMoves[gBattlerTarget] = 0;
+        gLastHitByType[gBattlerTarget] = 0;
         gBattleCommunication[6] = 3;
-        RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+        RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
-    if (gBattleMoveFlags & MOVESTATUS_NOTAFFECTED)
-        gProtectStructs[gBankAttacker].targetNotAffected = 1;
+    if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
+        gProtectStructs[gBattlerAttacker].targetNotAffected = 1;
 
     gBattlescriptCurrInstr++;
 }
@@ -1617,65 +1478,66 @@ static void CheckWonderGuardAndLevitate(void)
 
     GET_MOVE_TYPE(gCurrentMove, moveType);
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
         gLastUsedAbility = ABILITY_LEVITATE;
         gBattleCommunication[6] = moveType;
-        RecordAbilityBattle(gBankTarget, ABILITY_LEVITATE);
+        RecordAbilityBattle(gBattlerTarget, ABILITY_LEVITATE);
         return;
     }
 
-    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)
         {
-            if (gBattleMons[gBankTarget].status2 & STATUS2_FORESIGHT)
+            if (gBattleMons[gBattlerTarget].status2 & STATUS2_FORESIGHT)
                 break;
             i += 3;
             continue;
         }
-        if (gTypeEffectiveness[i] == moveType)
+        if (TYPE_EFFECT_ATK_TYPE(i) == moveType)
         {
             // check no effect
-            if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type1 && gTypeEffectiveness[i + 2] == 0)
+            if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type1
+                && TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_NO_EFFECT)
             {
-                gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
-                gProtectStructs[gBankAttacker].targetNotAffected = 1;
+                gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
+                gProtectStructs[gBattlerAttacker].targetNotAffected = 1;
             }
-            if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2 &&
-                gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2 &&
-                gTypeEffectiveness[i + 2] == TYPE_MUL_NO_EFFECT)
+            if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type2 &&
+                gBattleMons[gBattlerTarget].type1 != gBattleMons[gBattlerTarget].type2 &&
+                TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_NO_EFFECT)
             {
-                gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
-                gProtectStructs[gBankAttacker].targetNotAffected = 1;
+                gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
+                gProtectStructs[gBattlerAttacker].targetNotAffected = 1;
             }
 
             // check super effective
-            if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type1 && gTypeEffectiveness[i + 2] == 20)
+            if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type1 && TYPE_EFFECT_MULTIPLIER(i) == 20)
                 flags |= 1;
-            if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2
-             && gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2
-             && gTypeEffectiveness[i + 2] == TYPE_MUL_SUPER_EFFECTIVE)
+            if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type2
+             && gBattleMons[gBattlerTarget].type1 != gBattleMons[gBattlerTarget].type2
+             && TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_SUPER_EFFECTIVE)
                 flags |= 1;
 
             // check not very effective
-            if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type1 && gTypeEffectiveness[i + 2] == 5)
+            if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type1 && TYPE_EFFECT_MULTIPLIER(i) == 5)
                 flags |= 2;
-            if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2
-             && gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2
-             && gTypeEffectiveness[i + 2] == TYPE_MUL_NOT_EFFECTIVE)
+            if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type2
+             && gBattleMons[gBattlerTarget].type1 != gBattleMons[gBattlerTarget].type2
+             && TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_NOT_EFFECTIVE)
                 flags |= 2;
         }
         i += 3;
     }
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_WONDER_GUARD && AttacksThisTurn(gBankAttacker, gCurrentMove) == 2)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_WONDER_GUARD && AttacksThisTurn(gBattlerAttacker, gCurrentMove) == 2)
     {
         if (((flags & 2) || !(flags & 1)) && gBattleMoves[gCurrentMove].power)
         {
             gLastUsedAbility = ABILITY_WONDER_GUARD;
             gBattleCommunication[6] = 3;
-            RecordAbilityBattle(gBankTarget, ABILITY_WONDER_GUARD);
+            RecordAbilityBattle(gBattlerTarget, ABILITY_WONDER_GUARD);
         }
     }
 }
@@ -1689,32 +1551,32 @@ static void ModulateDmgByType2(u8 multiplier, u16 move, u8* flags) // same as Mo
     switch (multiplier)
     {
     case TYPE_MUL_NO_EFFECT:
-        *flags |= MOVESTATUS_NOTAFFECTED;
-        *flags &= ~MOVESTATUS_NOTVERYEFFECTIVE;
-        *flags &= ~MOVESTATUS_SUPEREFFECTIVE;
+        *flags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
+        *flags &= ~MOVE_RESULT_NOT_VERY_EFFECTIVE;
+        *flags &= ~MOVE_RESULT_SUPER_EFFECTIVE;
         break;
     case TYPE_MUL_NOT_EFFECTIVE:
-        if (gBattleMoves[move].power && !(*flags & MOVESTATUS_NOEFFECT))
+        if (gBattleMoves[move].power && !(*flags & MOVE_RESULT_NO_EFFECT))
         {
-            if (*flags & MOVESTATUS_SUPEREFFECTIVE)
-                *flags &= ~MOVESTATUS_SUPEREFFECTIVE;
+            if (*flags & MOVE_RESULT_SUPER_EFFECTIVE)
+                *flags &= ~MOVE_RESULT_SUPER_EFFECTIVE;
             else
-                *flags |= MOVESTATUS_NOTVERYEFFECTIVE;
+                *flags |= MOVE_RESULT_NOT_VERY_EFFECTIVE;
         }
         break;
     case TYPE_MUL_SUPER_EFFECTIVE:
-        if (gBattleMoves[move].power && !(*flags & MOVESTATUS_NOEFFECT))
+        if (gBattleMoves[move].power && !(*flags & MOVE_RESULT_NO_EFFECT))
         {
-            if (*flags & MOVESTATUS_NOTVERYEFFECTIVE)
-                *flags &= ~MOVESTATUS_NOTVERYEFFECTIVE;
+            if (*flags & MOVE_RESULT_NOT_VERY_EFFECTIVE)
+                *flags &= ~MOVE_RESULT_NOT_VERY_EFFECTIVE;
             else
-                *flags |= MOVESTATUS_SUPEREFFECTIVE;
+                *flags |= MOVE_RESULT_SUPER_EFFECTIVE;
         }
         break;
     }
 }
 
-u8 TypeCalc(u16 move, u8 bankAtk, u8 bankDef)
+u8 TypeCalc(u16 move, u8 attacker, u8 defender)
 {
     s32 i = 0;
     u8 flags = 0;
@@ -1726,48 +1588,48 @@ u8 TypeCalc(u16 move, u8 bankAtk, u8 bankDef)
     moveType = gBattleMoves[move].type;
 
     // check stab
-    if (gBattleMons[bankAtk].type1 == moveType || gBattleMons[bankAtk].type2 == moveType)
+    if (gBattleMons[attacker].type1 == moveType || gBattleMons[attacker].type2 == moveType)
     {
         gBattleMoveDamage = gBattleMoveDamage * 15;
         gBattleMoveDamage = gBattleMoveDamage / 10;
     }
 
-    if (gBattleMons[bankDef].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
+    if (gBattleMons[defender].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
-        flags |= (MOVESTATUS_MISSED | MOVESTATUS_NOTAFFECTED);
+        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)
             {
-                if (gBattleMons[bankDef].status2 & STATUS2_FORESIGHT)
+                if (gBattleMons[defender].status2 & STATUS2_FORESIGHT)
                     break;
                 i += 3;
                 continue;
             }
 
-            else if (gTypeEffectiveness[i] == moveType)
+            else if (TYPE_EFFECT_ATK_TYPE(i) == moveType)
             {
                 // check type1
-                if (gTypeEffectiveness[i + 1] == gBattleMons[bankDef].type1)
-                    ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
+                if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[defender].type1)
+                    ModulateDmgByType2(TYPE_EFFECT_MULTIPLIER(i), move, &flags);
                 // check type2
-                if (gTypeEffectiveness[i + 1] == gBattleMons[bankDef].type2 &&
-                    gBattleMons[bankDef].type1 != gBattleMons[bankDef].type2)
-                    ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
+                if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[defender].type2 &&
+                    gBattleMons[defender].type1 != gBattleMons[defender].type2)
+                    ModulateDmgByType2(TYPE_EFFECT_MULTIPLIER(i), move, &flags);
             }
             i += 3;
         }
     }
 
-    if (gBattleMons[bankDef].ability == ABILITY_WONDER_GUARD && !(flags & MOVESTATUS_MISSED)
-        && AttacksThisTurn(bankAtk, move) == 2
-        && (!(flags & MOVESTATUS_SUPEREFFECTIVE) || ((flags & (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)) == (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)))
+    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)
     {
-        flags |= MOVESTATUS_MISSED;
+        flags |= MOVE_RESULT_MISSED;
     }
     return flags;
 }
@@ -1786,33 +1648,33 @@ u8 AI_TypeCalc(u16 move, u16 targetSpecies, u8 targetAbility)
 
     if (targetAbility == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
-        flags = MOVESTATUS_MISSED | MOVESTATUS_NOTAFFECTED;
+        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] == moveType)
+            if (TYPE_EFFECT_ATK_TYPE(i) == moveType)
             {
                 // check type1
-                if (gTypeEffectiveness[i + 1] == type1)
-                    ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
+                if (TYPE_EFFECT_DEF_TYPE(i) == type1)
+                    ModulateDmgByType2(TYPE_EFFECT_MULTIPLIER(i), move, &flags);
                 // check type2
-                if (gTypeEffectiveness[i + 1] == type2 && type1 != type2)
-                    ModulateDmgByType2(gTypeEffectiveness[i + 2], move, &flags);
+                if (TYPE_EFFECT_DEF_TYPE(i) == type2 && type1 != type2)
+                    ModulateDmgByType2(TYPE_EFFECT_MULTIPLIER(i), move, &flags);
             }
             i += 3;
         }
     }
     if (targetAbility == ABILITY_WONDER_GUARD
-     && (!(flags & MOVESTATUS_SUPEREFFECTIVE) || ((flags & (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)) == (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)))
+     && (!(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 |= MOVESTATUS_NOTAFFECTED;
+        flags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
     return flags;
 }
 
@@ -1836,94 +1698,96 @@ static void Unused_ApplyRandomDmgMultiplier(void)
     ApplyRandomDmgMultiplier();
 }
 
-static void atk07_dmg_adjustment(void)
+static void atk07_adjustnormaldamage(void)
 {
-    u8 holdEffect, quality;
+    u8 holdEffect, param;
 
     ApplyRandomDmgMultiplier();
 
-    if (gBattleMons[gBankTarget].item == ITEM_ENIGMA_BERRY)
+    if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
     {
-        holdEffect = gEnigmaBerries[gBankTarget].holdEffect, quality = gEnigmaBerries[gBankTarget].holdEffectParam;
+        holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect;
+        param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     }
     else
     {
-        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBankTarget].item);
-        quality = ItemId_GetHoldEffectParam(gBattleMons[gBankTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
-    gStringBank = gBankTarget;
+    gPotentialItemEffectBattler = gBattlerTarget;
 
-    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < quality)
+    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemEffectBattle(gBankTarget, holdEffect);
-        gSpecialStatuses[gBankTarget].focusBanded = 1;
+        RecordItemEffectBattle(gBattlerTarget, holdEffect);
+        gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
-    if (gBattleMons[gBankTarget].status2 & STATUS2_SUBSTITUTE)
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE)
         goto END;
-    if (gBattleMoves[gCurrentMove].effect != EFFECT_FALSE_SWIPE && !gProtectStructs[gBankTarget].endured
-     && !gSpecialStatuses[gBankTarget].focusBanded)
+    if (gBattleMoves[gCurrentMove].effect != EFFECT_FALSE_SWIPE && !gProtectStructs[gBattlerTarget].endured
+     && !gSpecialStatuses[gBattlerTarget].focusBanded)
         goto END;
 
-    if (gBattleMons[gBankTarget].hp > gBattleMoveDamage)
+    if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
         goto END;
 
-    gBattleMoveDamage = gBattleMons[gBankTarget].hp - 1;
+    gBattleMoveDamage = gBattleMons[gBattlerTarget].hp - 1;
 
-    if (gProtectStructs[gBankTarget].endured)
+    if (gProtectStructs[gBattlerTarget].endured)
     {
-        gBattleMoveFlags |= MOVESTATUS_ENDURED;
+        gMoveResultFlags |= MOVE_RESULT_FOE_ENDURED;
     }
-    else if (gSpecialStatuses[gBankTarget].focusBanded)
+    else if (gSpecialStatuses[gBattlerTarget].focusBanded)
     {
-        gBattleMoveFlags |= MOVESTATUS_HUNGON;
-        gLastUsedItem = gBattleMons[gBankTarget].item;
+        gMoveResultFlags |= MOVE_RESULT_FOE_HUNG_ON;
+        gLastUsedItem = gBattleMons[gBattlerTarget].item;
     }
 
     END:
         gBattlescriptCurrInstr++;
 }
 
-static void atk08_dmg_adjustment2(void) // 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 holdEffect, quality;
+    u8 holdEffect, param;
 
     ApplyRandomDmgMultiplier();
 
-    if (gBattleMons[gBankTarget].item == ITEM_ENIGMA_BERRY)
+    if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
     {
-        holdEffect = gEnigmaBerries[gBankTarget].holdEffect, quality = gEnigmaBerries[gBankTarget].holdEffectParam;
+        holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect;
+        param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     }
     else
     {
-        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBankTarget].item);
-        quality = ItemId_GetHoldEffectParam(gBattleMons[gBankTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
-    gStringBank = gBankTarget;
+    gPotentialItemEffectBattler = gBattlerTarget;
 
-    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < quality)
+    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemEffectBattle(gBankTarget, holdEffect);
-        gSpecialStatuses[gBankTarget].focusBanded = 1;
+        RecordItemEffectBattle(gBattlerTarget, holdEffect);
+        gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
-    if (gBattleMons[gBankTarget].status2 & STATUS2_SUBSTITUTE)
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE)
         goto END;
-    if (!gProtectStructs[gBankTarget].endured && !gSpecialStatuses[gBankTarget].focusBanded)
+    if (!gProtectStructs[gBattlerTarget].endured && !gSpecialStatuses[gBattlerTarget].focusBanded)
         goto END;
-    if (gBattleMons[gBankTarget].hp > gBattleMoveDamage)
+    if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
         goto END;
 
-    gBattleMoveDamage = gBattleMons[gBankTarget].hp - 1;
+    gBattleMoveDamage = gBattleMons[gBattlerTarget].hp - 1;
 
-    if (gProtectStructs[gBankTarget].endured)
+    if (gProtectStructs[gBattlerTarget].endured)
     {
-        gBattleMoveFlags |= MOVESTATUS_ENDURED;
+        gMoveResultFlags |= MOVE_RESULT_FOE_ENDURED;
     }
-    else if (gSpecialStatuses[gBankTarget].focusBanded)
+    else if (gSpecialStatuses[gBattlerTarget].focusBanded)
     {
-        gBattleMoveFlags |= MOVESTATUS_HUNGON;
-        gLastUsedItem = gBattleMons[gBankTarget].item;
+        gMoveResultFlags |= MOVE_RESULT_FOE_HUNG_ON;
+        gLastUsedItem = gBattleMons[gBattlerTarget].item;
     }
 
     END:
@@ -1932,7 +1796,7 @@ static void atk08_dmg_adjustment2(void) // The same as 0x7 except it doesn't che
 
 static void atk09_attackanimation(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
     if ((gHitMarker & HITMARKER_NO_ANIMATIONS) && (gCurrentMove != MOVE_TRANSFORM && gCurrentMove != MOVE_SUBSTITUTE))
@@ -1952,17 +1816,17 @@ static void atk09_attackanimation(void)
             gBattlescriptCurrInstr++;
             return;
         }
-        if (!(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+        if (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
         {
             u8 multihit;
 
-            gActiveBank = gBankAttacker;
+            gActiveBattler = gBattlerAttacker;
 
-            if (gBattleMons[gBankTarget].status2 & STATUS2_SUBSTITUTE)
+            if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE)
                 multihit = gMultiHitCounter;
             else if (gMultiHitCounter != 0 && gMultiHitCounter != 1)
             {
-                if (gBattleMons[gBankTarget].hp <= gBattleMoveDamage)
+                if (gBattleMons[gBattlerTarget].hp <= gBattleMoveDamage)
                     multihit = 1;
                 else
                     multihit = gMultiHitCounter;
@@ -1970,10 +1834,10 @@ static void atk09_attackanimation(void)
             else
                 multihit = gMultiHitCounter;
 
-            EmitMoveAnimation(0, gCurrentMove, gBattleScripting.animTurn, gBattleMovePower, gBattleMoveDamage, gBattleMons[gBankAttacker].friendship, &gDisableStructs[gBankAttacker], multihit);
+            BtlController_EmitMoveAnimation(0, gCurrentMove, gBattleScripting.animTurn, gBattleMovePower, gBattleMoveDamage, gBattleMons[gBattlerAttacker].friendship, &gDisableStructs[gBattlerAttacker], multihit);
             gBattleScripting.animTurn += 1;
             gBattleScripting.animTargetsHit += 1;
-            MarkBufferBankForExecution(gBankAttacker);
+            MarkBattlerForControllerExec(gBattlerAttacker);
             gBattlescriptCurrInstr++;
         }
         else
@@ -1986,22 +1850,22 @@ static void atk09_attackanimation(void)
 
 static void atk0A_waitanimation(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
         gBattlescriptCurrInstr++;
 }
 
 static void atk0B_healthbarupdate(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    if (!(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+    if (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-        if (gBattleMons[gActiveBank].status2 & STATUS2_SUBSTITUTE && gDisableStructs[gActiveBank].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE))
+        if (gBattleMons[gActiveBattler].status2 & STATUS2_SUBSTITUTE && gDisableStructs[gActiveBattler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE))
         {
-            PrepareStringBattle(STRINGID_SUBSTITUTEDAMAGED, gActiveBank);
+            PrepareStringBattle(STRINGID_SUBSTITUTEDAMAGED, gActiveBattler);
         }
         else
         {
@@ -2015,10 +1879,10 @@ static void atk0B_healthbarupdate(void)
             else
                 healthValue = maxPossibleDmgValue;
 
-            EmitHealthBarUpdate(0, healthValue);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitHealthBarUpdate(0, healthValue);
+            MarkBattlerForControllerExec(gActiveBattler);
 
-            if (GetBankSide(gActiveBank) == SIDE_PLAYER && gBattleMoveDamage > 0)
+            if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER && gBattleMoveDamage > 0)
                 gBattleResults.unk5_0 = 1;
         }
     }
@@ -2030,7 +1894,7 @@ static void atk0C_datahpupdate(void)
 {
     u32 moveType;
 
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
     if (gBattleStruct->dynamicMoveType == 0)
@@ -2040,27 +1904,27 @@ static void atk0C_datahpupdate(void)
     else
         moveType = gBattleMoves[gCurrentMove].type;
 
-    if (!(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+    if (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        if (gBattleMons[gActiveBank].status2 & STATUS2_SUBSTITUTE && gDisableStructs[gActiveBank].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE))
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        if (gBattleMons[gActiveBattler].status2 & STATUS2_SUBSTITUTE && gDisableStructs[gActiveBattler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE))
         {
-            if (gDisableStructs[gActiveBank].substituteHP >= gBattleMoveDamage)
+            if (gDisableStructs[gActiveBattler].substituteHP >= gBattleMoveDamage)
             {
-                if (gSpecialStatuses[gActiveBank].moveturnLostHP == 0)
-                    gSpecialStatuses[gActiveBank].moveturnLostHP = gBattleMoveDamage;
-                gDisableStructs[gActiveBank].substituteHP -= gBattleMoveDamage;
+                if (gSpecialStatuses[gActiveBattler].dmg == 0)
+                    gSpecialStatuses[gActiveBattler].dmg = gBattleMoveDamage;
+                gDisableStructs[gActiveBattler].substituteHP -= gBattleMoveDamage;
                 gHpDealt = gBattleMoveDamage;
             }
             else
             {
-                if (gSpecialStatuses[gActiveBank].moveturnLostHP == 0)
-                    gSpecialStatuses[gActiveBank].moveturnLostHP = gDisableStructs[gActiveBank].substituteHP;
-                gHpDealt = gDisableStructs[gActiveBank].substituteHP;
-                gDisableStructs[gActiveBank].substituteHP = 0;
+                if (gSpecialStatuses[gActiveBattler].dmg == 0)
+                    gSpecialStatuses[gActiveBattler].dmg = gDisableStructs[gActiveBattler].substituteHP;
+                gHpDealt = gDisableStructs[gActiveBattler].substituteHP;
+                gDisableStructs[gActiveBattler].substituteHP = 0;
             }
             // check substitute fading
-            if (gDisableStructs[gActiveBank].substituteHP == 0)
+            if (gDisableStructs[gActiveBattler].substituteHP == 0)
             {
                 gBattlescriptCurrInstr += 2;
                 BattleScriptPushCursor();
@@ -2073,9 +1937,9 @@ static void atk0C_datahpupdate(void)
             gHitMarker &= ~(HITMARKER_IGNORE_SUBSTITUTE);
             if (gBattleMoveDamage < 0) // hp goes up
             {
-                gBattleMons[gActiveBank].hp -= gBattleMoveDamage;
-                if (gBattleMons[gActiveBank].hp > gBattleMons[gActiveBank].maxHP)
-                    gBattleMons[gActiveBank].hp = gBattleMons[gActiveBank].maxHP;
+                gBattleMons[gActiveBattler].hp -= gBattleMoveDamage;
+                if (gBattleMons[gActiveBattler].hp > gBattleMons[gActiveBattler].maxHP)
+                    gBattleMons[gActiveBattler].hp = gBattleMons[gActiveBattler].maxHP;
 
             }
             else // hp goes down
@@ -2086,125 +1950,125 @@ static void atk0C_datahpupdate(void)
                 }
                 else
                 {
-                    gTakenDmg[gActiveBank] += gBattleMoveDamage;
-                    if (gBattlescriptCurrInstr[1] == BS_GET_TARGET)
-                        gTakenDmgBanks[gActiveBank] = gBankAttacker;
+                    gTakenDmg[gActiveBattler] += gBattleMoveDamage;
+                    if (gBattlescriptCurrInstr[1] == BS_TARGET)
+                        gTakenDmgByBattler[gActiveBattler] = gBattlerAttacker;
                     else
-                        gTakenDmgBanks[gActiveBank] = gBankTarget;
+                        gTakenDmgByBattler[gActiveBattler] = gBattlerTarget;
                 }
 
-                if (gBattleMons[gActiveBank].hp > gBattleMoveDamage)
+                if (gBattleMons[gActiveBattler].hp > gBattleMoveDamage)
                 {
-                    gBattleMons[gActiveBank].hp -= gBattleMoveDamage;
+                    gBattleMons[gActiveBattler].hp -= gBattleMoveDamage;
                     gHpDealt = gBattleMoveDamage;
                 }
                 else
                 {
-                    gHpDealt = gBattleMons[gActiveBank].hp;
-                    gBattleMons[gActiveBank].hp = 0;
+                    gHpDealt = gBattleMons[gActiveBattler].hp;
+                    gBattleMons[gActiveBattler].hp = 0;
                 }
 
-                if (!gSpecialStatuses[gActiveBank].moveturnLostHP && !(gHitMarker & HITMARKER_x100000))
-                    gSpecialStatuses[gActiveBank].moveturnLostHP = gHpDealt;
+                if (!gSpecialStatuses[gActiveBattler].dmg && !(gHitMarker & HITMARKER_x100000))
+                    gSpecialStatuses[gActiveBattler].dmg = gHpDealt;
 
-                if (moveType <= 8 && !(gHitMarker & HITMARKER_x100000) && gCurrentMove != MOVE_PAIN_SPLIT)
+                if (IS_MOVE_PHYSICAL(moveType) && !(gHitMarker & HITMARKER_x100000) && gCurrentMove != MOVE_PAIN_SPLIT)
                 {
-                    gProtectStructs[gActiveBank].physicalDmg = gHpDealt;
-                    gSpecialStatuses[gActiveBank].moveturnLostHP_physical = gHpDealt;
-                    if (gBattlescriptCurrInstr[1] == BS_GET_TARGET)
+                    gProtectStructs[gActiveBattler].physicalDmg = gHpDealt;
+                    gSpecialStatuses[gActiveBattler].physicalDmg = gHpDealt;
+                    if (gBattlescriptCurrInstr[1] == BS_TARGET)
                     {
-                        gProtectStructs[gActiveBank].physicalBank = gBankAttacker;
-                        gSpecialStatuses[gActiveBank].moveturnPhysicalBank = gBankAttacker;
+                        gProtectStructs[gActiveBattler].physicalBattlerId = gBattlerAttacker;
+                        gSpecialStatuses[gActiveBattler].physicalBattlerId = gBattlerAttacker;
                     }
                     else
                     {
-                        gProtectStructs[gActiveBank].physicalBank = gBankTarget;
-                        gSpecialStatuses[gActiveBank].moveturnPhysicalBank = gBankTarget;
+                        gProtectStructs[gActiveBattler].physicalBattlerId = gBattlerTarget;
+                        gSpecialStatuses[gActiveBattler].physicalBattlerId = gBattlerTarget;
                     }
                 }
-                else if (moveType > 8 && !(gHitMarker & HITMARKER_x100000))
+                else if (!IS_MOVE_PHYSICAL(moveType) && !(gHitMarker & HITMARKER_x100000))
                 {
-                    gProtectStructs[gActiveBank].specialDmg = gHpDealt;
-                    gSpecialStatuses[gActiveBank].moveturnLostHP_special = gHpDealt;
-                    if (gBattlescriptCurrInstr[1] == BS_GET_TARGET)
+                    gProtectStructs[gActiveBattler].specialDmg = gHpDealt;
+                    gSpecialStatuses[gActiveBattler].specialDmg = gHpDealt;
+                    if (gBattlescriptCurrInstr[1] == BS_TARGET)
                     {
-                        gProtectStructs[gActiveBank].specialBank = gBankAttacker;
-                        gSpecialStatuses[gActiveBank].moveturnSpecialBank = gBankAttacker;
+                        gProtectStructs[gActiveBattler].specialBattlerId = gBattlerAttacker;
+                        gSpecialStatuses[gActiveBattler].specialBattlerId = gBattlerAttacker;
                     }
                     else
                     {
-                        gProtectStructs[gActiveBank].specialBank = gBankTarget;
-                        gSpecialStatuses[gActiveBank].moveturnSpecialBank = gBankTarget;
+                        gProtectStructs[gActiveBattler].specialBattlerId = gBattlerTarget;
+                        gSpecialStatuses[gActiveBattler].specialBattlerId = gBattlerTarget;
                     }
                 }
             }
             gHitMarker &= ~(HITMARKER_x100000);
-            EmitSetMonData(0, REQUEST_HP_BATTLE, 0, 2, &gBattleMons[gActiveBank].hp);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitSetMonData(0, REQUEST_HP_BATTLE, 0, 2, &gBattleMons[gActiveBattler].hp);
+            MarkBattlerForControllerExec(gActiveBattler);
         }
     }
     else
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        if (gSpecialStatuses[gActiveBank].moveturnLostHP == 0)
-            gSpecialStatuses[gActiveBank].moveturnLostHP = 0xFFFF;
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        if (gSpecialStatuses[gActiveBattler].dmg == 0)
+            gSpecialStatuses[gActiveBattler].dmg = 0xFFFF;
     }
     gBattlescriptCurrInstr += 2;
 }
 
 static void atk0D_critmessage(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
-        if (gCritMultiplier == 2 && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+        if (gCritMultiplier == 2 && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
         {
-            PrepareStringBattle(STRINGID_CRITICALHIT, gBankAttacker);
+            PrepareStringBattle(STRINGID_CRITICALHIT, gBattlerAttacker);
             gBattleCommunication[MSG_DISPLAY] = 1;
         }
         gBattlescriptCurrInstr++;
     }
 }
 
-static void atk0E_effectiveness_sound(void)
+static void atk0E_effectivenesssound(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = gBankTarget;
-    if (!(gBattleMoveFlags & MOVESTATUS_MISSED))
+    gActiveBattler = gBattlerTarget;
+    if (!(gMoveResultFlags & MOVE_RESULT_MISSED))
     {
-        switch (gBattleMoveFlags & (u8)(~(MOVESTATUS_MISSED)))
+        switch (gMoveResultFlags & (u8)(~(MOVE_RESULT_MISSED)))
         {
-        case MOVESTATUS_SUPEREFFECTIVE:
-            EmitEffectivenessSound(0, SE_KOUKA_H);
-            MarkBufferBankForExecution(gActiveBank);
+        case MOVE_RESULT_SUPER_EFFECTIVE:
+            BtlController_EmitPlaySE(0, SE_KOUKA_H);
+            MarkBattlerForControllerExec(gActiveBattler);
             break;
-        case MOVESTATUS_NOTVERYEFFECTIVE:
-            EmitEffectivenessSound(0, SE_KOUKA_L);
-            MarkBufferBankForExecution(gActiveBank);
+        case MOVE_RESULT_NOT_VERY_EFFECTIVE:
+            BtlController_EmitPlaySE(0, SE_KOUKA_L);
+            MarkBattlerForControllerExec(gActiveBattler);
             break;
-        case MOVESTATUS_NOTAFFECTED:
-        case MOVESTATUS_FAILED:
+        case MOVE_RESULT_DOESNT_AFFECT_FOE:
+        case MOVE_RESULT_FAILED:
             // no sound
             break;
-        case MOVESTATUS_ENDURED:
-        case MOVESTATUS_ONEHITKO:
-        case MOVESTATUS_HUNGON:
+        case MOVE_RESULT_FOE_ENDURED:
+        case MOVE_RESULT_ONE_HIT_KO:
+        case MOVE_RESULT_FOE_HUNG_ON:
         default:
-            if (gBattleMoveFlags & MOVESTATUS_SUPEREFFECTIVE)
+            if (gMoveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE)
             {
-                EmitEffectivenessSound(0, SE_KOUKA_H);
-                MarkBufferBankForExecution(gActiveBank);
+                BtlController_EmitPlaySE(0, SE_KOUKA_H);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
-            else if (gBattleMoveFlags & MOVESTATUS_NOTVERYEFFECTIVE)
+            else if (gMoveResultFlags & MOVE_RESULT_NOT_VERY_EFFECTIVE)
             {
-                EmitEffectivenessSound(0, SE_KOUKA_L);
-                MarkBufferBankForExecution(gActiveBank);
+                BtlController_EmitPlaySE(0, SE_KOUKA_L);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
-            else if (!(gBattleMoveFlags & (MOVESTATUS_NOTAFFECTED | MOVESTATUS_FAILED)))
+            else if (!(gMoveResultFlags & (MOVE_RESULT_DOESNT_AFFECT_FOE | MOVE_RESULT_FAILED)))
             {
-                EmitEffectivenessSound(0, SE_KOUKA_M);
-                MarkBufferBankForExecution(gActiveBank);
+                BtlController_EmitPlaySE(0, SE_KOUKA_M);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
             break;
         }
@@ -2216,10 +2080,10 @@ static void atk0F_resultmessage(void)
 {
     u32 stringId = 0;
 
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    if (gBattleMoveFlags & MOVESTATUS_MISSED && (!(gBattleMoveFlags & MOVESTATUS_NOTAFFECTED) || gBattleCommunication[6] > 2))
+    if (gMoveResultFlags & MOVE_RESULT_MISSED && (!(gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE) || gBattleCommunication[6] > 2))
     {
         stringId = gMissStringIds[gBattleCommunication[6]];
         gBattleCommunication[MSG_DISPLAY] = 1;
@@ -2227,64 +2091,64 @@ static void atk0F_resultmessage(void)
     else
     {
         gBattleCommunication[MSG_DISPLAY] = 1;
-        switch (gBattleMoveFlags & (u8)(~(MOVESTATUS_MISSED)))
+        switch (gMoveResultFlags & (u8)(~(MOVE_RESULT_MISSED)))
         {
-        case MOVESTATUS_SUPEREFFECTIVE:
+        case MOVE_RESULT_SUPER_EFFECTIVE:
             stringId = STRINGID_SUPEREFFECTIVE;
             break;
-        case MOVESTATUS_NOTVERYEFFECTIVE:
+        case MOVE_RESULT_NOT_VERY_EFFECTIVE:
             stringId = STRINGID_NOTVERYEFFECTIVE;
             break;
-        case MOVESTATUS_ONEHITKO:
+        case MOVE_RESULT_ONE_HIT_KO:
             stringId = STRINGID_ONEHITKO;
             break;
-        case MOVESTATUS_ENDURED:
+        case MOVE_RESULT_FOE_ENDURED:
             stringId = STRINGID_PKMNENDUREDHIT;
             break;
-        case MOVESTATUS_FAILED:
+        case MOVE_RESULT_FAILED:
             stringId = STRINGID_BUTITFAILED;
             break;
-        case MOVESTATUS_NOTAFFECTED:
+        case MOVE_RESULT_DOESNT_AFFECT_FOE:
             stringId = STRINGID_ITDOESNTAFFECT;
             break;
-        case MOVESTATUS_HUNGON:
-            gLastUsedItem = gBattleMons[gBankTarget].item;
-            gStringBank = gBankTarget;
-            gBattleMoveFlags &= ~(MOVESTATUS_ENDURED | MOVESTATUS_HUNGON);
+        case MOVE_RESULT_FOE_HUNG_ON:
+            gLastUsedItem = gBattleMons[gBattlerTarget].item;
+            gPotentialItemEffectBattler = gBattlerTarget;
+            gMoveResultFlags &= ~(MOVE_RESULT_FOE_ENDURED | MOVE_RESULT_FOE_HUNG_ON);
             BattleScriptPushCursor();
             gBattlescriptCurrInstr = BattleScript_HangedOnMsg;
             return;
         default:
-            if (gBattleMoveFlags & MOVESTATUS_NOTAFFECTED)
+            if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
             {
                 stringId = STRINGID_ITDOESNTAFFECT;
             }
-            else if (gBattleMoveFlags & MOVESTATUS_ONEHITKO)
+            else if (gMoveResultFlags & MOVE_RESULT_ONE_HIT_KO)
             {
-                gBattleMoveFlags &= ~(MOVESTATUS_ONEHITKO);
-                gBattleMoveFlags &= ~(MOVESTATUS_SUPEREFFECTIVE);
-                gBattleMoveFlags &= ~(MOVESTATUS_NOTVERYEFFECTIVE);
+                gMoveResultFlags &= ~(MOVE_RESULT_ONE_HIT_KO);
+                gMoveResultFlags &= ~(MOVE_RESULT_SUPER_EFFECTIVE);
+                gMoveResultFlags &= ~(MOVE_RESULT_NOT_VERY_EFFECTIVE);
                 BattleScriptPushCursor();
                 gBattlescriptCurrInstr = BattleScript_OneHitKOMsg;
                 return;
             }
-            else if (gBattleMoveFlags & MOVESTATUS_ENDURED)
+            else if (gMoveResultFlags & MOVE_RESULT_FOE_ENDURED)
             {
-                gBattleMoveFlags &= ~(MOVESTATUS_ENDURED | MOVESTATUS_HUNGON);
+                gMoveResultFlags &= ~(MOVE_RESULT_FOE_ENDURED | MOVE_RESULT_FOE_HUNG_ON);
                 BattleScriptPushCursor();
                 gBattlescriptCurrInstr = BattleScript_EnduredMsg;
                 return;
             }
-            else if (gBattleMoveFlags & MOVESTATUS_HUNGON)
+            else if (gMoveResultFlags & MOVE_RESULT_FOE_HUNG_ON)
             {
-                gLastUsedItem = gBattleMons[gBankTarget].item;
-                gStringBank = gBankTarget;
-                gBattleMoveFlags &= ~(MOVESTATUS_ENDURED | MOVESTATUS_HUNGON);
+                gLastUsedItem = gBattleMons[gBattlerTarget].item;
+                gPotentialItemEffectBattler = gBattlerTarget;
+                gMoveResultFlags &= ~(MOVE_RESULT_FOE_ENDURED | MOVE_RESULT_FOE_HUNG_ON);
                 BattleScriptPushCursor();
                 gBattlescriptCurrInstr = BattleScript_HangedOnMsg;
                 return;
             }
-            else if (gBattleMoveFlags & MOVESTATUS_FAILED)
+            else if (gMoveResultFlags & MOVE_RESULT_FAILED)
             {
                 stringId = STRINGID_BUTITFAILED;
             }
@@ -2296,28 +2160,28 @@ static void atk0F_resultmessage(void)
     }
 
     if (stringId)
-        PrepareStringBattle(stringId, gBankAttacker);
+        PrepareStringBattle(stringId, gBattlerAttacker);
 
     gBattlescriptCurrInstr++;
 }
 
 static void atk10_printstring(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
         u16 var = BS2ScriptRead16(gBattlescriptCurrInstr + 1);
-        PrepareStringBattle(var, gBankAttacker);
+        PrepareStringBattle(var, gBattlerAttacker);
         gBattlescriptCurrInstr += 3;
         gBattleCommunication[MSG_DISPLAY] = 1;
     }
 }
 
-static void atk11_printstring_playeronly(void)
+static void atk11_printselectionstring(void)
 {
-    gActiveBank = gBankAttacker;
+    gActiveBattler = gBattlerAttacker;
 
-    EmitPrintStringPlayerOnly(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1));
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitPrintSelectionString(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1));
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 3;
     gBattleCommunication[MSG_DISPLAY] = 1;
@@ -2325,7 +2189,7 @@ static void atk11_printstring_playeronly(void)
 
 static void atk12_waitmessage(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
         if (!gBattleCommunication[MSG_DISPLAY])
         {
@@ -2346,40 +2210,40 @@ static void atk12_waitmessage(void)
 
 static void atk13_printfromtable(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
         const u16 *ptr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
         ptr += gBattleCommunication[MULTISTRING_CHOOSER];
 
-        PrepareStringBattle(*ptr, gBankAttacker);
+        PrepareStringBattle(*ptr, gBattlerAttacker);
 
         gBattlescriptCurrInstr += 5;
         gBattleCommunication[MSG_DISPLAY] = 1;
     }
 }
 
-static void atk14_printfromtable_playeronly(void)
+static void atk14_printselectionstringfromtable(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
         const u16 *ptr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
         ptr += gBattleCommunication[MULTISTRING_CHOOSER];
 
-        gActiveBank = gBankAttacker;
-        EmitPrintStringPlayerOnly(0, *ptr);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = gBattlerAttacker;
+        BtlController_EmitPrintSelectionString(0, *ptr);
+        MarkBattlerForControllerExec(gActiveBattler);
 
         gBattlescriptCurrInstr += 5;
         gBattleCommunication[MSG_DISPLAY] = 1;
     }
 }
 
-u8 BankGetTurnOrder(u8 bank)
+u8 GetBattlerTurnOrderNum(u8 battlerId)
 {
     s32 i;
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
-        if (gBanksByTurnOrder[i] == bank)
+        if (gBattleTurnOrder[i] == battlerId)
             break;
     }
     return i;
@@ -2406,67 +2270,67 @@ void SetMoveEffect(bool8 primary, u8 certain)
 
     if (gBattleCommunication[MOVE_EFFECT_BYTE] & MOVE_EFFECT_AFFECTS_USER)
     {
-        gEffectBank = gBankAttacker; // bank that effects get applied on
+        gEffectBattler = gBattlerAttacker; // battlerId that effects get applied on
         gBattleCommunication[MOVE_EFFECT_BYTE] &= ~(MOVE_EFFECT_AFFECTS_USER);
         affectsUser = MOVE_EFFECT_AFFECTS_USER;
-        gBattleScripting.bank = gBankTarget; // theoretically the attacker
+        gBattleScripting.battler = gBattlerTarget; // theoretically the attacker
     }
     else
     {
-        gEffectBank = gBankTarget;
-        gBattleScripting.bank = gBankAttacker;
+        gEffectBattler = gBattlerTarget;
+        gBattleScripting.battler = gBattlerAttacker;
     }
 
-    if (gBattleMons[gEffectBank].ability == ABILITY_SHIELD_DUST && !(gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
+    if (gBattleMons[gEffectBattler].ability == ABILITY_SHIELD_DUST && !(gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
         && !primary && gBattleCommunication[MOVE_EFFECT_BYTE] <= 9)
         INCREMENT_RESET_RETURN
 
-    if (gSideAffecting[GET_BANK_SIDE(gEffectBank)] & SIDE_STATUS_SAFEGUARD && !(gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
+    if (gSideStatuses[GET_BATTLER_SIDE(gEffectBattler)] & SIDE_STATUS_SAFEGUARD && !(gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
         && !primary && gBattleCommunication[MOVE_EFFECT_BYTE] <= 7)
         INCREMENT_RESET_RETURN
 
-    if (gBattleMons[gEffectBank].hp == 0
+    if (gBattleMons[gEffectBattler].hp == 0
         && gBattleCommunication[MOVE_EFFECT_BYTE] != MOVE_EFFECT_PAYDAY
         && gBattleCommunication[MOVE_EFFECT_BYTE] != MOVE_EFFECT_STEAL_ITEM)
         INCREMENT_RESET_RETURN
 
-    if (gBattleMons[gEffectBank].status2 & STATUS2_SUBSTITUTE && affectsUser != MOVE_EFFECT_AFFECTS_USER)
+    if (gBattleMons[gEffectBattler].status2 & STATUS2_SUBSTITUTE && affectsUser != MOVE_EFFECT_AFFECTS_USER)
         INCREMENT_RESET_RETURN
 
     if (gBattleCommunication[MOVE_EFFECT_BYTE] <= 6) // status change
     {
         switch (sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]])
         {
-        case STATUS_SLEEP:
+        case STATUS1_SLEEP:
             // check active uproar
-            if (gBattleMons[gEffectBank].ability != ABILITY_SOUNDPROOF)
+            if (gBattleMons[gEffectBattler].ability != ABILITY_SOUNDPROOF)
             {
-                for (gActiveBank = 0;
-                    gActiveBank < gNoOfAllBanks && !(gBattleMons[gActiveBank].status2 & STATUS2_UPROAR);
-                    gActiveBank++)
+                for (gActiveBattler = 0;
+                    gActiveBattler < gBattlersCount && !(gBattleMons[gActiveBattler].status2 & STATUS2_UPROAR);
+                    gActiveBattler++)
                 {}
             }
             else
-                gActiveBank = gNoOfAllBanks;
+                gActiveBattler = gBattlersCount;
 
-            if (gBattleMons[gEffectBank].status1)
+            if (gBattleMons[gEffectBattler].status1)
                 break;
-            if (gActiveBank != gNoOfAllBanks)
+            if (gActiveBattler != gBattlersCount)
                 break;
-            if (gBattleMons[gEffectBank].ability == ABILITY_VITAL_SPIRIT)
+            if (gBattleMons[gEffectBattler].ability == ABILITY_VITAL_SPIRIT)
                 break;
-            if (gBattleMons[gEffectBank].ability == ABILITY_INSOMNIA)
+            if (gBattleMons[gEffectBattler].ability == ABILITY_INSOMNIA)
                 break;
 
-            CancelMultiTurnMoves(gEffectBank);
+            CancelMultiTurnMoves(gEffectBattler);
             statusChanged = TRUE;
             break;
-        case STATUS_POISON:
-            if (gBattleMons[gEffectBank].ability == ABILITY_IMMUNITY
+        case STATUS1_POISON:
+            if (gBattleMons[gEffectBattler].ability == ABILITY_IMMUNITY
                 && (primary == TRUE || certain == MOVE_EFFECT_CERTAIN))
             {
                 gLastUsedAbility = ABILITY_IMMUNITY;
-                RecordAbilityBattle(gEffectBank, ABILITY_IMMUNITY);
+                RecordAbilityBattle(gEffectBattler, ABILITY_IMMUNITY);
 
                 BattleScriptPush(gBattlescriptCurrInstr + 1);
                 gBattlescriptCurrInstr = BattleScript_PSNPrevention;
@@ -2482,8 +2346,8 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 }
                 RESET_RETURN
             }
-            if ((gBattleMons[gEffectBank].type1 == TYPE_POISON || gBattleMons[gEffectBank].type2 == TYPE_POISON
-                 || gBattleMons[gEffectBank].type1 == TYPE_STEEL || gBattleMons[gEffectBank].type2 == TYPE_STEEL)
+            if ((gBattleMons[gEffectBattler].type1 == TYPE_POISON || gBattleMons[gEffectBattler].type2 == TYPE_POISON
+                 || gBattleMons[gEffectBattler].type1 == TYPE_STEEL || gBattleMons[gEffectBattler].type2 == TYPE_STEEL)
                 && (gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
                 && (primary == TRUE || certain == MOVE_EFFECT_CERTAIN))
             {
@@ -2493,27 +2357,27 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 gBattleCommunication[MULTISTRING_CHOOSER] = 2;
                 RESET_RETURN
             }
-            if (gBattleMons[gEffectBank].type1 == TYPE_POISON)
+            if (gBattleMons[gEffectBattler].type1 == TYPE_POISON)
                 break;
-            if (gBattleMons[gEffectBank].type2 == TYPE_POISON)
+            if (gBattleMons[gEffectBattler].type2 == TYPE_POISON)
                 break;
-            if (gBattleMons[gEffectBank].type1 == TYPE_STEEL)
+            if (gBattleMons[gEffectBattler].type1 == TYPE_STEEL)
                 break;
-            if (gBattleMons[gEffectBank].type2 == TYPE_STEEL)
+            if (gBattleMons[gEffectBattler].type2 == TYPE_STEEL)
                 break;
-            if (gBattleMons[gEffectBank].status1)
+            if (gBattleMons[gEffectBattler].status1)
                 break;
-            if (gBattleMons[gEffectBank].ability == ABILITY_IMMUNITY)
+            if (gBattleMons[gEffectBattler].ability == ABILITY_IMMUNITY)
                 break;
 
             statusChanged = TRUE;
             break;
-        case STATUS_BURN:
-            if (gBattleMons[gEffectBank].ability == ABILITY_WATER_VEIL
+        case STATUS1_BURN:
+            if (gBattleMons[gEffectBattler].ability == ABILITY_WATER_VEIL
                 && (primary == TRUE || certain == MOVE_EFFECT_CERTAIN))
             {
                 gLastUsedAbility = ABILITY_WATER_VEIL;
-                RecordAbilityBattle(gEffectBank, ABILITY_WATER_VEIL);
+                RecordAbilityBattle(gEffectBattler, ABILITY_WATER_VEIL);
 
                 BattleScriptPush(gBattlescriptCurrInstr + 1);
                 gBattlescriptCurrInstr = BattleScript_BRNPrevention;
@@ -2528,8 +2392,8 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 }
                 RESET_RETURN
             }
-            if ((gBattleMons[gEffectBank].type1 == TYPE_FIRE
-                 || gBattleMons[gEffectBank].type2 == TYPE_FIRE)
+            if ((gBattleMons[gEffectBattler].type1 == TYPE_FIRE
+                 || gBattleMons[gEffectBattler].type2 == TYPE_FIRE)
                 && (gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
                 && (primary == TRUE || certain == MOVE_EFFECT_CERTAIN))
             {
@@ -2539,41 +2403,41 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 gBattleCommunication[MULTISTRING_CHOOSER] = 2;
                 RESET_RETURN
             }
-            if (gBattleMons[gEffectBank].type1 == TYPE_FIRE)
+            if (gBattleMons[gEffectBattler].type1 == TYPE_FIRE)
                 break;
-            if (gBattleMons[gEffectBank].type2 == TYPE_FIRE)
+            if (gBattleMons[gEffectBattler].type2 == TYPE_FIRE)
                 break;
-            if (gBattleMons[gEffectBank].ability == ABILITY_WATER_VEIL)
+            if (gBattleMons[gEffectBattler].ability == ABILITY_WATER_VEIL)
                 break;
-            if (gBattleMons[gEffectBank].status1)
+            if (gBattleMons[gEffectBattler].status1)
                 break;
 
             statusChanged = TRUE;
             break;
-        case STATUS_FREEZE:
+        case STATUS1_FREEZE:
             if (WEATHER_HAS_EFFECT && gBattleWeather & WEATHER_SUN_ANY)
                 noSunCanFreeze = FALSE;
-            if (gBattleMons[gEffectBank].type1 == TYPE_ICE)
+            if (gBattleMons[gEffectBattler].type1 == TYPE_ICE)
                 break;
-            if (gBattleMons[gEffectBank].type2 == TYPE_ICE)
+            if (gBattleMons[gEffectBattler].type2 == TYPE_ICE)
                 break;
-            if (gBattleMons[gEffectBank].status1)
+            if (gBattleMons[gEffectBattler].status1)
                 break;
             if (noSunCanFreeze == 0)
                 break;
-            if (gBattleMons[gEffectBank].ability == ABILITY_MAGMA_ARMOR)
+            if (gBattleMons[gEffectBattler].ability == ABILITY_MAGMA_ARMOR)
                 break;
 
-            CancelMultiTurnMoves(gEffectBank);
+            CancelMultiTurnMoves(gEffectBattler);
             statusChanged = TRUE;
             break;
-        case STATUS_PARALYSIS:
-            if (gBattleMons[gEffectBank].ability == ABILITY_LIMBER)
+        case STATUS1_PARALYSIS:
+            if (gBattleMons[gEffectBattler].ability == ABILITY_LIMBER)
             {
                 if (primary == TRUE || certain == MOVE_EFFECT_CERTAIN)
                 {
                     gLastUsedAbility = ABILITY_LIMBER;
-                    RecordAbilityBattle(gEffectBank, ABILITY_LIMBER);
+                    RecordAbilityBattle(gEffectBattler, ABILITY_LIMBER);
 
                     BattleScriptPush(gBattlescriptCurrInstr + 1);
                     gBattlescriptCurrInstr = BattleScript_PRLZPrevention;
@@ -2592,16 +2456,16 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 else
                     break;
             }
-            if (gBattleMons[gEffectBank].status1)
+            if (gBattleMons[gEffectBattler].status1)
                 break;
 
             statusChanged = TRUE;
             break;
-        case STATUS_TOXIC_POISON:
-            if (gBattleMons[gEffectBank].ability == ABILITY_IMMUNITY && (primary == TRUE || certain == MOVE_EFFECT_CERTAIN))
+        case STATUS1_TOXIC_POISON:
+            if (gBattleMons[gEffectBattler].ability == ABILITY_IMMUNITY && (primary == TRUE || certain == MOVE_EFFECT_CERTAIN))
             {
                 gLastUsedAbility = ABILITY_IMMUNITY;
-                RecordAbilityBattle(gEffectBank, ABILITY_IMMUNITY);
+                RecordAbilityBattle(gEffectBattler, ABILITY_IMMUNITY);
 
                 BattleScriptPush(gBattlescriptCurrInstr + 1);
                 gBattlescriptCurrInstr = BattleScript_PSNPrevention;
@@ -2617,8 +2481,8 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 }
                 RESET_RETURN
             }
-            if ((gBattleMons[gEffectBank].type1 == TYPE_POISON || gBattleMons[gEffectBank].type2 == TYPE_POISON
-                 || gBattleMons[gEffectBank].type1 == TYPE_STEEL || gBattleMons[gEffectBank].type2 == TYPE_STEEL)
+            if ((gBattleMons[gEffectBattler].type1 == TYPE_POISON || gBattleMons[gEffectBattler].type2 == TYPE_POISON
+                 || gBattleMons[gEffectBattler].type1 == TYPE_STEEL || gBattleMons[gEffectBattler].type2 == TYPE_STEEL)
                 && (gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
                 && (primary == TRUE || certain == MOVE_EFFECT_CERTAIN))
             {
@@ -2628,25 +2492,25 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 gBattleCommunication[MULTISTRING_CHOOSER] = 2;
                 RESET_RETURN
             }
-            if (gBattleMons[gEffectBank].status1)
+            if (gBattleMons[gEffectBattler].status1)
                 break;
-            if (gBattleMons[gEffectBank].type1 != TYPE_POISON
-                && gBattleMons[gEffectBank].type2 != TYPE_POISON
-                && gBattleMons[gEffectBank].type1 != TYPE_STEEL
-                && gBattleMons[gEffectBank].type2 != TYPE_STEEL)
+            if (gBattleMons[gEffectBattler].type1 != TYPE_POISON
+                && gBattleMons[gEffectBattler].type2 != TYPE_POISON
+                && gBattleMons[gEffectBattler].type1 != TYPE_STEEL
+                && gBattleMons[gEffectBattler].type2 != TYPE_STEEL)
             {
-                if (gBattleMons[gEffectBank].ability == ABILITY_IMMUNITY)
+                if (gBattleMons[gEffectBattler].ability == ABILITY_IMMUNITY)
                     break;
 
                 // It's redundant, because at this point we know the status1 value is 0.
-                gBattleMons[gEffectBank].status1 &= ~(STATUS_TOXIC_POISON);
-                gBattleMons[gEffectBank].status1 &= ~(STATUS_POISON);
+                gBattleMons[gEffectBattler].status1 &= ~(STATUS1_TOXIC_POISON);
+                gBattleMons[gEffectBattler].status1 &= ~(STATUS1_POISON);
                 statusChanged = TRUE;
                 break;
             }
             else
             {
-                gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
+                gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
             }
             break;
         }
@@ -2654,16 +2518,16 @@ void SetMoveEffect(bool8 primary, u8 certain)
         {
             BattleScriptPush(gBattlescriptCurrInstr + 1);
 
-            if (sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]] == STATUS_SLEEP)
-                gBattleMons[gEffectBank].status1 |= ((Random() & 3) + 2);
+            if (sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]] == STATUS1_SLEEP)
+                gBattleMons[gEffectBattler].status1 |= ((Random() & 3) + 2);
             else
-                gBattleMons[gEffectBank].status1 |= sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]];
+                gBattleMons[gEffectBattler].status1 |= sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]];
 
             gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleCommunication[MOVE_EFFECT_BYTE]];
 
-            gActiveBank = gEffectBank;
-            EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gEffectBank].status1);
-            MarkBufferBankForExecution(gActiveBank);
+            gActiveBattler = gEffectBattler;
+            BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gEffectBattler].status1);
+            MarkBattlerForControllerExec(gActiveBattler);
 
             if (gHitMarker & HITMARKER_IGNORE_SAFEGUARD)
             {
@@ -2698,7 +2562,7 @@ void SetMoveEffect(bool8 primary, u8 certain)
     }
     else
     {
-        if (gBattleMons[gEffectBank].status2 & sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]])
+        if (gBattleMons[gEffectBattler].status2 & sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]])
         {
             gBattlescriptCurrInstr++;
         }
@@ -2708,26 +2572,26 @@ void SetMoveEffect(bool8 primary, u8 certain)
             switch (gBattleCommunication[MOVE_EFFECT_BYTE])
             {
             case MOVE_EFFECT_CONFUSION:
-                if (gBattleMons[gEffectBank].ability == ABILITY_OWN_TEMPO
-                    || gBattleMons[gEffectBank].status2 & STATUS2_CONFUSION)
+                if (gBattleMons[gEffectBattler].ability == ABILITY_OWN_TEMPO
+                    || gBattleMons[gEffectBattler].status2 & STATUS2_CONFUSION)
                 {
                     gBattlescriptCurrInstr++;
                 }
                 else
                 {
-                    gBattleMons[gEffectBank].status2 |= (((Random()) % 0x4)) + 2;
+                    gBattleMons[gEffectBattler].status2 |= (((Random()) % 0x4)) + 2;
 
                     BattleScriptPush(gBattlescriptCurrInstr + 1);
                     gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleCommunication[MOVE_EFFECT_BYTE]];
                 }
                 break;
             case MOVE_EFFECT_FLINCH:
-                if (gBattleMons[gEffectBank].ability == ABILITY_INNER_FOCUS)
+                if (gBattleMons[gEffectBattler].ability == ABILITY_INNER_FOCUS)
                 {
                     if (primary == TRUE || certain == MOVE_EFFECT_CERTAIN)
                     {
                         gLastUsedAbility = ABILITY_INNER_FOCUS;
-                        RecordAbilityBattle(gEffectBank, ABILITY_INNER_FOCUS);
+                        RecordAbilityBattle(gEffectBattler, ABILITY_INNER_FOCUS);
                         gBattlescriptCurrInstr = BattleScript_FlinchPrevention;
                     }
                     else
@@ -2737,18 +2601,18 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 }
                 else
                 {
-                    if (BankGetTurnOrder(gEffectBank) > gCurrentTurnActionNumber)
-                        gBattleMons[gEffectBank].status2 |= sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]];
+                    if (GetBattlerTurnOrderNum(gEffectBattler) > gCurrentTurnActionNumber)
+                        gBattleMons[gEffectBattler].status2 |= sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]];
                     gBattlescriptCurrInstr++;
                 }
                 break;
             case MOVE_EFFECT_UPROAR:
-                if (!(gBattleMons[gEffectBank].status2 & STATUS2_UPROAR))
+                if (!(gBattleMons[gEffectBattler].status2 & STATUS2_UPROAR))
                 {
 
-                    gBattleMons[gEffectBank].status2 |= STATUS2_MULTIPLETURNS;
-                    gLockedMoves[gEffectBank] = gCurrentMove;
-                    gBattleMons[gEffectBank].status2 |= ((Random() & 3) + 2) << 4;
+                    gBattleMons[gEffectBattler].status2 |= STATUS2_MULTIPLETURNS;
+                    gLockedMoves[gEffectBattler] = gCurrentMove;
+                    gBattleMons[gEffectBattler].status2 |= ((Random() & 3) + 2) << 4;
 
                     BattleScriptPush(gBattlescriptCurrInstr + 1);
                     gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleCommunication[MOVE_EFFECT_BYTE]];
@@ -2759,10 +2623,10 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 }
                 break;
             case MOVE_EFFECT_PAYDAY:
-                if (GET_BANK_SIDE(gBankAttacker) == SIDE_PLAYER)
+                if (GET_BATTLER_SIDE(gBattlerAttacker) == B_SIDE_PLAYER)
                 {
                     u16 PayDay = gPaydayMoney;
-                    gPaydayMoney += (gBattleMons[gBankAttacker].level * 5);
+                    gPaydayMoney += (gBattleMons[gBattlerAttacker].level * 5);
                     if (PayDay > gPaydayMoney)
                         gPaydayMoney = 0xFFFF;
                 }
@@ -2770,7 +2634,7 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleCommunication[MOVE_EFFECT_BYTE]];
                 break;
             case MOVE_EFFECT_TRI_ATTACK:
-                if (gBattleMons[gEffectBank].status1)
+                if (gBattleMons[gEffectBattler].status1)
                 {
                     gBattlescriptCurrInstr++;
                 }
@@ -2781,23 +2645,23 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 }
                 break;
             case MOVE_EFFECT_CHARGING:
-                gBattleMons[gEffectBank].status2 |= STATUS2_MULTIPLETURNS;
-                gLockedMoves[gEffectBank] = gCurrentMove;
-                gProtectStructs[gEffectBank].chargingTurn = 1;
+                gBattleMons[gEffectBattler].status2 |= STATUS2_MULTIPLETURNS;
+                gLockedMoves[gEffectBattler] = gCurrentMove;
+                gProtectStructs[gEffectBattler].chargingTurn = 1;
                 gBattlescriptCurrInstr++;
                 break;
             case MOVE_EFFECT_WRAP:
-                if (gBattleMons[gEffectBank].status2 & STATUS2_WRAPPED)
+                if (gBattleMons[gEffectBattler].status2 & STATUS2_WRAPPED)
                 {
                     gBattlescriptCurrInstr++;
                 }
                 else
                 {
-                    gBattleMons[gEffectBank].status2 |= ((Random() & 3) + 3) << 0xD;
+                    gBattleMons[gEffectBattler].status2 |= ((Random() & 3) + 3) << 0xD;
 
-                    *(gBattleStruct->wrappedMove + gEffectBank * 2 + 0) = gCurrentMove;
-                    *(gBattleStruct->wrappedMove + gEffectBank * 2 + 1) = gCurrentMove >> 8;
-                    *(gBattleStruct->wrappedBy + gEffectBank) = gBankAttacker;
+                    *(gBattleStruct->wrappedMove + gEffectBattler * 2 + 0) = gCurrentMove;
+                    *(gBattleStruct->wrappedMove + gEffectBattler * 2 + 1) = gCurrentMove >> 8;
+                    *(gBattleStruct->wrappedBy + gEffectBattler) = gBattlerAttacker;
 
                     BattleScriptPush(gBattlescriptCurrInstr + 1);
                     gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleCommunication[MOVE_EFFECT_BYTE]];
@@ -2904,13 +2768,13 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 }
                 break;
             case MOVE_EFFECT_RECHARGE:
-                gBattleMons[gEffectBank].status2 |= STATUS2_RECHARGE;
-                gDisableStructs[gEffectBank].rechargeCounter = 2;
-                gLockedMoves[gEffectBank] = gCurrentMove;
+                gBattleMons[gEffectBattler].status2 |= STATUS2_RECHARGE;
+                gDisableStructs[gEffectBattler].rechargeCounter = 2;
+                gLockedMoves[gEffectBattler] = gCurrentMove;
                 gBattlescriptCurrInstr++;
                 break;
             case MOVE_EFFECT_RAGE:
-                gBattleMons[gBankAttacker].status2 |= STATUS2_RAGE;
+                gBattleMons[gBattlerAttacker].status2 |= STATUS2_RAGE;
                 gBattlescriptCurrInstr++;
                 break;
             case MOVE_EFFECT_STEAL_ITEM:
@@ -2921,8 +2785,8 @@ void SetMoveEffect(bool8 primary, u8 certain)
                         break;
                     }
 
-                    side = GetBankSide(gBankAttacker);
-                    if (GetBankSide(gBankAttacker) == SIDE_OPPONENT
+                    side = GetBattlerSide(gBattlerAttacker);
+                    if (GetBattlerSide(gBattlerAttacker) == B_SIDE_OPPONENT
                         && !(gBattleTypeFlags &
                              (BATTLE_TYPE_EREADER_TRAINER
                               | BATTLE_TYPE_FRONTIER
@@ -2938,56 +2802,56 @@ void SetMoveEffect(bool8 primary, u8 certain)
                            | BATTLE_TYPE_LINK
                            | BATTLE_TYPE_x2000000
                            | BATTLE_TYPE_SECRET_BASE))
-                        && (gWishFutureKnock.knockedOffPokes[side] & gBitTable[gBattlePartyID[gBankAttacker]]))
+                        && (gWishFutureKnock.knockedOffPokes[side] & gBitTable[gBattlerPartyIndexes[gBattlerAttacker]]))
                     {
                         gBattlescriptCurrInstr++;
                     }
-                    else if (gBattleMons[gBankTarget].item
-                        && gBattleMons[gBankTarget].ability == ABILITY_STICKY_HOLD)
+                    else if (gBattleMons[gBattlerTarget].item
+                        && gBattleMons[gBattlerTarget].ability == ABILITY_STICKY_HOLD)
                     {
                         BattleScriptPushCursor();
                         gBattlescriptCurrInstr = BattleScript_NoItemSteal;
 
-                        gLastUsedAbility = gBattleMons[gBankTarget].ability;
-                        RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+                        gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
+                        RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
                     }
-                    else if (gBattleMons[gBankAttacker].item != 0
-                        || gBattleMons[gBankTarget].item == ITEM_ENIGMA_BERRY
-                        || IS_ITEM_MAIL(gBattleMons[gBankTarget].item)
-                        || gBattleMons[gBankTarget].item == 0)
+                    else if (gBattleMons[gBattlerAttacker].item != 0
+                        || gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY
+                        || IS_ITEM_MAIL(gBattleMons[gBattlerTarget].item)
+                        || gBattleMons[gBattlerTarget].item == 0)
                     {
                         gBattlescriptCurrInstr++;
                     }
                     else
                     {
-                        u16* changedItem = &gBattleStruct->changedItems[gBankAttacker];
-                        gLastUsedItem = *changedItem = gBattleMons[gBankTarget].item;
-                        gBattleMons[gBankTarget].item = 0;
+                        u16* changedItem = &gBattleStruct->changedItems[gBattlerAttacker];
+                        gLastUsedItem = *changedItem = gBattleMons[gBattlerTarget].item;
+                        gBattleMons[gBattlerTarget].item = 0;
 
-                        gActiveBank = gBankAttacker;
-                        EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gLastUsedItem);
-                        MarkBufferBankForExecution(gBankAttacker);
+                        gActiveBattler = gBattlerAttacker;
+                        BtlController_EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gLastUsedItem);
+                        MarkBattlerForControllerExec(gBattlerAttacker);
 
-                        gActiveBank = gBankTarget;
-                        EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gBankTarget].item);
-                        MarkBufferBankForExecution(gBankTarget);
+                        gActiveBattler = gBattlerTarget;
+                        BtlController_EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gBattlerTarget].item);
+                        MarkBattlerForControllerExec(gBattlerTarget);
 
                         BattleScriptPush(gBattlescriptCurrInstr + 1);
                         gBattlescriptCurrInstr = BattleScript_ItemSteal;
 
-                        *(u8*)((u8*)(&gBattleStruct->choicedMove[gBankTarget]) + 0) = 0;
-                        *(u8*)((u8*)(&gBattleStruct->choicedMove[gBankTarget]) + 1) = 0;
+                        *(u8*)((u8*)(&gBattleStruct->choicedMove[gBattlerTarget]) + 0) = 0;
+                        *(u8*)((u8*)(&gBattleStruct->choicedMove[gBattlerTarget]) + 1) = 0;
                     }
 
                 }
                 break;
             case MOVE_EFFECT_PREVENT_ESCAPE:
-                gBattleMons[gBankTarget].status2 |= STATUS2_ESCAPE_PREVENTION;
-                gDisableStructs[gBankTarget].bankPreventingEscape = gBankAttacker;
+                gBattleMons[gBattlerTarget].status2 |= STATUS2_ESCAPE_PREVENTION;
+                gDisableStructs[gBattlerTarget].battlerPreventingEscape = gBattlerAttacker;
                 gBattlescriptCurrInstr++;
                 break;
             case MOVE_EFFECT_NIGHTMARE:
-                gBattleMons[gBankTarget].status2 |= STATUS2_NIGHTMARE;
+                gBattleMons[gBattlerTarget].status2 |= STATUS2_NIGHTMARE;
                 gBattlescriptCurrInstr++;
                 break;
             case MOVE_EFFECT_ALL_STATS_UP:
@@ -2999,17 +2863,17 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 gBattlescriptCurrInstr = BattleScript_RapidSpinAway;
                 break;
             case MOVE_EFFECT_REMOVE_PARALYSIS: // Smelling salts
-                if (!(gBattleMons[gBankTarget].status1 & STATUS_PARALYSIS))
+                if (!(gBattleMons[gBattlerTarget].status1 & STATUS1_PARALYSIS))
                 {
                     gBattlescriptCurrInstr++;
                 }
                 else
                 {
-                    gBattleMons[gBankTarget].status1 &= ~(STATUS_PARALYSIS);
+                    gBattleMons[gBattlerTarget].status1 &= ~(STATUS1_PARALYSIS);
 
-                    gActiveBank = gBankTarget;
-                    EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBank].status1);
-                    MarkBufferBankForExecution(gActiveBank);
+                    gActiveBattler = gBattlerTarget;
+                    BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1);
+                    MarkBattlerForControllerExec(gActiveBattler);
 
                     BattleScriptPush(gBattlescriptCurrInstr + 1);
                     gBattlescriptCurrInstr = BattleScript_TargetPRLZHeal;
@@ -3028,21 +2892,21 @@ void SetMoveEffect(bool8 primary, u8 certain)
                 gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleCommunication[MOVE_EFFECT_BYTE]];
                 break;
             case MOVE_EFFECT_THRASH:
-                if (gBattleMons[gEffectBank].status2 & STATUS2_LOCK_CONFUSE)
+                if (gBattleMons[gEffectBattler].status2 & STATUS2_LOCK_CONFUSE)
                 {
                     gBattlescriptCurrInstr++;
                 }
                 else
                 {
-                    gBattleMons[gEffectBank].status2 |= STATUS2_MULTIPLETURNS;
-                    gLockedMoves[gEffectBank] = gCurrentMove;
-                    gBattleMons[gEffectBank].status2 |= (((Random() & 1) + 2) << 0xA);
+                    gBattleMons[gEffectBattler].status2 |= STATUS2_MULTIPLETURNS;
+                    gLockedMoves[gEffectBattler] = gCurrentMove;
+                    gBattleMons[gEffectBattler].status2 |= (((Random() & 1) + 2) << 0xA);
                 }
                 break;
             case MOVE_EFFECT_KNOCK_OFF:
-                if (gBattleMons[gEffectBank].ability == ABILITY_STICKY_HOLD)
+                if (gBattleMons[gEffectBattler].ability == ABILITY_STICKY_HOLD)
                 {
-                    if (gBattleMons[gEffectBank].item == 0)
+                    if (gBattleMons[gEffectBattler].item == 0)
                     {
                         gBattlescriptCurrInstr++;
                     }
@@ -3050,23 +2914,23 @@ void SetMoveEffect(bool8 primary, u8 certain)
                     {
                         gLastUsedAbility = ABILITY_STICKY_HOLD;
                         gBattlescriptCurrInstr = BattleScript_StickyHoldActivates;
-                        RecordAbilityBattle(gEffectBank, ABILITY_STICKY_HOLD);
+                        RecordAbilityBattle(gEffectBattler, ABILITY_STICKY_HOLD);
                     }
                     break;
                 }
-                if (gBattleMons[gEffectBank].item)
+                if (gBattleMons[gEffectBattler].item)
                 {
-                    side = GetBankSide(gEffectBank);
+                    side = GetBattlerSide(gEffectBattler);
 
-                    gLastUsedItem = gBattleMons[gEffectBank].item;
-                    gBattleMons[gEffectBank].item = 0;
-                    gWishFutureKnock.knockedOffPokes[side] |= gBitTable[gBattlePartyID[gEffectBank]];
+                    gLastUsedItem = gBattleMons[gEffectBattler].item;
+                    gBattleMons[gEffectBattler].item = 0;
+                    gWishFutureKnock.knockedOffPokes[side] |= gBitTable[gBattlerPartyIndexes[gEffectBattler]];
 
                     BattleScriptPush(gBattlescriptCurrInstr + 1);
                     gBattlescriptCurrInstr = BattleScript_KnockedOff;
 
-                    *(u8*)((u8*)(&gBattleStruct->choicedMove[gEffectBank]) + 0) = 0;
-                    *(u8*)((u8*)(&gBattleStruct->choicedMove[gEffectBank]) + 1) = 0;
+                    *(u8*)((u8*)(&gBattleStruct->choicedMove[gEffectBattler]) + 0) = 0;
+                    *(u8*)((u8*)(&gBattleStruct->choicedMove[gEffectBattler]) + 1) = 0;
                 }
                 else
                 {
@@ -3088,20 +2952,20 @@ static void atk15_seteffectwithchance(void)
 {
     u32 percentChance;
 
-    if (gBattleMons[gBankAttacker].ability == ABILITY_SERENE_GRACE)
+    if (gBattleMons[gBattlerAttacker].ability == ABILITY_SERENE_GRACE)
         percentChance = gBattleMoves[gCurrentMove].secondaryEffectChance * 2;
     else
         percentChance = gBattleMoves[gCurrentMove].secondaryEffectChance;
 
     if (gBattleCommunication[MOVE_EFFECT_BYTE] & MOVE_EFFECT_CERTAIN
-        && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+        && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
         gBattleCommunication[MOVE_EFFECT_BYTE] &= ~(MOVE_EFFECT_CERTAIN);
         SetMoveEffect(0, MOVE_EFFECT_CERTAIN);
     }
     else if (Random() % 100 < percentChance
              && gBattleCommunication[MOVE_EFFECT_BYTE]
-             && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+             && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
     {
         if (percentChance >= 100)
             SetMoveEffect(0, MOVE_EFFECT_CERTAIN);
@@ -3114,7 +2978,7 @@ static void atk15_seteffectwithchance(void)
     }
 
     gBattleCommunication[MOVE_EFFECT_BYTE] = 0;
-    gBattleScripting.field_16 = 0;
+    gBattleScripting.multihitMoveEffect = 0;
 }
 
 static void atk16_seteffectprimary(void)
@@ -3127,34 +2991,34 @@ static void atk17_seteffectsecondary(void)
     SetMoveEffect(FALSE, 0);
 }
 
-static void atk18_status_effect_clear(void)
+static void atk18_clearstatusfromeffect(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
     if (gBattleCommunication[MOVE_EFFECT_BYTE] <= MOVE_EFFECT_TOXIC)
-        gBattleMons[gActiveBank].status1 &= (~sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]]);
+        gBattleMons[gActiveBattler].status1 &= (~sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]]);
     else
-        gBattleMons[gActiveBank].status2 &= (~sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]]);
+        gBattleMons[gActiveBattler].status2 &= (~sStatusFlagsForMoveEffects[gBattleCommunication[MOVE_EFFECT_BYTE]]);
 
     gBattleCommunication[MOVE_EFFECT_BYTE] = 0;
     gBattlescriptCurrInstr += 2;
-    gBattleScripting.field_16 = 0;
+    gBattleScripting.multihitMoveEffect = 0;
 }
 
-static void atk19_faint_pokemon(void)
+static void atk19_tryfaintmon(void)
 {
     const u8 *BS_ptr;
 
     if (gBattlescriptCurrInstr[2] != 0)
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        if (gHitMarker & HITMARKER_FAINTED(gActiveBank))
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        if (gHitMarker & HITMARKER_FAINTED(gActiveBattler))
         {
             BS_ptr = BSScriptReadPtr(gBattlescriptCurrInstr + 3);
 
             BattleScriptPop();
             gBattlescriptCurrInstr = BS_ptr;
-            gSideAffecting[GetBankSide(gActiveBank)] &= ~(SIDE_STATUS_SPIKES_DAMAGED);
+            gSideStatuses[GetBattlerSide(gActiveBattler)] &= ~(SIDE_STATUS_SPIKES_DAMAGED);
         }
         else
         {
@@ -3163,62 +3027,62 @@ static void atk19_faint_pokemon(void)
     }
     else
     {
-        u8 bank;
+        u8 battlerId;
 
-        if (gBattlescriptCurrInstr[1] == BS_GET_ATTACKER)
+        if (gBattlescriptCurrInstr[1] == BS_ATTACKER)
         {
-            gActiveBank = gBankAttacker;
-            bank = gBankTarget;
+            gActiveBattler = gBattlerAttacker;
+            battlerId = gBattlerTarget;
             BS_ptr = BattleScript_FaintAttacker;
         }
         else
         {
-            gActiveBank = gBankTarget;
-            bank = gBankAttacker;
+            gActiveBattler = gBattlerTarget;
+            battlerId = gBattlerAttacker;
             BS_ptr = BattleScript_FaintTarget;
         }
-        if (!(gAbsentBankFlags & gBitTable[gActiveBank])
-         && gBattleMons[gActiveBank].hp == 0)
+        if (!(gAbsentBattlerFlags & gBitTable[gActiveBattler])
+         && gBattleMons[gActiveBattler].hp == 0)
         {
-            gHitMarker |= HITMARKER_FAINTED(gActiveBank);
+            gHitMarker |= HITMARKER_FAINTED(gActiveBattler);
             BattleScriptPush(gBattlescriptCurrInstr + 7);
             gBattlescriptCurrInstr = BS_ptr;
-            if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+            if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
             {
                 gHitMarker |= HITMARKER_x400000;
                 if (gBattleResults.playerFaintCounter < 0xFF)
                     gBattleResults.playerFaintCounter++;
-                AdjustFriendshipOnBattleFaint(gActiveBank);
+                AdjustFriendshipOnBattleFaint(gActiveBattler);
             }
             else
             {
                 if (gBattleResults.opponentFaintCounter < 0xFF)
                     gBattleResults.opponentFaintCounter++;
-                gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES, NULL);
+                gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES, NULL);
             }
-            if ((gHitMarker & HITMARKER_DESTINYBOND) && gBattleMons[gBankAttacker].hp != 0)
+            if ((gHitMarker & HITMARKER_DESTINYBOND) && gBattleMons[gBattlerAttacker].hp != 0)
             {
                 gHitMarker &= ~(HITMARKER_DESTINYBOND);
                 BattleScriptPush(gBattlescriptCurrInstr);
-                gBattleMoveDamage = gBattleMons[bank].hp;
+                gBattleMoveDamage = gBattleMons[battlerId].hp;
                 gBattlescriptCurrInstr = BattleScript_DestinyBondTakesLife;
             }
-            if ((gStatuses3[gBankTarget] & STATUS3_GRUDGE)
+            if ((gStatuses3[gBattlerTarget] & STATUS3_GRUDGE)
              && !(gHitMarker & HITMARKER_GRUDGE)
-             && GetBankSide(gBankAttacker) != GetBankSide(gBankTarget)
-             && gBattleMons[gBankAttacker].hp != 0
+             && GetBattlerSide(gBattlerAttacker) != GetBattlerSide(gBattlerTarget)
+             && gBattleMons[gBattlerAttacker].hp != 0
              && gCurrentMove != MOVE_STRUGGLE)
             {
-                u8 moveIndex = *(gBattleStruct->chosenMovePositions + gBankAttacker);
+                u8 moveIndex = *(gBattleStruct->chosenMovePositions + gBattlerAttacker);
 
-                gBattleMons[gBankAttacker].pp[moveIndex] = 0;
+                gBattleMons[gBattlerAttacker].pp[moveIndex] = 0;
                 BattleScriptPush(gBattlescriptCurrInstr);
                 gBattlescriptCurrInstr = BattleScript_GrudgeTakesPp;
-                gActiveBank = gBankAttacker;
-                EmitSetMonData(0, moveIndex + REQUEST_PPMOVE1_BATTLE, 0, 1, &gBattleMons[gActiveBank].pp[moveIndex]);
-                MarkBufferBankForExecution(gActiveBank);
+                gActiveBattler = gBattlerAttacker;
+                BtlController_EmitSetMonData(0, moveIndex + REQUEST_PPMOVE1_BATTLE, 0, 1, &gBattleMons[gActiveBattler].pp[moveIndex]);
+                MarkBattlerForControllerExec(gActiveBattler);
 
-                PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleMons[gBankAttacker].moves[moveIndex])
+                PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerAttacker].moves[moveIndex])
             }
         }
         else
@@ -3228,28 +3092,28 @@ static void atk19_faint_pokemon(void)
     }
 }
 
-static void atk1A_faint_animation(void)
+static void atk1A_dofaintanimation(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        EmitFaintAnimation(0);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        BtlController_EmitFaintAnimation(0);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 2;
     }
 }
 
-static void atk1B_faint_effects_clear(void)
+static void atk1B_cleareffectsonfaint(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-        if (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || gBattleMons[gActiveBank].hp == 0)
+        if (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || gBattleMons[gActiveBattler].hp == 0)
         {
-            gBattleMons[gActiveBank].status1 = 0;
-            EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 0x4, &gBattleMons[gActiveBank].status1);
-            MarkBufferBankForExecution(gActiveBank);
+            gBattleMons[gActiveBattler].status1 = 0;
+            BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 0x4, &gBattleMons[gActiveBattler].status1);
+            MarkBattlerForControllerExec(gActiveBattler);
         }
 
         FaintClearSetData(); // Effects like attractions, trapping, etc.
@@ -3259,11 +3123,11 @@ static void atk1B_faint_effects_clear(void)
 
 static void atk1C_jumpifstatus(void)
 {
-    u8 bank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     u32 flags = BS2ScriptRead32(gBattlescriptCurrInstr + 2);
     const u8* jumpPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 6);
 
-    if (gBattleMons[bank].status1 & flags && gBattleMons[bank].hp)
+    if (gBattleMons[battlerId].status1 & flags && gBattleMons[battlerId].hp)
         gBattlescriptCurrInstr = jumpPtr;
     else
         gBattlescriptCurrInstr += 10;
@@ -3271,11 +3135,11 @@ static void atk1C_jumpifstatus(void)
 
 static void atk1D_jumpifstatus2(void)
 {
-    u8 bank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     u32 flags = BS2ScriptRead32(gBattlescriptCurrInstr + 2);
     const u8* jumpPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 6);
 
-    if (gBattleMons[bank].status2 & flags && gBattleMons[bank].hp)
+    if (gBattleMons[battlerId].status2 & flags && gBattleMons[battlerId].hp)
         gBattlescriptCurrInstr = jumpPtr;
     else
         gBattlescriptCurrInstr += 10;
@@ -3283,45 +3147,45 @@ static void atk1D_jumpifstatus2(void)
 
 static void atk1E_jumpifability(void)
 {
-    u8 bank;
+    u8 battlerId;
     u8 ability = gBattlescriptCurrInstr[2];
     const u8* jumpPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 3);
 
-    if (gBattlescriptCurrInstr[1] == BS_GET_ATTACKER_SIDE)
+    if (gBattlescriptCurrInstr[1] == BS_ATTACKER_SIDE)
     {
-        bank = AbilityBattleEffects(ABILITYEFFECT_CHECK_BANK_SIDE, gBankAttacker, ability, 0, 0);
-        if (bank)
+        battlerId = AbilityBattleEffects(ABILITYEFFECT_CHECK_BANK_SIDE, gBattlerAttacker, ability, 0, 0);
+        if (battlerId)
         {
             gLastUsedAbility = ability;
             gBattlescriptCurrInstr = jumpPtr;
-            RecordAbilityBattle(bank - 1, gLastUsedAbility);
-            gBattleScripting.field_15 = bank - 1;
+            RecordAbilityBattle(battlerId - 1, gLastUsedAbility);
+            gBattleScripting.battlerWithAbility = battlerId - 1;
         }
         else
             gBattlescriptCurrInstr += 7;
     }
-    else if (gBattlescriptCurrInstr[1] == BS_GET_NOT_ATTACKER_SIDE)
+    else if (gBattlescriptCurrInstr[1] == BS_NOT_ATTACKER_SIDE)
     {
-        bank = AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gBankAttacker, ability, 0, 0);
-        if (bank)
+        battlerId = AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gBattlerAttacker, ability, 0, 0);
+        if (battlerId)
         {
             gLastUsedAbility = ability;
             gBattlescriptCurrInstr = jumpPtr;
-            RecordAbilityBattle(bank - 1, gLastUsedAbility);
-            gBattleScripting.field_15 = bank - 1;
+            RecordAbilityBattle(battlerId - 1, gLastUsedAbility);
+            gBattleScripting.battlerWithAbility = battlerId - 1;
         }
         else
             gBattlescriptCurrInstr += 7;
     }
     else
     {
-        bank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        if (gBattleMons[bank].ability == ability)
+        battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        if (gBattleMons[battlerId].ability == ability)
         {
             gLastUsedAbility = ability;
             gBattlescriptCurrInstr = jumpPtr;
-            RecordAbilityBattle(bank, gLastUsedAbility);
-            gBattleScripting.field_15 = bank;
+            RecordAbilityBattle(battlerId, gLastUsedAbility);
+            gBattleScripting.battlerWithAbility = battlerId;
         }
         else
             gBattlescriptCurrInstr += 7;
@@ -3334,15 +3198,15 @@ static void atk1F_jumpifsideaffecting(void)
     u16 flags;
     const u8* jumpPtr;
 
-    if (gBattlescriptCurrInstr[1] == BS_GET_ATTACKER)
-        side = GET_BANK_SIDE(gBankAttacker);
+    if (gBattlescriptCurrInstr[1] == BS_ATTACKER)
+        side = GET_BATTLER_SIDE(gBattlerAttacker);
     else
-        side = GET_BANK_SIDE(gBankTarget);
+        side = GET_BATTLER_SIDE(gBattlerTarget);
 
     flags = BS2ScriptRead16(gBattlescriptCurrInstr + 2);
     jumpPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 4);
 
-    if (gSideAffecting[side] & flags)
+    if (gSideStatuses[side] & flags)
         gBattlescriptCurrInstr = jumpPtr;
     else
         gBattlescriptCurrInstr += 8;
@@ -3351,8 +3215,8 @@ static void atk1F_jumpifsideaffecting(void)
 static void atk20_jumpifstat(void)
 {
     u8 ret = 0;
-    u8 bank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    u8 value = gBattleMons[bank].statStages[gBattlescriptCurrInstr[3]];
+    u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    u8 value = gBattleMons[battlerId].statStages[gBattlescriptCurrInstr[3]];
 
     switch (gBattlescriptCurrInstr[2])
     {
@@ -3388,25 +3252,25 @@ static void atk20_jumpifstat(void)
         gBattlescriptCurrInstr += 9;
 }
 
-static void atk21_jumpifstatus3(void)
+static void atk21_jumpifstatus3condition(void)
 {
     u32 flags;
-    const u8* jumpPtr;
+    const u8 *jumpPtr;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     flags = BS2ScriptRead32(gBattlescriptCurrInstr + 2);
     jumpPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 7);
 
     if (gBattlescriptCurrInstr[6])
     {
-        if ((gStatuses3[gActiveBank] & flags) != 0)
+        if ((gStatuses3[gActiveBattler] & flags) != 0)
             gBattlescriptCurrInstr += 11;
         else
             gBattlescriptCurrInstr = jumpPtr;
     }
     else
     {
-        if ((gStatuses3[gActiveBank] & flags) != 0)
+        if ((gStatuses3[gActiveBattler] & flags) != 0)
             gBattlescriptCurrInstr = jumpPtr;
         else
             gBattlescriptCurrInstr += 11;
@@ -3415,11 +3279,11 @@ static void atk21_jumpifstatus3(void)
 
 static void atk22_jumpiftype(void)
 {
-    u8 bank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     u8 type = gBattlescriptCurrInstr[2];
     const u8* jumpPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 3);
 
-    if (gBattleMons[bank].type1 == type || gBattleMons[bank].type2 == type)
+    if (gBattleMons[battlerId].type1 == type || gBattleMons[battlerId].type2 == type)
         gBattlescriptCurrInstr = jumpPtr;
     else
         gBattlescriptCurrInstr += 7;
@@ -3435,13 +3299,13 @@ static void atk23_getexp(void)
     s32 viaExpShare = 0;
     u16* exp = &gBattleStruct->expValue;
 
-    gBank1 = GetBattleBank(gBattlescriptCurrInstr[1]);
-    sentIn = gSentPokesToOpponent[(gBank1 & 2) >> 1];
+    gBattlerFainted = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    sentIn = gSentPokesToOpponent[(gBattlerFainted & 2) >> 1];
 
     switch (gBattleScripting.atk23_state)
     {
     case 0: // check if should receive exp at all
-        if (GetBankSide(gBank1) != SIDE_OPPONENT || (gBattleTypeFlags &
+        if (GetBattlerSide(gBattlerFainted) != B_SIDE_OPPONENT || (gBattleTypeFlags &
              (BATTLE_TYPE_LINK
               | BATTLE_TYPE_x2000000
               | BATTLE_TYPE_x4000000
@@ -3455,7 +3319,7 @@ static void atk23_getexp(void)
         else
         {
             gBattleScripting.atk23_state++;
-            gBattleStruct->field_DF |= gBitTable[gBattlePartyID[gBank1]];
+            gBattleStruct->field_DF |= gBitTable[gBattlerPartyIndexes[gBattlerFainted]];
         }
         break;
     case 1: // calculate experience points to redistribute
@@ -3481,7 +3345,7 @@ static void atk23_getexp(void)
                     viaExpShare++;
             }
 
-            calculatedExp = gBaseStats[gBattleMons[gBank1].species].expYield * gBattleMons[gBank1].level / 7;
+            calculatedExp = gBaseStats[gBattleMons[gBattlerFainted].species].expYield * gBattleMons[gBattlerFainted].level / 7;
 
             if (viaExpShare) // at least one mon is getting exp via exp share
             {
@@ -3502,14 +3366,14 @@ static void atk23_getexp(void)
             }
 
             gBattleScripting.atk23_state++;
-            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 (gBattleExecBuffer == 0)
+        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 = gSaveBlock1Ptr->enigmaBerry.holdEffect;
@@ -3522,7 +3386,7 @@ static void atk23_getexp(void)
                 gBattleScripting.atk23_state = 5;
                 gBattleMoveDamage = 0; // used for exp
             }
-            else if (GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_LEVEL) == MAX_MON_LEVEL)
+            else if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) == MAX_MON_LEVEL)
             {
                 *(&gBattleStruct->sentInPokes) >>= 1;
                 gBattleScripting.atk23_state = 5;
@@ -3533,12 +3397,12 @@ static void atk23_getexp(void)
                 // music change in wild battle after fainting a poke
                 if (!(gBattleTypeFlags & BATTLE_TYPE_TRAINER) && gBattleMons[0].hp && !gBattleStruct->wildVictorySong)
                 {
-                    BattleMusicStop();
+                    BattleStopLowHpSound();
                     PlayBGM(0x161);
                     gBattleStruct->wildVictorySong++;
                 }
 
-                if (GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_HP))
+                if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP))
                 {
                     if (gBattleStruct->sentInPokes & 1)
                         gBattleMoveDamage = *exp;
@@ -3552,10 +3416,10 @@ static void atk23_getexp(void)
                     if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
                         gBattleMoveDamage = (gBattleMoveDamage * 150) / 100;
 
-                    if (IsTradedMon(&gPlayerParty[gBattleStruct->expGetterId]))
+                    if (IsTradedMon(&gPlayerParty[gBattleStruct->expGetterMonId]))
                     {
                         // check if the pokemon doesn't belong to the player
-                        if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gBattleStruct->expGetterId >= 3)
+                        if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gBattleStruct->expGetterMonId >= 3)
                         {
                             i = 0x149;
                         }
@@ -3570,31 +3434,31 @@ static void atk23_getexp(void)
                         i = 0x149;
                     }
 
-                    // get exp getter bank
+                    // get exp getter battlerId
                     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
                     {
-                        if (!(gBattlePartyID[2] != gBattleStruct->expGetterId) && !(gAbsentBankFlags & gBitTable[2]))
-                            gBattleStruct->expGetterBank = 2;
+                        if (!(gBattlerPartyIndexes[2] != gBattleStruct->expGetterMonId) && !(gAbsentBattlerFlags & gBitTable[2]))
+                            gBattleStruct->expGetterBattlerId = 2;
                         else
                         {
-                            if (!(gAbsentBankFlags & gBitTable[0]))
-                                gBattleStruct->expGetterBank = 0;
+                            if (!(gAbsentBattlerFlags & gBitTable[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[gBattlerFainted].species);
                 }
                 gBattleStruct->sentInPokes >>= 1;
                 gBattleScripting.atk23_state++;
@@ -3602,72 +3466,72 @@ static void atk23_getexp(void)
         }
         break;
     case 3: // Set stats and give exp
-        if (gBattleExecBuffer == 0)
+        if (gBattleControllerExecFlags == 0)
         {
-            gBattleBufferB[gBattleStruct->expGetterBank][0] = 0;
-            if (GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_HP) && GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_LEVEL) != MAX_MON_LEVEL)
+            gBattleBufferB[gBattleStruct->expGetterBattlerId][0] = 0;
+            if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP) && GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) != MAX_MON_LEVEL)
             {
-                BATTLE_LVLUP_STATS->hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_MAX_HP);
-                BATTLE_LVLUP_STATS->atk = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_ATK);
-                BATTLE_LVLUP_STATS->def = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_DEF);
-                BATTLE_LVLUP_STATS->spd = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_SPEED);
-                BATTLE_LVLUP_STATS->spAtk = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_SPATK);
-                BATTLE_LVLUP_STATS->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);
 
-                gActiveBank = gBattleStruct->expGetterBank;
-                EmitExpUpdate(0, gBattleStruct->expGetterId, gBattleMoveDamage);
-                MarkBufferBankForExecution(gActiveBank);
+                gActiveBattler = gBattleStruct->expGetterBattlerId;
+                BtlController_EmitExpUpdate(0, gBattleStruct->expGetterMonId, gBattleMoveDamage);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
             gBattleScripting.atk23_state++;
         }
         break;
     case 4: // lvl up if necessary
-        if (gBattleExecBuffer == 0)
+        if (gBattleControllerExecFlags == 0)
         {
-            gActiveBank = gBattleStruct->expGetterBank;
-            if (gBattleBufferB[gActiveBank][0] == CONTROLLER_TWORETURNVALUES && gBattleBufferB[gActiveBank][1] == RET_VALUE_LEVELLED_UP)
+            gActiveBattler = gBattleStruct->expGetterBattlerId;
+            if (gBattleBufferB[gActiveBattler][0] == CONTROLLER_TWORETURNVALUES && gBattleBufferB[gActiveBattler][1] == RET_VALUE_LEVELLED_UP)
             {
-                if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gBattlePartyID[gActiveBank] == gBattleStruct->expGetterId)
-                    sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank);
+                if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterMonId)
+                    HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
 
-                PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gActiveBank, 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[gActiveBank][2] | (gBattleBufferB[gActiveBank][3] << 8));
-                AdjustFriendship(&gPlayerParty[gBattleStruct->expGetterId], 0);
+                gBattleMoveDamage = (gBattleBufferB[gActiveBattler][2] | (gBattleBufferB[gActiveBattler][3] << 8));
+                AdjustFriendship(&gPlayerParty[gBattleStruct->expGetterMonId], 0);
 
                 // update battle mon structure after level up
-                if (gBattlePartyID[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].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
+                    gBattleMons[0].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], 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].spAttack = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPATK);
+                    gBattleMons[0].spDefense = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPDEF);
                 }
                 // What is else if?
-                if (gBattlePartyID[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].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
+                    gBattleMons[2].speed = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPEED);
 
-                    gBattleMons[2].spAttack = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_SPATK);
+                    gBattleMons[2].spAttack = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPATK);
                 }
                 gBattleScripting.atk23_state = 5;
             }
@@ -3683,19 +3547,19 @@ static void atk23_getexp(void)
             gBattleScripting.atk23_state = 3;
         else
         {
-            gBattleStruct->expGetterId++;
-            if (gBattleStruct->expGetterId <= 5)
+            gBattleStruct->expGetterMonId++;
+            if (gBattleStruct->expGetterMonId <= 5)
                 gBattleScripting.atk23_state = 2; // loop again
             else
                 gBattleScripting.atk23_state = 6; // we're done
         }
         break;
     case 6: // increment instruction
-        if (gBattleExecBuffer == 0)
+        if (gBattleControllerExecFlags == 0)
         {
             // not sure why gf clears the item and ability here
-            gBattleMons[gBank1].item = 0;
-            gBattleMons[gBank1].ability = 0;
+            gBattleMons[gBattlerFainted].item = 0;
+            gBattleMons[gBattlerFainted].ability = 0;
             gBattlescriptCurrInstr += 2;
         }
         break;
@@ -3708,7 +3572,7 @@ static void atk24(void)
     u16 HP_count = 0;
     s32 i;
 
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
     if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gPartnerTrainerId == STEVEN_PARTNER_ID)
@@ -3724,7 +3588,7 @@ static void atk24(void)
         for (i = 0; i < 6; i++)
         {
             if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)
-                && (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || !(gBattleStruct->field_2A0 & gBitTable[i])))
+             && (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || !(gBattleStruct->field_2A0 & gBitTable[i])))
             {
                 HP_count += GetMonData(&gPlayerParty[i], MON_DATA_HP);
             }
@@ -3732,7 +3596,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++)
     {
@@ -3744,7 +3608,7 @@ static void atk24(void)
     }
 
     if (HP_count == 0)
-        gBattleOutcome |= BATTLE_WON;
+        gBattleOutcome |= B_OUTCOME_WON;
 
     if (gBattleOutcome == 0 && (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_x2000000)))
     {
@@ -3752,13 +3616,13 @@ static void atk24(void)
         s32 foundOpponent;
 
         // Impossible to decompile loops.
-        for (foundPlayer = 0, i = 0; i < gNoOfAllBanks; i += 2)
+        for (foundPlayer = 0, i = 0; i < gBattlersCount; i += 2)
         {
             if (HITMARKER_UNK(i) & gHitMarker && !gSpecialStatuses[i].flag40)
                 foundPlayer++;
         }
 
-        for (foundOpponent = 0, i = 1; i < gNoOfAllBanks; i += 2)
+        for (foundOpponent = 0, i = 1; i < gBattlersCount; i += 2)
         {
             if (HITMARKER_UNK(i) & gHitMarker && !gSpecialStatuses[i].flag40)
                 foundOpponent++;
@@ -3794,7 +3658,7 @@ static void atk24(void)
         mov r7, r8\n\
         push {r7}\n\
         movs r6, 0\n\
-        ldr r0, =gBattleExecBuffer\n\
+        ldr r0, =gBattleControllerExecFlags\n\
         ldr r0, [r0]\n\
         cmp r0, 0\n\
         beq _0804ACE2\n\
@@ -3967,7 +3831,7 @@ static void atk24(void)
         beq _0804AF1A\n\
         movs r3, 0\n\
         movs r5, 0\n\
-        ldr r0, =gNoOfAllBanks\n\
+        ldr r0, =gBattlersCount\n\
         ldrb r1, [r0]\n\
         mov r12, r0\n\
         ldr r7, =gBattlescriptCurrInstr\n\
@@ -4082,7 +3946,7 @@ static void atk24(void)
 
 static void MoveValuesCleanUp(void)
 {
-    gBattleMoveFlags = 0;
+    gMoveResultFlags = 0;
     gBattleScripting.dmgMultiplier = 1;
     gCritMultiplier = 1;
     gBattleCommunication[MOVE_EFFECT_BYTE] = 0;
@@ -4091,19 +3955,19 @@ static void MoveValuesCleanUp(void)
     gHitMarker &= ~(HITMARKER_SYNCHRONISE_EFFECT);
 }
 
-static void atk25_move_values_cleanup(void)
+static void atk25_movevaluescleanup(void)
 {
     MoveValuesCleanUp();
     gBattlescriptCurrInstr += 1;
 }
 
-static void atk26_set_multihit(void)
+static void atk26_setmultihit(void)
 {
     gMultiHitCounter = gBattlescriptCurrInstr[1];
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk27_decrement_multihit(void)
+static void atk27_decrementmultihit(void)
 {
     if (--gMultiHitCounter == 0)
         gBattlescriptCurrInstr += 5;
@@ -4313,7 +4177,7 @@ static void atk31_copyarray(void)
     gBattlescriptCurrInstr += 10;
 }
 
-static void atk32_copyarray_withindex(void)
+static void atk32_copyarraywithindex(void)
 {
     u8* dest = BS2ScriptReadPtr(gBattlescriptCurrInstr + 1);
     const u8* src = BS2ScriptReadPtr(gBattlescriptCurrInstr + 5);
@@ -4381,7 +4245,7 @@ static void atk38_bicword(void)
 
 static void atk39_pause(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
         u16 value = BS2ScriptRead16(gBattlescriptCurrInstr + 1);
         if (++gPauseCounterBattle >= value)
@@ -4394,19 +4258,19 @@ static void atk39_pause(void)
 
 static void atk3A_waitstate(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
         gBattlescriptCurrInstr++;
 }
 
 static void atk3B_healthbar_update(void)
 {
-    if (gBattlescriptCurrInstr[1] == BS_GET_TARGET)
-        gActiveBank = gBankTarget;
+    if (gBattlescriptCurrInstr[1] == BS_TARGET)
+        gActiveBattler = gBattlerTarget;
     else
-        gActiveBank = gBankAttacker;
+        gActiveBattler = gBattlerAttacker;
 
-    EmitHealthBarUpdate(0, gBattleMoveDamage);
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitHealthBarUpdate(0, gBattleMoveDamage);
+    MarkBattlerForControllerExec(gActiveBattler);
     gBattlescriptCurrInstr += 2;
 }
 
@@ -4418,25 +4282,25 @@ static void atk3C_return(void)
 static void atk3D_end(void)
 {
     if (gBattleTypeFlags & BATTLE_TYPE_ARENA)
-        sub_81A5718(gBankAttacker);
+        sub_81A5718(gBattlerAttacker);
 
-    gBattleMoveFlags = 0;
-    gActiveBank = 0;
+    gMoveResultFlags = 0;
+    gActiveBattler = 0;
     gCurrentActionFuncId = 0xB;
 }
 
 static void atk3E_end2(void)
 {
-    gActiveBank = 0;
+    gActiveBattler = 0;
     gCurrentActionFuncId = 0xB;
 }
 
 static void atk3F_end3(void) // pops the main function stack
 {
     BattleScriptPop();
-    if (BATTLE_CALLBACKS_STACK->size)
-        BATTLE_CALLBACKS_STACK->size--;
-    gBattleMainFunc = BATTLE_CALLBACKS_STACK->function[BATTLE_CALLBACKS_STACK->size];
+    if (gBattleResources->battleCallbackStack->size != 0)
+        gBattleResources->battleCallbackStack->size--;
+    gBattleMainFunc = gBattleResources->battleCallbackStack->function[gBattleResources->battleCallbackStack->size];
 }
 
 static void atk41_call(void)
@@ -4447,9 +4311,9 @@ static void atk41_call(void)
 
 static void atk42_jumpiftype2(void)
 {
-    u8 bank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    if (gBattlescriptCurrInstr[2] == gBattleMons[bank].type1 || gBattlescriptCurrInstr[2] == gBattleMons[bank].type2)
+    if (gBattlescriptCurrInstr[2] == gBattleMons[battlerId].type1 || gBattlescriptCurrInstr[2] == gBattleMons[battlerId].type2)
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 3);
     else
         gBattlescriptCurrInstr += 7;
@@ -4463,24 +4327,24 @@ static void atk43_jumpifabilitypresent(void)
         gBattlescriptCurrInstr += 6;
 }
 
-static void atk44_end_selection_script(void)
+static void atk44_endselectionscript(void)
 {
-    *(gBankAttacker + gBattleStruct->selectionScriptFinished) = TRUE;
+    *(gBattlerAttacker + gBattleStruct->selectionScriptFinished) = TRUE;
 }
 
 static void atk45_playanimation(void)
 {
     const u16* argumentPtr;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     argumentPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 3);
 
     if (gBattlescriptCurrInstr[2] == B_ANIM_STATS_CHANGE
         || gBattlescriptCurrInstr[2] == B_ANIM_SNATCH_MOVE
         || gBattlescriptCurrInstr[2] == B_ANIM_SUBSTITUTE_FADE)
     {
-        EmitBattleAnimation(0, gBattlescriptCurrInstr[2], *argumentPtr);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBattleAnimation(0, gBattlescriptCurrInstr[2], *argumentPtr);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 7;
     }
     else if (gHitMarker & HITMARKER_NO_ANIMATIONS)
@@ -4493,18 +4357,18 @@ static void atk45_playanimation(void)
              || gBattlescriptCurrInstr[2] == B_ANIM_SANDSTORM_CONTINUES
              || gBattlescriptCurrInstr[2] == B_ANIM_HAIL_CONTINUES)
     {
-        EmitBattleAnimation(0, gBattlescriptCurrInstr[2], *argumentPtr);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBattleAnimation(0, gBattlescriptCurrInstr[2], *argumentPtr);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 7;
     }
-    else if (gStatuses3[gActiveBank] & STATUS3_SEMI_INVULNERABLE)
+    else if (gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE)
     {
         gBattlescriptCurrInstr += 7;
     }
     else
     {
-        EmitBattleAnimation(0, gBattlescriptCurrInstr[2], *argumentPtr);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBattleAnimation(0, gBattlescriptCurrInstr[2], *argumentPtr);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 7;
     }
 }
@@ -4514,7 +4378,7 @@ static void atk46_playanimation2(void) // animation Id is stored in the first po
     const u16* argumentPtr;
     const u8* animationIdPtr;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     animationIdPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 2);
     argumentPtr = BS2ScriptReadPtr(gBattlescriptCurrInstr + 6);
 
@@ -4522,8 +4386,8 @@ static void atk46_playanimation2(void) // animation Id is stored in the first po
         || *animationIdPtr == B_ANIM_SNATCH_MOVE
         || *animationIdPtr == B_ANIM_SUBSTITUTE_FADE)
     {
-        EmitBattleAnimation(0, *animationIdPtr, *argumentPtr);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBattleAnimation(0, *animationIdPtr, *argumentPtr);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 10;
     }
     else if (gHitMarker & HITMARKER_NO_ANIMATIONS)
@@ -4535,18 +4399,18 @@ static void atk46_playanimation2(void) // animation Id is stored in the first po
              || *animationIdPtr == B_ANIM_SANDSTORM_CONTINUES
              || *animationIdPtr == B_ANIM_HAIL_CONTINUES)
     {
-        EmitBattleAnimation(0, *animationIdPtr, *argumentPtr);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBattleAnimation(0, *animationIdPtr, *argumentPtr);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 10;
     }
-    else if (gStatuses3[gActiveBank] & STATUS3_SEMI_INVULNERABLE)
+    else if (gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE)
     {
         gBattlescriptCurrInstr += 10;
     }
     else
     {
-        EmitBattleAnimation(0, *animationIdPtr, *argumentPtr);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBattleAnimation(0, *animationIdPtr, *argumentPtr);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 10;
     }
 }
@@ -4583,7 +4447,7 @@ static void atk48_playstatchangeanimation(void)
     s32 changeableStats = 0;
     u32 statsToCheck = 0;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
     statsToCheck = gBattlescriptCurrInstr[2];
 
     if (gBattlescriptCurrInstr[3] & ATK48_STAT_NEGATIVE) // goes down
@@ -4595,19 +4459,19 @@ static void atk48_playstatchangeanimation(void)
             {
                 if (!(gBattlescriptCurrInstr[3] & ATK48_LOWER_FAIL_CHECK))
                 {
-                    if (gBattleMons[gActiveBank].statStages[currStat] > 0)
+                    if (gBattleMons[gActiveBattler].statStages[currStat] > 0)
                     {
                         statAnimId = checkingStatAnimId;
                         changeableStats++;
                     }
                 }
-                else if (!gSideTimers[GET_BANK_SIDE(gActiveBank)].mistTimer
-                        && gBattleMons[gActiveBank].ability != ABILITY_CLEAR_BODY
-                        && gBattleMons[gActiveBank].ability != ABILITY_WHITE_SMOKE
-                        && !(gBattleMons[gActiveBank].ability == ABILITY_KEEN_EYE && currStat == STAT_STAGE_ACC)
-                        && !(gBattleMons[gActiveBank].ability == ABILITY_HYPER_CUTTER && currStat == STAT_STAGE_ATK))
+                else if (!gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].mistTimer
+                        && gBattleMons[gActiveBattler].ability != ABILITY_CLEAR_BODY
+                        && gBattleMons[gActiveBattler].ability != ABILITY_WHITE_SMOKE
+                        && !(gBattleMons[gActiveBattler].ability == ABILITY_KEEN_EYE && currStat == STAT_ACC)
+                        && !(gBattleMons[gActiveBattler].ability == ABILITY_HYPER_CUTTER && currStat == STAT_ATK))
                 {
-                    if (gBattleMons[gActiveBank].statStages[currStat] > 0)
+                    if (gBattleMons[gActiveBattler].statStages[currStat] > 0)
                     {
                         statAnimId = checkingStatAnimId;
                         changeableStats++;
@@ -4630,7 +4494,7 @@ static void atk48_playstatchangeanimation(void)
         checkingStatAnimId = (gBattlescriptCurrInstr[3] & ATK48_STAT_BY_TWO) ? 0x26 : 0xE;
         while (statsToCheck != 0)
         {
-            if (statsToCheck & 1 && gBattleMons[gActiveBank].statStages[currStat] < 0xC)
+            if (statsToCheck & 1 && gBattleMons[gActiveBattler].statStages[currStat] < 0xC)
             {
                 statAnimId = checkingStatAnimId;
                 changeableStats++;
@@ -4653,8 +4517,8 @@ static void atk48_playstatchangeanimation(void)
     }
     else if (changeableStats != 0 && gBattleScripting.field_1B == 0)
     {
-        EmitBattleAnimation(0, B_ANIM_STATS_CHANGE, statAnimId);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBattleAnimation(0, B_ANIM_STATS_CHANGE, statAnimId);
+        MarkBattlerForControllerExec(gActiveBattler);
         if (gBattlescriptCurrInstr[3] & ATK48_BIT_x4 && changeableStats > 1)
             gBattleScripting.field_1B = 1;
         gBattlescriptCurrInstr += 4;
@@ -4684,8 +4548,8 @@ static void atk48_playstatchangeanimation(void)
 	ldr r0, [r5]\n\
 	ldrb r0, [r0, 0x1]\n\
 	str r3, [sp]\n\
-	bl GetBattleBank\n\
-	ldr r2, =gActiveBank\n\
+	bl GetBattlerForBattleScript\n\
+	ldr r2, =gActiveBattler\n\
 	strb r0, [r2]\n\
 	ldr r0, [r5]\n\
 	ldrb r4, [r0, 0x2]\n\
@@ -4722,7 +4586,7 @@ _0804BA26:\n\
 	ands r0, r1\n\
 	cmp r0, 0\n\
 	beq _0804BA58\n\
-	ldr r0, =gActiveBank\n\
+	ldr r0, =gActiveBattler\n\
 	ldrb r1, [r0]\n\
 	movs r0, 0x58\n\
 	muls r0, r1\n\
@@ -4730,10 +4594,10 @@ _0804BA26:\n\
 	b _0804BAA0\n\
 	.pool\n\
 _0804BA58:\n\
-	ldr r6, =gActiveBank\n\
+	ldr r6, =gActiveBattler\n\
 	ldrb r0, [r6]\n\
 	str r3, [sp]\n\
-	bl GetBankIdentity\n\
+	bl GetBattlerPosition\n\
 	mov r1, r10\n\
 	ands r1, r0\n\
 	lsls r0, r1, 1\n\
@@ -4881,10 +4745,10 @@ _0804BB6C:\n\
 	movs r1, 0x1\n\
 	mov r2, r8\n\
 	str r3, [sp]\n\
-	bl EmitBattleAnimation\n\
-	ldr r0, =gActiveBank\n\
+	bl BtlController_EmitBattleAnimation\n\
+	ldr r0, =gActiveBattler\n\
 	ldrb r0, [r0]\n\
-	bl MarkBufferBankForExecution\n\
+	bl MarkBattlerForControllerExec\n\
 	ldr r0, =gBattlescriptCurrInstr\n\
 	ldr r0, [r0]\n\
 	ldrb r1, [r0, 0x3]\n\
@@ -4930,25 +4794,24 @@ static void atk49_moveend(void)
     u8 holdEffectAtk;
     u16 *choicedMoveAtk;
     u8 arg1, arg2;
-    u16 lastMove;
+    u16 originallyUsedMove;
 
     effect = FALSE;
 
-    if (gLastUsedMove == 0xFFFF)
-        lastMove = 0;
+    if (gChosenMove == 0xFFFF)
+        originallyUsedMove = 0;
     else
-        lastMove = gLastUsedMove;
+        originallyUsedMove = gChosenMove;
 
     arg1 = gBattlescriptCurrInstr[1];
     arg2 = gBattlescriptCurrInstr[2];
 
-    if (gBattleMons[gBankAttacker].item == ITEM_ENIGMA_BERRY)
-        holdEffectAtk = gEnigmaBerries[gBankAttacker].holdEffect;
+    if (gBattleMons[gBattlerAttacker].item == ITEM_ENIGMA_BERRY)
+        holdEffectAtk = gEnigmaBerries[gBattlerAttacker].holdEffect;
     else
-        holdEffectAtk = ItemId_GetHoldEffect(gBattleMons[gBankAttacker].item);
-
-    choicedMoveAtk = &gBattleStruct->choicedMove[gBankAttacker];
+        holdEffectAtk = ItemId_GetHoldEffect(gBattleMons[gBattlerAttacker].item);
 
+    choicedMoveAtk = &gBattleStruct->choicedMove[gBattlerAttacker];
     GET_MOVE_TYPE(gCurrentMove, moveType);
 
     do
@@ -4956,13 +4819,13 @@ static void atk49_moveend(void)
         switch (gBattleScripting.atk49_state)
         {
         case 0: // rage check
-            if (gBattleMons[gBankTarget].status2 & STATUS2_RAGE
-                && gBattleMons[gBankTarget].hp != 0 && gBankAttacker != gBankTarget
-                && GetBankSide(gBankAttacker) != GetBankSide(gBankTarget)
-                && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT) && TARGET_TURN_DAMAGED
-                && gBattleMoves[gCurrentMove].power && gBattleMons[gBankTarget].statStages[STAT_STAGE_ATK] <= 0xB)
+            if (gBattleMons[gBattlerTarget].status2 & STATUS2_RAGE
+                && gBattleMons[gBattlerTarget].hp != 0 && gBattlerAttacker != gBattlerTarget
+                && GetBattlerSide(gBattlerAttacker) != GetBattlerSide(gBattlerTarget)
+                && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT) && TARGET_TURN_DAMAGED
+                && gBattleMoves[gCurrentMove].power && gBattleMons[gBattlerTarget].statStages[STAT_ATK] <= 0xB)
             {
-                gBattleMons[gBankTarget].statStages[STAT_STAGE_ATK]++;
+                gBattleMons[gBattlerTarget].statStages[STAT_ATK]++;
                 BattleScriptPushCursor();
                 gBattlescriptCurrInstr = BattleScript_RageIsBuilding;
                 effect = TRUE;
@@ -4970,15 +4833,15 @@ static void atk49_moveend(void)
             gBattleScripting.atk49_state++;
             break;
         case 1: // defrosting check
-            if (gBattleMons[gBankTarget].status1 & STATUS_FREEZE
-                && gBattleMons[gBankTarget].hp != 0 && gBankAttacker != gBankTarget
-                && gSpecialStatuses[gBankTarget].moveturnLostHP_special
-                && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT) && moveType == TYPE_FIRE)
-            {
-                gBattleMons[gBankTarget].status1 &= ~(STATUS_FREEZE);
-                gActiveBank = gBankTarget;
-                EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBankTarget].status1);
-                MarkBufferBankForExecution(gActiveBank);
+            if (gBattleMons[gBattlerTarget].status1 & STATUS1_FREEZE
+                && gBattleMons[gBattlerTarget].hp != 0 && gBattlerAttacker != gBattlerTarget
+                && gSpecialStatuses[gBattlerTarget].specialDmg
+                && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT) && moveType == TYPE_FIRE)
+            {
+                gBattleMons[gBattlerTarget].status1 &= ~(STATUS1_FREEZE);
+                gActiveBattler = gBattlerTarget;
+                BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerTarget].status1);
+                MarkBattlerForControllerExec(gActiveBattler);
                 BattleScriptPushCursor();
                 gBattlescriptCurrInstr = BattleScript_DefrostedViaFireMove;
                 effect = TRUE;
@@ -4986,41 +4849,41 @@ static void atk49_moveend(void)
             gBattleScripting.atk49_state++;
             break;
         case 2: // target synchronize
-            if (AbilityBattleEffects(ABILITYEFFECT_SYNCHRONIZE, gBankTarget, 0, 0, 0))
+            if (AbilityBattleEffects(ABILITYEFFECT_SYNCHRONIZE, gBattlerTarget, 0, 0, 0))
                 effect = TRUE;
             gBattleScripting.atk49_state++;
             break;
         case 3: // contact abilities
-            if (AbilityBattleEffects(ABILITYEFFECT_CONTACT, gBankTarget, 0, 0, 0))
+            if (AbilityBattleEffects(ABILITYEFFECT_CONTACT, gBattlerTarget, 0, 0, 0))
                 effect = TRUE;
             gBattleScripting.atk49_state++;
             break;
         case 4: // status immunities
             if (AbilityBattleEffects(ABILITYEFFECT_IMMUNITY, 0, 0, 0, 0))
-                effect = TRUE; // it loops through all banks, so we increment after its done with all banks
+                effect = TRUE; // it loops through all battlers, so we increment after its done with all battlers
             else
                 gBattleScripting.atk49_state++;
             break;
         case 5: // attacker synchronize
-            if (AbilityBattleEffects(ABILITYEFFECT_ATK_SYNCHRONIZE, gBankAttacker, 0, 0, 0))
+            if (AbilityBattleEffects(ABILITYEFFECT_ATK_SYNCHRONIZE, gBattlerAttacker, 0, 0, 0))
                 effect = TRUE;
             gBattleScripting.atk49_state++;
             break;
         case 6: // update choice band move
             if (!(gHitMarker & HITMARKER_OBEYS) || holdEffectAtk != HOLD_EFFECT_CHOICE_BAND
-                || gLastUsedMove == MOVE_STRUGGLE || (*choicedMoveAtk != 0 && *choicedMoveAtk != 0xFFFF))
+                || gChosenMove == MOVE_STRUGGLE || (*choicedMoveAtk != 0 && *choicedMoveAtk != 0xFFFF))
                     goto LOOP;
-            if (gLastUsedMove == MOVE_BATON_PASS && !(gBattleMoveFlags & MOVESTATUS_FAILED))
+            if (gChosenMove == MOVE_BATON_PASS && !(gMoveResultFlags & MOVE_RESULT_FAILED))
             {
                 gBattleScripting.atk49_state++;
                 break;
             }
-            *choicedMoveAtk = gLastUsedMove;
+            *choicedMoveAtk = gChosenMove;
             LOOP:
             {
                 for (i = 0; i < 4; i++)
                 {
-                    if (gBattleMons[gBankAttacker].moves[i] == *choicedMoveAtk)
+                    if (gBattleMons[gBattlerAttacker].moves[i] == *choicedMoveAtk)
                         break;
                 }
                 if (i == 4)
@@ -5030,7 +4893,7 @@ static void atk49_moveend(void)
             }
             break;
         case 7: // changed held items
-            for (i = 0; i < gNoOfAllBanks; i++)
+            for (i = 0; i < gBattlersCount; i++)
             {
                 u16* changedItem = &gBattleStruct->changedItems[i];
                 if (*changedItem != 0)
@@ -5041,7 +4904,7 @@ static void atk49_moveend(void)
             }
             gBattleScripting.atk49_state++;
             break;
-        case 11: // item effects for all banks
+        case 11: // item effects for all battlers
             if (ItemBattleEffects(3, 0, FALSE))
                 effect = TRUE;
             else
@@ -5053,47 +4916,47 @@ static void atk49_moveend(void)
             gBattleScripting.atk49_state++;
             break;
         case 8: // make attacker sprite invisible
-            if (gStatuses3[gBankAttacker] & (STATUS3_SEMI_INVULNERABLE)
+            if (gStatuses3[gBattlerAttacker] & (STATUS3_SEMI_INVULNERABLE)
                 && gHitMarker & HITMARKER_NO_ANIMATIONS)
             {
-                gActiveBank = gBankAttacker;
-                EmitSpriteInvisibility(0, TRUE);
-                MarkBufferBankForExecution(gActiveBank);
+                gActiveBattler = gBattlerAttacker;
+                BtlController_EmitSpriteInvisibility(0, TRUE);
+                MarkBattlerForControllerExec(gActiveBattler);
                 gBattleScripting.atk49_state++;
                 return;
             }
             gBattleScripting.atk49_state++;
             break;
         case 9: // make attacker sprite visible
-            if (gBattleMoveFlags & MOVESTATUS_NOEFFECT
-                || !(gStatuses3[gBankAttacker] & (STATUS3_SEMI_INVULNERABLE))
-                || WasUnableToUseMove(gBankAttacker))
-            {
-                gActiveBank = gBankAttacker;
-                EmitSpriteInvisibility(0, FALSE);
-                MarkBufferBankForExecution(gActiveBank);
-                gStatuses3[gBankAttacker] &= ~(STATUS3_SEMI_INVULNERABLE);
-                gSpecialStatuses[gBankAttacker].restoredBankSprite = 1;
+            if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT
+                || !(gStatuses3[gBattlerAttacker] & (STATUS3_SEMI_INVULNERABLE))
+                || WasUnableToUseMove(gBattlerAttacker))
+            {
+                gActiveBattler = gBattlerAttacker;
+                BtlController_EmitSpriteInvisibility(0, FALSE);
+                MarkBattlerForControllerExec(gActiveBattler);
+                gStatuses3[gBattlerAttacker] &= ~(STATUS3_SEMI_INVULNERABLE);
+                gSpecialStatuses[gBattlerAttacker].restoredBankSprite = 1;
                 gBattleScripting.atk49_state++;
                 return;
             }
             gBattleScripting.atk49_state++;
             break;
         case 10: // make target sprite visible
-            if (!gSpecialStatuses[gBankTarget].restoredBankSprite && gBankTarget < gNoOfAllBanks
-                && !(gStatuses3[gBankTarget] & STATUS3_SEMI_INVULNERABLE))
+            if (!gSpecialStatuses[gBattlerTarget].restoredBankSprite && gBattlerTarget < gBattlersCount
+                && !(gStatuses3[gBattlerTarget] & STATUS3_SEMI_INVULNERABLE))
             {
-                gActiveBank = gBankTarget;
-                EmitSpriteInvisibility(0, FALSE);
-                MarkBufferBankForExecution(gActiveBank);
-                gStatuses3[gBankTarget] &= ~(STATUS3_SEMI_INVULNERABLE);
+                gActiveBattler = gBattlerTarget;
+                BtlController_EmitSpriteInvisibility(0, FALSE);
+                MarkBattlerForControllerExec(gActiveBattler);
+                gStatuses3[gBattlerTarget] &= ~(STATUS3_SEMI_INVULNERABLE);
                 gBattleScripting.atk49_state++;
                 return;
             }
             gBattleScripting.atk49_state++;
             break;
         case 13: // update substitute
-            for (i = 0; i < gNoOfAllBanks; i++)
+            for (i = 0; i < gBattlersCount; i++)
             {
                 if (gDisableStructs[i].substituteHP == 0)
                     gBattleMons[i].status2 &= ~(STATUS2_SUBSTITUTE);
@@ -5103,87 +4966,87 @@ static void atk49_moveend(void)
         case 14: // This case looks interesting, although I am not certain what it does. Probably fine tunes edge cases.
             if (gHitMarker & HITMARKER_PURSUIT_TRAP)
             {
-                gActiveBank = gBankAttacker;
-                gBankAttacker = gBankTarget;
-                gBankTarget = gActiveBank;
+                gActiveBattler = gBattlerAttacker;
+                gBattlerAttacker = gBattlerTarget;
+                gBattlerTarget = gActiveBattler;
                 gHitMarker &= ~(HITMARKER_PURSUIT_TRAP);
             }
             if (gHitMarker & HITMARKER_ATTACKSTRING_PRINTED)
             {
-                gUnknownMovesUsedByBanks[gBankAttacker] = gLastUsedMove;
+                gLastPrintedMoves[gBattlerAttacker] = gChosenMove;
             }
-            if (!(gAbsentBankFlags & gBitTable[gBankAttacker])
-                && !(gBattleStruct->field_91 & gBitTable[gBankAttacker])
-                && gBattleMoves[lastMove].effect != EFFECT_BATON_PASS)
+            if (!(gAbsentBattlerFlags & gBitTable[gBattlerAttacker])
+                && !(gBattleStruct->field_91 & gBitTable[gBattlerAttacker])
+                && gBattleMoves[originallyUsedMove].effect != EFFECT_BATON_PASS)
             {
                 if (gHitMarker & HITMARKER_OBEYS)
                 {
-                    gLastUsedMovesByBanks[gBankAttacker] = gLastUsedMove;
-                    gUnknown_02024260[gBankAttacker] = gCurrentMove;
+                    gLastMoves[gBattlerAttacker] = gChosenMove;
+                    gLastResultingMoves[gBattlerAttacker] = gCurrentMove;
                 }
                 else
                 {
-                    gLastUsedMovesByBanks[gBankAttacker] = 0xFFFF;
-                    gUnknown_02024260[gBankAttacker] = 0xFFFF;
+                    gLastMoves[gBattlerAttacker] = 0xFFFF;
+                    gLastResultingMoves[gBattlerAttacker] = 0xFFFF;
                 }
 
-                if (!(gHitMarker & HITMARKER_FAINTED(gBankTarget)))
-                    gUnknown_02024270[gBankTarget] = gBankAttacker;
+                if (!(gHitMarker & HITMARKER_FAINTED(gBattlerTarget)))
+                    gLastHitBy[gBattlerTarget] = gBattlerAttacker;
 
-                if (gHitMarker & HITMARKER_OBEYS && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+                if (gHitMarker & HITMARKER_OBEYS && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
                 {
-                    if (gLastUsedMove == 0xFFFF)
+                    if (gChosenMove == 0xFFFF)
                     {
-                        gUnknown_02024250[gBankTarget] = gLastUsedMove;
+                        gLastLandedMoves[gBattlerTarget] = gChosenMove;
                     }
                     else
                     {
-                        gUnknown_02024250[gBankTarget] = gCurrentMove;
-                        GET_MOVE_TYPE(gCurrentMove, gUnknown_02024258[gBankTarget]);
+                        gLastLandedMoves[gBattlerTarget] = gCurrentMove;
+                        GET_MOVE_TYPE(gCurrentMove, gLastHitByType[gBattlerTarget]);
                     }
                 }
                 else
                 {
-                    gUnknown_02024250[gBankTarget] = 0xFFFF;
+                    gLastLandedMoves[gBattlerTarget] = 0xFFFF;
                 }
             }
             gBattleScripting.atk49_state++;
             break;
         case 15: // mirror move
-            if (!(gAbsentBankFlags & gBitTable[gBankAttacker]) && !(gBattleStruct->field_91 & gBitTable[gBankAttacker])
-                && gBattleMoves[lastMove].flags & FLAG_MIRROR_MOVE_AFFECTED && gHitMarker & HITMARKER_OBEYS
-                && gBankAttacker != gBankTarget && !(gHitMarker & HITMARKER_FAINTED(gBankTarget))
-                && !(gBattleMoveFlags & MOVESTATUS_NOEFFECT))
+            if (!(gAbsentBattlerFlags & gBitTable[gBattlerAttacker]) && !(gBattleStruct->field_91 & gBitTable[gBattlerAttacker])
+                && gBattleMoves[originallyUsedMove].flags & FLAG_MIRROR_MOVE_AFFECTED && gHitMarker & HITMARKER_OBEYS
+                && gBattlerAttacker != gBattlerTarget && !(gHitMarker & HITMARKER_FAINTED(gBattlerTarget))
+                && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT))
             {
                 u8 target, attacker;
 
-                *(gBattleStruct->mirrorMoves + gBankTarget * 2 + 0) = gLastUsedMove;
-                *(gBattleStruct->mirrorMoves + gBankTarget * 2 + 1) = gLastUsedMove >> 8;
+                *(gBattleStruct->mirrorMoves + gBattlerTarget * 2 + 0) = gChosenMove;
+                *(gBattleStruct->mirrorMoves + gBattlerTarget * 2 + 1) = gChosenMove >> 8;
 
-                target = gBankTarget;
-                attacker = gBankAttacker;
-                *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = gLastUsedMove;
+                target = gBattlerTarget;
+                attacker = gBattlerAttacker;
+                *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = gChosenMove;
 
-                target = gBankTarget;
-                attacker = gBankAttacker;
-                *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = gLastUsedMove >> 8;
+                target = gBattlerTarget;
+                attacker = gBattlerAttacker;
+                *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = gChosenMove >> 8;
             }
             gBattleScripting.atk49_state++;
             break;
         case 16: //
             if (!(gHitMarker & HITMARKER_UNABLE_TO_USE_MOVE) && gBattleTypeFlags & BATTLE_TYPE_DOUBLE
-                && !gProtectStructs[gBankAttacker].chargingTurn && gBattleMoves[gCurrentMove].target == MOVE_TARGET_BOTH
+                && !gProtectStructs[gBattlerAttacker].chargingTurn && gBattleMoves[gCurrentMove].target == MOVE_TARGET_BOTH
                 && !(gHitMarker & HITMARKER_NO_ATTACKSTRING))
             {
-                u8 bank = GetBankByIdentity(GetBankIdentity(gBankTarget) ^ BIT_MON);
-                if (gBattleMons[bank].hp != 0)
+                u8 battlerId = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerTarget)));
+                if (gBattleMons[battlerId].hp != 0)
                 {
-                    gBankTarget = bank;
+                    gBattlerTarget = battlerId;
                     gHitMarker |= HITMARKER_NO_ATTACKSTRING;
                     gBattleScripting.atk49_state = 0;
                     MoveValuesCleanUp();
                     BattleScriptPush(gBattleScriptsForMoveEffects[gBattleMoves[gCurrentMove].effect]);
-                    gBattlescriptCurrInstr = gUnknown_082DB87D;
+                    gBattlescriptCurrInstr = BattleScript_82DB87D;
                     return;
                 }
                 else
@@ -5214,21 +5077,21 @@ static void atk4A_typecalc2(void)
     s32 i = 0;
     u8 moveType = gBattleMoves[gCurrentMove].type;
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_LEVITATE && moveType == TYPE_GROUND)
     {
-        gLastUsedAbility = gBattleMons[gBankTarget].ability;
-        gBattleMoveFlags |= (MOVESTATUS_MISSED | MOVESTATUS_NOTAFFECTED);
-        gUnknown_02024250[gBankTarget] = 0;
+        gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
+        gMoveResultFlags |= (MOVE_RESULT_MISSED | MOVE_RESULT_DOESNT_AFFECT_FOE);
+        gLastLandedMoves[gBattlerTarget] = 0;
         gBattleCommunication[6] = moveType;
-        RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+        RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
     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)
             {
-                if (gBattleMons[gBankTarget].status2 & STATUS2_FORESIGHT)
+                if (gBattleMons[gBattlerTarget].status2 & STATUS2_FORESIGHT)
                 {
                     break;
                 }
@@ -5239,45 +5102,45 @@ static void atk4A_typecalc2(void)
                 }
             }
 
-            if (gTypeEffectiveness[i] == moveType)
+            if (TYPE_EFFECT_ATK_TYPE(i) == moveType)
             {
                 // check type1
-                if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type1)
+                if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type1)
                 {
-                    if (gTypeEffectiveness[i + 2] == 0)
+                    if (TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_NO_EFFECT)
                     {
-                        gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
+                        gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
                         break;
                     }
-                    if (gTypeEffectiveness[i + 2] == 5)
+                    if (TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_NOT_EFFECTIVE)
                     {
-                        flags |= MOVESTATUS_NOTVERYEFFECTIVE;
+                        flags |= MOVE_RESULT_NOT_VERY_EFFECTIVE;
                     }
-                    if (gTypeEffectiveness[i + 2] == 20)
+                    if (TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_SUPER_EFFECTIVE)
                     {
-                        flags |= MOVESTATUS_SUPEREFFECTIVE;
+                        flags |= MOVE_RESULT_SUPER_EFFECTIVE;
                     }
                 }
                 // check type2
-                if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2)
+                if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type2)
                 {
-                    if (gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2
-                        && gTypeEffectiveness[i + 2] == 0)
+                    if (gBattleMons[gBattlerTarget].type1 != gBattleMons[gBattlerTarget].type2
+                        && TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_NO_EFFECT)
                     {
-                        gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
+                        gMoveResultFlags |= MOVE_RESULT_DOESNT_AFFECT_FOE;
                         break;
                     }
-                    if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2
-                        && gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2
-                        && gTypeEffectiveness[i + 2] == 5)
+                    if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type2
+                        && gBattleMons[gBattlerTarget].type1 != gBattleMons[gBattlerTarget].type2
+                        && TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_NOT_EFFECTIVE)
                     {
-                        flags |= MOVESTATUS_NOTVERYEFFECTIVE;
+                        flags |= MOVE_RESULT_NOT_VERY_EFFECTIVE;
                     }
-                    if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2
-                        && gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2
-                        && gTypeEffectiveness[i + 2] == 20)
+                    if (TYPE_EFFECT_DEF_TYPE(i) == gBattleMons[gBattlerTarget].type2
+                        && gBattleMons[gBattlerTarget].type1 != gBattleMons[gBattlerTarget].type2
+                        && TYPE_EFFECT_MULTIPLIER(i) == TYPE_MUL_SUPER_EFFECTIVE)
                     {
-                        flags |= MOVESTATUS_SUPEREFFECTIVE;
+                        flags |= MOVE_RESULT_SUPER_EFFECTIVE;
                     }
                 }
             }
@@ -5285,125 +5148,122 @@ static void atk4A_typecalc2(void)
         }
     }
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_WONDER_GUARD
-        && !(flags & MOVESTATUS_NOEFFECT)
-        && AttacksThisTurn(gBankAttacker, gCurrentMove) == 2
-        && (!(flags & MOVESTATUS_SUPEREFFECTIVE) || ((flags & (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)) == (MOVESTATUS_SUPEREFFECTIVE | MOVESTATUS_NOTVERYEFFECTIVE)))
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_WONDER_GUARD
+        && !(flags & MOVE_RESULT_NO_EFFECT)
+        && AttacksThisTurn(gBattlerAttacker, gCurrentMove) == 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[gCurrentMove].power)
     {
         gLastUsedAbility = ABILITY_WONDER_GUARD;
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
-        gUnknown_02024250[gBankTarget] = 0;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
+        gLastLandedMoves[gBattlerTarget] = 0;
         gBattleCommunication[6] = 3;
-        RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+        RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
-    if (gBattleMoveFlags & MOVESTATUS_NOTAFFECTED)
-        gProtectStructs[gBankAttacker].targetNotAffected = 1;
+    if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
+        gProtectStructs[gBattlerAttacker].targetNotAffected = 1;
 
     gBattlescriptCurrInstr++;
 }
 
-static void atk4B_return_atk_to_ball(void)
+static void atk4B_returnatktoball(void)
 {
-    gActiveBank = gBankAttacker;
-    if (!(gHitMarker & HITMARKER_FAINTED(gActiveBank)))
+    gActiveBattler = gBattlerAttacker;
+    if (!(gHitMarker & HITMARKER_FAINTED(gActiveBattler)))
     {
-        EmitReturnMonToBall(0, 0);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitReturnMonToBall(0, 0);
+        MarkBattlerForControllerExec(gActiveBattler);
     }
     gBattlescriptCurrInstr++;
 }
 
-static void atk4C_copy_poke_data(void)
+static void atk4C_getswitchedmondata(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    gBattlePartyID[gActiveBank] = *(gBattleStruct->field_5C + gActiveBank);
+    gBattlerPartyIndexes[gActiveBattler] = *(gBattleStruct->monToSwitchIntoId + gActiveBattler);
 
-    EmitGetMonData(0, 0, gBitTable[gBattlePartyID[gActiveBank]]);
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitGetMonData(0, REQUEST_ALL_BATTLE, gBitTable[gBattlerPartyIndexes[gActiveBattler]]);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk4D_switch_data_update(void)
+static void atk4D_switchindataupdate(void)
 {
     struct BattlePokemon oldData;
     s32 i;
     u8 *monData;
 
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    oldData = gBattleMons[gActiveBank];
-    monData = (u8*)(&gBattleMons[gActiveBank]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    oldData = gBattleMons[gActiveBattler];
+    monData = (u8*)(&gBattleMons[gActiveBattler]);
 
     for (i = 0; i < sizeof(struct BattlePokemon); i++)
     {
-        monData[i] = gBattleBufferB[gActiveBank][4 + i];
+        monData[i] = gBattleBufferB[gActiveBattler][4 + i];
     }
 
-    gBattleMons[gActiveBank].type1 = gBaseStats[gBattleMons[gActiveBank].species].type1;
-    gBattleMons[gActiveBank].type2 = gBaseStats[gBattleMons[gActiveBank].species].type2;
-    gBattleMons[gActiveBank].ability = GetAbilityBySpecies(gBattleMons[gActiveBank].species, gBattleMons[gActiveBank].altAbility);
+    gBattleMons[gActiveBattler].type1 = gBaseStats[gBattleMons[gActiveBattler].species].type1;
+    gBattleMons[gActiveBattler].type2 = gBaseStats[gBattleMons[gActiveBattler].species].type2;
+    gBattleMons[gActiveBattler].ability = GetAbilityBySpecies(gBattleMons[gActiveBattler].species, gBattleMons[gActiveBattler].altAbility);
 
     // check knocked off item
-    i = GetBankSide(gActiveBank);
-    if (gWishFutureKnock.knockedOffPokes[i] & gBitTable[gBattlePartyID[gActiveBank]])
+    i = GetBattlerSide(gActiveBattler);
+    if (gWishFutureKnock.knockedOffPokes[i] & gBitTable[gBattlerPartyIndexes[gActiveBattler]])
     {
-        gBattleMons[gActiveBank].item = 0;
+        gBattleMons[gActiveBattler].item = 0;
     }
 
     if (gBattleMoves[gCurrentMove].effect == EFFECT_BATON_PASS)
     {
-        for (i = 0; i < 8; i++)
+        for (i = 0; i < BATTLE_STATS_NO; i++)
         {
-            gBattleMons[gActiveBank].statStages[i] = oldData.statStages[i];
+            gBattleMons[gActiveBattler].statStages[i] = oldData.statStages[i];
         }
-        gBattleMons[gActiveBank].status2 = oldData.status2;
+        gBattleMons[gActiveBattler].status2 = oldData.status2;
     }
 
     SwitchInClearSetData();
 
-    if (gBattleTypeFlags & BATTLE_TYPE_PALACE && gBattleMons[gActiveBank].maxHP / 2 >= gBattleMons[gActiveBank].hp
-        && gBattleMons[gActiveBank].hp != 0 && !(gBattleMons[gActiveBank].status1 & STATUS_SLEEP))
+    if (gBattleTypeFlags & BATTLE_TYPE_PALACE && gBattleMons[gActiveBattler].maxHP / 2 >= gBattleMons[gActiveBattler].hp
+        && gBattleMons[gActiveBattler].hp != 0 && !(gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP))
     {
-        gBattleStruct->field_92 |= gBitTable[gActiveBank];
+        gBattleStruct->field_92 |= gBitTable[gActiveBattler];
     }
 
-    gBattleScripting.bank = gActiveBank;
-    gBattleTextBuff1[0] = PLACEHOLDER_BEGIN;
-    gBattleTextBuff1[1] = 7;
-    gBattleTextBuff1[2] = gActiveBank;
-    gBattleTextBuff1[3] = gBattlePartyID[gActiveBank];
-    gBattleTextBuff1[4] = EOS;
+    gBattleScripting.battler = gActiveBattler;
+
+    PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, gActiveBattler, gBattlerPartyIndexes[gActiveBattler]);
 
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk4E_switchin_anim(void)
+static void atk4E_switchinanim(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    if (GetBankSide(gActiveBank) == SIDE_OPPONENT
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT
         && !(gBattleTypeFlags & (BATTLE_TYPE_LINK
                                  | BATTLE_TYPE_EREADER_TRAINER
                                  | BATTLE_TYPE_x2000000
                                  | BATTLE_TYPE_x4000000
                                  | BATTLE_TYPE_FRONTIER)))
-            HandleSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gActiveBank].species), FLAG_SET_SEEN, gBattleMons[gActiveBank].personality);
+            HandleSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gActiveBattler].species), FLAG_SET_SEEN, gBattleMons[gActiveBattler].personality);
 
-    gAbsentBankFlags &= ~(gBitTable[gActiveBank]);
+    gAbsentBattlerFlags &= ~(gBitTable[gActiveBattler]);
 
-    EmitSwitchInAnim(0, gBattlePartyID[gActiveBank], gBattlescriptCurrInstr[2]);
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitSwitchInAnim(0, gBattlerPartyIndexes[gActiveBattler], gBattlescriptCurrInstr[2]);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 3;
 
@@ -5411,18 +5271,18 @@ static void atk4E_switchin_anim(void)
         sub_81A56B4();
 }
 
-static void atk4F_jump_if_cannot_switch(void)
+static void atk4F_jumpifcantswitch(void)
 {
     s32 val = 0;
     s32 compareVar = 0;
     struct Pokemon *party = NULL;
     s32 r7 = 0;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1] & ~(ATK4F_DONT_CHECK_STATUSES));
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1] & ~(ATK4F_DONT_CHECK_STATUSES));
 
     if (!(gBattlescriptCurrInstr[1] & ATK4F_DONT_CHECK_STATUSES)
-        && ((gBattleMons[gActiveBank].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION))
-            || (gStatuses3[gActiveBank] & STATUS3_ROOTED)))
+        && ((gBattleMons[gActiveBattler].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION))
+            || (gStatuses3[gActiveBattler] & STATUS3_ROOTED)))
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 2);
     }
@@ -5431,13 +5291,13 @@ static void atk4F_jump_if_cannot_switch(void)
         #ifndef NONMATCHING
             asm("":::"r5");
         #endif // NONMATCHING
-        if (GetBankSide(gActiveBank) == SIDE_OPPONENT)
+        if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT)
             party = gEnemyParty;
         else
             party = gPlayerParty;
 
         val = 0;
-        if (2 & gActiveBank)
+        if (2 & gActiveBattler)
             val = 3;
 
         for (compareVar = val + 3; val < compareVar; val++)
@@ -5445,7 +5305,7 @@ static void atk4F_jump_if_cannot_switch(void)
             if (GetMonData(&party[val], MON_DATA_SPECIES) != SPECIES_NONE
              && !GetMonData(&party[val], MON_DATA_IS_EGG)
              && GetMonData(&party[val], MON_DATA_HP) != 0
-             && gBattlePartyID[gActiveBank] != val)
+             && gBattlerPartyIndexes[gActiveBattler] != val)
                 break;
         }
 
@@ -5458,19 +5318,19 @@ static void atk4F_jump_if_cannot_switch(void)
     {
         if (gBattleTypeFlags & BATTLE_TYPE_x800000)
         {
-            if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+            if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
             {
                 party = gPlayerParty;
 
                 val = 0;
-                if (sub_806D82C(GetBankMultiplayerId(gActiveBank)) == TRUE)
+                if (sub_806D82C(GetBattlerMultiplayerId(gActiveBattler)) == TRUE)
                     val = 3;
             }
             else
             {
                 party = gEnemyParty;
 
-                if (gActiveBank == 1)
+                if (gActiveBattler == 1)
                     val = 0;
                 else
                     val = 3;
@@ -5478,14 +5338,14 @@ static void atk4F_jump_if_cannot_switch(void)
         }
         else
         {
-            if (GetBankSide(gActiveBank) == SIDE_OPPONENT)
+            if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT)
                 party = gEnemyParty;
             else
                 party = gPlayerParty;
 
 
             val = 0;
-            if (sub_806D82C(GetBankMultiplayerId(gActiveBank)) == TRUE)
+            if (sub_806D82C(GetBattlerMultiplayerId(gActiveBattler)) == TRUE)
                 val = 3;
         }
 
@@ -5494,7 +5354,7 @@ static void atk4F_jump_if_cannot_switch(void)
             if (GetMonData(&party[val], MON_DATA_SPECIES) != SPECIES_NONE
              && !GetMonData(&party[val], MON_DATA_IS_EGG)
              && GetMonData(&party[val], MON_DATA_HP) != 0
-             && gBattlePartyID[gActiveBank] != val)
+             && gBattlerPartyIndexes[gActiveBattler] != val)
                 break;
         }
 
@@ -5503,12 +5363,12 @@ static void atk4F_jump_if_cannot_switch(void)
         else
             gBattlescriptCurrInstr += 6;
     }
-    else if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS && GetBankSide(gActiveBank) == SIDE_OPPONENT)
+    else if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS && GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT)
     {
         party = gEnemyParty;
 
         val = 0;
-        if (gActiveBank == 3)
+        if (gActiveBattler == 3)
             val = 3;
 
         for (compareVar = val + 3; val < compareVar; val++)
@@ -5516,7 +5376,7 @@ static void atk4F_jump_if_cannot_switch(void)
             if (GetMonData(&party[val], MON_DATA_SPECIES) != SPECIES_NONE
              && !GetMonData(&party[val], MON_DATA_IS_EGG)
              && GetMonData(&party[val], MON_DATA_HP) != 0
-             && gBattlePartyID[gActiveBank] != val)
+             && gBattlerPartyIndexes[gActiveBattler] != val)
                 break;
         }
 
@@ -5527,12 +5387,12 @@ static void atk4F_jump_if_cannot_switch(void)
     }
     else
     {
-        if (GetBankSide(gActiveBank) == SIDE_OPPONENT)
+        if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT)
         {
-            r7 = GetBankByIdentity(1);
+            r7 = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
 
             if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
-                compareVar = GetBankByIdentity(3);
+                compareVar = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
             else
                 compareVar = r7;
 
@@ -5540,10 +5400,10 @@ static void atk4F_jump_if_cannot_switch(void)
         }
         else
         {
-            r7 = GetBankByIdentity(0);
+            r7 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
 
             if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
-                compareVar = GetBankByIdentity(2);
+                compareVar = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
             else
                 compareVar = r7;
 
@@ -5554,7 +5414,7 @@ static void atk4F_jump_if_cannot_switch(void)
             if (GetMonData(&party[val], MON_DATA_HP) != 0
              && GetMonData(&party[val], MON_DATA_SPECIES) != SPECIES_NONE
              && !GetMonData(&party[val], MON_DATA_IS_EGG)
-             && val != gBattlePartyID[r7] && val != gBattlePartyID[compareVar])
+             && val != gBattlerPartyIndexes[r7] && val != gBattlerPartyIndexes[compareVar])
                 break;
         }
 
@@ -5567,22 +5427,22 @@ static void atk4F_jump_if_cannot_switch(void)
 
 static void sub_804CF10(u8 arg0)
 {
-    *(gBattleStruct->field_58 + gActiveBank) = gBattlePartyID[gActiveBank];
-    *(gBattleStruct->field_5C + gActiveBank) = 6;
-    gBattleStruct->field_93 &= ~(gBitTable[gActiveBank]);
+    *(gBattleStruct->field_58 + gActiveBattler) = gBattlerPartyIndexes[gActiveBattler];
+    *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = 6;
+    gBattleStruct->field_93 &= ~(gBitTable[gActiveBattler]);
 
-    EmitChoosePokemon(0, 1, arg0, 0, gBattleStruct->field_60[gActiveBank]);
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitChoosePokemon(0, 1, arg0, 0, gBattleStruct->field_60[gActiveBattler]);
+    MarkBattlerForControllerExec(gActiveBattler);
 }
 
 static void atk50_openpartyscreen(void)
 {
     u32 flags;
     u8 hitmarkerFaintBits;
-    u8 bank;
+    u8 battlerId;
     const u8 *jumpPtr;
 
-    bank = 0;
+    battlerId = 0;
     flags = 0;
     jumpPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 2);
 
@@ -5590,27 +5450,27 @@ static void atk50_openpartyscreen(void)
     {
         if ((gBattleTypeFlags & (BATTLE_TYPE_DOUBLE | BATTLE_TYPE_MULTI)) != BATTLE_TYPE_DOUBLE)
         {
-            for (gActiveBank = 0; gActiveBank < gNoOfAllBanks; gActiveBank++)
+            for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++)
             {
-                if (gHitMarker & HITMARKER_FAINTED(gActiveBank))
+                if (gHitMarker & HITMARKER_FAINTED(gActiveBattler))
                 {
-                    if (sub_80423F4(gActiveBank, 6, 6))
+                    if (sub_80423F4(gActiveBattler, 6, 6))
                     {
-                        gAbsentBankFlags |= gBitTable[gActiveBank];
-                        gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-                        EmitLinkStandbyMsg(0, 2, 0);
-                        MarkBufferBankForExecution(gActiveBank);
+                        gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+                        gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+                        BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                        MarkBattlerForControllerExec(gActiveBattler);
                     }
-                    else if (!gSpecialStatuses[gActiveBank].flag40)
+                    else if (!gSpecialStatuses[gActiveBattler].flag40)
                     {
                         sub_804CF10(6);
-                        gSpecialStatuses[gActiveBank].flag40 = 1;
+                        gSpecialStatuses[gActiveBattler].flag40 = 1;
                     }
                 }
                 else
                 {
-                    EmitLinkStandbyMsg(0, 2, 0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
             }
         }
@@ -5622,88 +5482,88 @@ static void atk50_openpartyscreen(void)
 
             if (gBitTable[0] & hitmarkerFaintBits)
             {
-                gActiveBank = 0;
+                gActiveBattler = 0;
                 if (sub_80423F4(0, 6, 6))
                 {
-                    gAbsentBankFlags |= gBitTable[gActiveBank];
-                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-                    EmitCmd42(0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+                    BtlController_EmitCmd42(0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
-                else if (!gSpecialStatuses[gActiveBank].flag40)
+                else if (!gSpecialStatuses[gActiveBattler].flag40)
                 {
-                    sub_804CF10(gBattleStruct->field_5C[2]);
-                    gSpecialStatuses[gActiveBank].flag40 = 1;
+                    sub_804CF10(gBattleStruct->monToSwitchIntoId[2]);
+                    gSpecialStatuses[gActiveBattler].flag40 = 1;
                 }
                 else
                 {
-                    EmitLinkStandbyMsg(0, 2, 0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                     flags |= 1;
                 }
             }
             if (gBitTable[2] & hitmarkerFaintBits && !(gBitTable[0] & hitmarkerFaintBits))
             {
-                gActiveBank = 2;
+                gActiveBattler = 2;
                 if (sub_80423F4(2, 6, 6))
                 {
-                    gAbsentBankFlags |= gBitTable[gActiveBank];
-                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-                    EmitCmd42(0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+                    BtlController_EmitCmd42(0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
-                else if (!gSpecialStatuses[gActiveBank].flag40)
+                else if (!gSpecialStatuses[gActiveBattler].flag40)
                 {
-                    sub_804CF10(gBattleStruct->field_5C[0]);
-                    gSpecialStatuses[gActiveBank].flag40 = 1;
+                    sub_804CF10(gBattleStruct->monToSwitchIntoId[0]);
+                    gSpecialStatuses[gActiveBattler].flag40 = 1;
                 }
                 else if (!(flags & 1))
                 {
-                    EmitLinkStandbyMsg(0, 2, 0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
             }
             if (gBitTable[1] & hitmarkerFaintBits)
             {
-                gActiveBank = 1;
+                gActiveBattler = 1;
                 if (sub_80423F4(1, 6, 6))
                 {
-                    gAbsentBankFlags |= gBitTable[gActiveBank];
-                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-                    EmitCmd42(0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+                    BtlController_EmitCmd42(0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
-                else if (!gSpecialStatuses[gActiveBank].flag40)
+                else if (!gSpecialStatuses[gActiveBattler].flag40)
                 {
-                    sub_804CF10(gBattleStruct->field_5C[3]);
-                    gSpecialStatuses[gActiveBank].flag40 = 1;
+                    sub_804CF10(gBattleStruct->monToSwitchIntoId[3]);
+                    gSpecialStatuses[gActiveBattler].flag40 = 1;
                 }
                 else
                 {
-                    EmitLinkStandbyMsg(0, 2, 0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                     flags |= 2;
                 }
             }
             if (gBitTable[3] & hitmarkerFaintBits && !(gBitTable[1] & hitmarkerFaintBits))
             {
-                gActiveBank = 3;
+                gActiveBattler = 3;
                 if (sub_80423F4(3, 6, 6))
                 {
-                    gAbsentBankFlags |= gBitTable[gActiveBank];
-                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-                    EmitCmd42(0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+                    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+                    BtlController_EmitCmd42(0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
-                else if (!gSpecialStatuses[gActiveBank].flag40)
+                else if (!gSpecialStatuses[gActiveBattler].flag40)
                 {
-                    sub_804CF10(gBattleStruct->field_5C[1]);
-                    gSpecialStatuses[gActiveBank].flag40 = 1;
+                    sub_804CF10(gBattleStruct->monToSwitchIntoId[1]);
+                    gSpecialStatuses[gActiveBattler].flag40 = 1;
                 }
                 else if (!(flags & 2))
                 {
-                    EmitLinkStandbyMsg(0, 2, 0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
             }
 
@@ -5713,13 +5573,13 @@ static void atk50_openpartyscreen(void)
                 flag40_2 = gSpecialStatuses[2].flag40;
                 if (!flag40_2 && hitmarkerFaintBits != 0)
                 {
-                    if (gAbsentBankFlags & gBitTable[0])
-                        gActiveBank = 2;
+                    if (gAbsentBattlerFlags & gBitTable[0])
+                        gActiveBattler = 2;
                     else
-                        gActiveBank = 0;
+                        gActiveBattler = 0;
 
-                    EmitLinkStandbyMsg(0, 2, 0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
 
             }
@@ -5729,13 +5589,13 @@ static void atk50_openpartyscreen(void)
                 flag40_3 = gSpecialStatuses[3].flag40;
                 if (!flag40_3 && hitmarkerFaintBits != 0)
                 {
-                    if (gAbsentBankFlags & gBitTable[1])
-                        gActiveBank = 3;
+                    if (gAbsentBattlerFlags & gBitTable[1])
+                        gActiveBattler = 3;
                     else
-                        gActiveBank = 1;
+                        gActiveBattler = 1;
 
-                    EmitLinkStandbyMsg(0, 2, 0);
-                    MarkBufferBankForExecution(gActiveBank);
+                    BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                    MarkBattlerForControllerExec(gActiveBattler);
                 }
             }
         }
@@ -5750,34 +5610,34 @@ static void atk50_openpartyscreen(void)
                 hitmarkerFaintBits = gHitMarker >> 0x1C;
                 if (gBitTable[2] & hitmarkerFaintBits && gBitTable[0] & hitmarkerFaintBits)
                 {
-                    gActiveBank = 2;
+                    gActiveBattler = 2;
                     if (sub_80423F4(2, gBattleBufferB[0][1], 6))
                     {
-                        gAbsentBankFlags |= gBitTable[gActiveBank];
-                        gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-                        EmitCmd42(0);
-                        MarkBufferBankForExecution(gActiveBank);
+                        gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+                        gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+                        BtlController_EmitCmd42(0);
+                        MarkBattlerForControllerExec(gActiveBattler);
                     }
-                    else if (!gSpecialStatuses[gActiveBank].flag40)
+                    else if (!gSpecialStatuses[gActiveBattler].flag40)
                     {
-                        sub_804CF10(gBattleStruct->field_5C[0]);
-                        gSpecialStatuses[gActiveBank].flag40 = 1;
+                        sub_804CF10(gBattleStruct->monToSwitchIntoId[0]);
+                        gSpecialStatuses[gActiveBattler].flag40 = 1;
                     }
                 }
                 if (gBitTable[3] & hitmarkerFaintBits && hitmarkerFaintBits & gBitTable[1])
                 {
-                    gActiveBank = 3;
+                    gActiveBattler = 3;
                     if (sub_80423F4(3, gBattleBufferB[1][1], 6))
                     {
-                        gAbsentBankFlags |= gBitTable[gActiveBank];
-                        gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-                        EmitCmd42(0);
-                        MarkBufferBankForExecution(gActiveBank);
+                        gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+                        gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+                        BtlController_EmitCmd42(0);
+                        MarkBattlerForControllerExec(gActiveBattler);
                     }
-                    else if (!gSpecialStatuses[gActiveBank].flag40)
+                    else if (!gSpecialStatuses[gActiveBattler].flag40)
                     {
-                        sub_804CF10(gBattleStruct->field_5C[1]);
-                        gSpecialStatuses[gActiveBank].flag40 = 1;
+                        sub_804CF10(gBattleStruct->monToSwitchIntoId[1]);
+                        gSpecialStatuses[gActiveBattler].flag40 = 1;
                     }
                 }
                 gBattlescriptCurrInstr += 6;
@@ -5794,17 +5654,17 @@ static void atk50_openpartyscreen(void)
 
         hitmarkerFaintBits = gHitMarker >> 0x1C;
 
-        gBank1 = 0;
+        gBattlerFainted = 0;
         while (1)
         {
-            if (gBitTable[gBank1] & hitmarkerFaintBits)
+            if (gBitTable[gBattlerFainted] & hitmarkerFaintBits)
                 break;
-            if (gBank1 >= gNoOfAllBanks)
+            if (gBattlerFainted >= gBattlersCount)
                 break;
-            gBank1++;
+            gBattlerFainted++;
         }
 
-        if (gBank1 == gNoOfAllBanks)
+        if (gBattlerFainted == gBattlersCount)
             gBattlescriptCurrInstr = jumpPtr;
     }
     else
@@ -5814,76 +5674,76 @@ static void atk50_openpartyscreen(void)
         else
             hitmarkerFaintBits = 1;
 
-        bank = GetBattleBank(gBattlescriptCurrInstr[1] & ~(0x80));
-        if (gSpecialStatuses[bank].flag40)
+        battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1] & ~(0x80));
+        if (gSpecialStatuses[battlerId].flag40)
         {
             gBattlescriptCurrInstr += 6;
         }
-        else if (sub_80423F4(bank, 6, 6))
+        else if (sub_80423F4(battlerId, 6, 6))
         {
-            gActiveBank = bank;
-            gAbsentBankFlags |= gBitTable[gActiveBank];
-            gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
+            gActiveBattler = battlerId;
+            gAbsentBattlerFlags |= gBitTable[gActiveBattler];
+            gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
             gBattlescriptCurrInstr = jumpPtr;
         }
         else
         {
-            gActiveBank = bank;
-            *(gBattleStruct->field_58 + gActiveBank) = gBattlePartyID[gActiveBank];
-            *(gBattleStruct->field_5C + gActiveBank) = 6;
-            gBattleStruct->field_93 &= ~(gBitTable[gActiveBank]);
+            gActiveBattler = battlerId;
+            *(gBattleStruct->field_58 + gActiveBattler) = gBattlerPartyIndexes[gActiveBattler];
+            *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = 6;
+            gBattleStruct->field_93 &= ~(gBitTable[gActiveBattler]);
 
-            EmitChoosePokemon(0, hitmarkerFaintBits, *(gBattleStruct->field_5C + (gActiveBank ^ 2)), 0, gBattleStruct->field_60[gActiveBank]);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitChoosePokemon(0, hitmarkerFaintBits, *(gBattleStruct->monToSwitchIntoId + (gActiveBattler ^ 2)), 0, gBattleStruct->field_60[gActiveBattler]);
+            MarkBattlerForControllerExec(gActiveBattler);
 
             gBattlescriptCurrInstr += 6;
 
-            if (GetBankIdentity(gActiveBank) == 0 && gBattleResults.playerSwitchesCounter < 0xFF)
+            if (GetBattlerPosition(gActiveBattler) == 0 && gBattleResults.playerSwitchesCounter < 0xFF)
                 gBattleResults.playerSwitchesCounter++;
 
             if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
             {
-                for (gActiveBank = 0; gActiveBank < gNoOfAllBanks; gActiveBank++)
+                for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++)
                 {
-                    if (gActiveBank != bank)
+                    if (gActiveBattler != battlerId)
                     {
-                        EmitLinkStandbyMsg(0, 2, 0);
-                        MarkBufferBankForExecution(gActiveBank);
+                        BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                        MarkBattlerForControllerExec(gActiveBattler);
                     }
                 }
             }
             else
             {
-                gActiveBank = GetBankByIdentity(GetBankIdentity(bank) ^ BIT_SIDE);
-                if (gAbsentBankFlags & gBitTable[gActiveBank])
-                    gActiveBank ^= BIT_MON;
+                gActiveBattler = GetBattlerAtPosition(GetBattlerPosition(battlerId) ^ BIT_SIDE);
+                if (gAbsentBattlerFlags & gBitTable[gActiveBattler])
+                    gActiveBattler ^= BIT_FLANK;
 
-                EmitLinkStandbyMsg(0, 2, 0);
-                MarkBufferBankForExecution(gActiveBank);
+                BtlController_EmitLinkStandbyMsg(0, 2, 0);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
         }
     }
 }
 
-static void atk51_switch_handle_order(void)
+static void atk51_switchhandleorder(void)
 {
     s32 i;
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
     switch (gBattlescriptCurrInstr[2])
     {
     case 0:
-        for (i = 0; i < gNoOfAllBanks; i++)
+        for (i = 0; i < gBattlersCount; i++)
         {
             if (gBattleBufferB[i][0] == 0x22)
             {
-                *(gBattleStruct->field_5C + i) = gBattleBufferB[i][1];
+                *(gBattleStruct->monToSwitchIntoId + i) = gBattleBufferB[i][1];
                 if (!(gBattleStruct->field_93 & gBitTable[i]))
                 {
-                    RecordedBattle_SetBankAction(i, gBattleBufferB[i][1]);
+                    RecordedBattle_SetBattlerAction(i, gBattleBufferB[i][1]);
                     gBattleStruct->field_93 |= gBitTable[i];
                 }
             }
@@ -5891,40 +5751,40 @@ static void atk51_switch_handle_order(void)
         break;
     case 1:
         if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
-            sub_803BDA0(gActiveBank);
+            sub_803BDA0(gActiveBattler);
         break;
     case 2:
-        if (!(gBattleStruct->field_93 & gBitTable[gActiveBank]))
+        if (!(gBattleStruct->field_93 & gBitTable[gActiveBattler]))
         {
-            RecordedBattle_SetBankAction(gActiveBank, gBattleBufferB[gActiveBank][1]);
-            gBattleStruct->field_93 |= gBitTable[gActiveBank];
+            RecordedBattle_SetBattlerAction(gActiveBattler, gBattleBufferB[gActiveBattler][1]);
+            gBattleStruct->field_93 |= gBitTable[gActiveBattler];
         }
         // fall through
     case 3:
-        gBattleCommunication[0] = gBattleBufferB[gActiveBank][1];
-        *(gBattleStruct->field_5C + gActiveBank) = gBattleBufferB[gActiveBank][1];
+        gBattleCommunication[0] = gBattleBufferB[gActiveBattler][1];
+        *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = gBattleBufferB[gActiveBattler][1];
 
         if (gBattleTypeFlags & BATTLE_TYPE_LINK && gBattleTypeFlags & BATTLE_TYPE_MULTI)
         {
-            *(gActiveBank * 3 + (u8*)(gBattleStruct->field_60) + 0) &= 0xF;
-            *(gActiveBank * 3 + (u8*)(gBattleStruct->field_60) + 0) |= (gBattleBufferB[gActiveBank][2] & 0xF0);
-            *(gActiveBank * 3 + (u8*)(gBattleStruct->field_60) + 1) = gBattleBufferB[gActiveBank][3];
+            *(gActiveBattler * 3 + (u8*)(gBattleStruct->field_60) + 0) &= 0xF;
+            *(gActiveBattler * 3 + (u8*)(gBattleStruct->field_60) + 0) |= (gBattleBufferB[gActiveBattler][2] & 0xF0);
+            *(gActiveBattler * 3 + (u8*)(gBattleStruct->field_60) + 1) = gBattleBufferB[gActiveBattler][3];
 
-            *((gActiveBank ^ BIT_MON) * 3 + (u8*)(gBattleStruct->field_60) + 0) &= (0xF0);
-            *((gActiveBank ^ BIT_MON) * 3 + (u8*)(gBattleStruct->field_60) + 0) |= (gBattleBufferB[gActiveBank][2] & 0xF0) >> 4;
-            *((gActiveBank ^ BIT_MON) * 3 + (u8*)(gBattleStruct->field_60) + 2) = gBattleBufferB[gActiveBank][3];
+            *((gActiveBattler ^ BIT_FLANK) * 3 + (u8*)(gBattleStruct->field_60) + 0) &= (0xF0);
+            *((gActiveBattler ^ BIT_FLANK) * 3 + (u8*)(gBattleStruct->field_60) + 0) |= (gBattleBufferB[gActiveBattler][2] & 0xF0) >> 4;
+            *((gActiveBattler ^ BIT_FLANK) * 3 + (u8*)(gBattleStruct->field_60) + 2) = gBattleBufferB[gActiveBattler][3];
         }
         else if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER)
         {
-            sub_80571DC(gActiveBank, *(gBattleStruct->field_5C + gActiveBank));
+            sub_80571DC(gActiveBattler, *(gBattleStruct->monToSwitchIntoId + gActiveBattler));
         }
         else
         {
-            sub_803BDA0(gActiveBank);
+            sub_803BDA0(gActiveBattler);
         }
 
-        PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[gBankAttacker].species)
-        PREPARE_MON_NICK_BUFFER(gBattleTextBuff2, gActiveBank, gBattleBufferB[gActiveBank][1])
+        PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerAttacker].species)
+        PREPARE_MON_NICK_BUFFER(gBattleTextBuff2, gActiveBattler, gBattleBufferB[gActiveBattler][1])
 
         break;
     }
@@ -5932,65 +5792,65 @@ static void atk51_switch_handle_order(void)
     gBattlescriptCurrInstr += 3;
 }
 
-static void atk52_switch_in_effects(void)
+static void atk52_switchineffects(void)
 {
     s32 i;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    sub_803FA70(gActiveBank);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    sub_803FA70(gActiveBattler);
 
-    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
-    gSpecialStatuses[gActiveBank].flag40 = 0;
+    gHitMarker &= ~(HITMARKER_FAINTED(gActiveBattler));
+    gSpecialStatuses[gActiveBattler].flag40 = 0;
 
-    if (!(gSideAffecting[GetBankSide(gActiveBank)] & SIDE_STATUS_SPIKES_DAMAGED)
-        && (gSideAffecting[GetBankSide(gActiveBank)] & SIDE_STATUS_SPIKES)
-        && gBattleMons[gActiveBank].type1 != TYPE_FLYING
-        && gBattleMons[gActiveBank].type2 != TYPE_FLYING
-        && gBattleMons[gActiveBank].ability != ABILITY_LEVITATE)
+    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[GetBankSide(gActiveBank)] |= SIDE_STATUS_SPIKES_DAMAGED;
+        gSideStatuses[GetBattlerSide(gActiveBattler)] |= SIDE_STATUS_SPIKES_DAMAGED;
 
-        gBattleMons[gActiveBank].status2 &= ~(STATUS2_DESTINY_BOND);
+        gBattleMons[gActiveBattler].status2 &= ~(STATUS2_DESTINY_BOND);
         gHitMarker &= ~(HITMARKER_DESTINYBOND);
 
-        spikesDmg = (5 - gSideTimers[GetBankSide(gActiveBank)].spikesAmount) * 2;
-        gBattleMoveDamage = gBattleMons[gActiveBank].maxHP / (spikesDmg);
+        spikesDmg = (5 - gSideTimers[GetBattlerSide(gActiveBattler)].spikesAmount) * 2;
+        gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / (spikesDmg);
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
 
-        gBattleScripting.bank = gActiveBank;
+        gBattleScripting.battler = gActiveBattler;
         BattleScriptPushCursor();
 
-        if (gBattlescriptCurrInstr[1] == 0)
-            gBattlescriptCurrInstr = gUnknown_082DAE90;
-        else if (gBattlescriptCurrInstr[1] == 1)
-            gBattlescriptCurrInstr = gUnknown_082DAE59;
+        if (gBattlescriptCurrInstr[1] == BS_TARGET)
+            gBattlescriptCurrInstr = BattleScript_SpikesOnTarget;
+        else if (gBattlescriptCurrInstr[1] == BS_ATTACKER)
+            gBattlescriptCurrInstr = BattleScript_SpikesOnAttacker;
         else
-            gBattlescriptCurrInstr = gUnknown_082DAEC7;
+            gBattlescriptCurrInstr = BattleScript_SpikesOnFaintedBattler;
     }
     else
     {
-        if (gBattleMons[gActiveBank].ability == ABILITY_TRUANT && !gDisableStructs[gActiveBank].truantUnknownBit)
-            gDisableStructs[gActiveBank].truantCounter = 1;
+        if (gBattleMons[gActiveBattler].ability == ABILITY_TRUANT && !gDisableStructs[gActiveBattler].truantUnknownBit)
+            gDisableStructs[gActiveBattler].truantCounter = 1;
 
-        gDisableStructs[gActiveBank].truantUnknownBit = 0;
+        gDisableStructs[gActiveBattler].truantUnknownBit = 0;
 
-        if (AbilityBattleEffects(ABILITYEFFECT_ON_SWITCHIN, gActiveBank, 0, 0, 0) == 0 &&
-            ItemBattleEffects(0, gActiveBank, 0) == 0)
+        if (AbilityBattleEffects(ABILITYEFFECT_ON_SWITCHIN, gActiveBattler, 0, 0, 0) == 0 &&
+            ItemBattleEffects(0, gActiveBattler, 0) == 0)
         {
-            gSideAffecting[GetBankSide(gActiveBank)] &= ~(SIDE_STATUS_SPIKES_DAMAGED);
+            gSideStatuses[GetBattlerSide(gActiveBattler)] &= ~(SIDE_STATUS_SPIKES_DAMAGED);
 
-            for (i = 0; i < gNoOfAllBanks; i++)
+            for (i = 0; i < gBattlersCount; i++)
             {
-                if (gBanksByTurnOrder[i] == gActiveBank)
-                    gActionsByTurnOrder[i] = ACTION_CANCEL_PARTNER;
+                if (gBattleTurnOrder[i] == gActiveBattler)
+                    gActionsByTurnOrder[i] = B_ACTION_CANCEL_PARTNER;
             }
 
-            for (i = 0; i < gNoOfAllBanks; i++)
+            for (i = 0; i < gBattlersCount; i++)
             {
-                u16* hpOnSwitchout = &gBattleStruct->hpOnSwitchout[GetBankSide(i)];
+                u16* hpOnSwitchout = &gBattleStruct->hpOnSwitchout[GetBattlerSide(i)];
                 *hpOnSwitchout = gBattleMons[i].hp;
             }
 
@@ -5998,14 +5858,14 @@ static void atk52_switch_in_effects(void)
             {
                 u32 hitmarkerFaintBits = gHitMarker >> 0x1C;
 
-                gBank1++;
+                gBattlerFainted++;
                 while (1)
                 {
-                    if (hitmarkerFaintBits & gBitTable[gBank1] && !(gAbsentBankFlags & gBitTable[gBank1]))
+                    if (hitmarkerFaintBits & gBitTable[gBattlerFainted] && !(gAbsentBattlerFlags & gBitTable[gBattlerFainted]))
                         break;
-                    if (gBank1 >= gNoOfAllBanks)
+                    if (gBattlerFainted >= gBattlersCount)
                         break;
-                    gBank1++;
+                    gBattlerFainted++;
                 }
             }
             gBattlescriptCurrInstr += 2;
@@ -6013,68 +5873,68 @@ static void atk52_switch_in_effects(void)
     }
 }
 
-static void atk53_trainer_slide(void)
+static void atk53_trainerslidein(void)
 {
-    gActiveBank = GetBankByIdentity(gBattlescriptCurrInstr[1]);
-    EmitTrainerSlide(0);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = GetBattlerAtPosition(gBattlescriptCurrInstr[1]);
+    BtlController_EmitTrainerSlide(0);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk54_effectiveness_sound(void)
+static void atk54_playse(void)
 {
-    gActiveBank = gBankAttacker;
-    EmitEffectivenessSound(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1));
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = gBattlerAttacker;
+    BtlController_EmitPlaySE(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1));
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 3;
 }
 
-static void atk55_play_fanfare(void)
+static void atk55_fanfare(void)
 {
-    gActiveBank = gBankAttacker;
-    EmitPlayFanfareOrBGM(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1), FALSE);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = gBattlerAttacker;
+    BtlController_EmitPlayFanfareOrBGM(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1), FALSE);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 3;
 }
 
-static void atk56_fainting_cry(void)
+static void atk56_playfaintcry(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    EmitFaintingCry(0);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    BtlController_EmitFaintingCry(0);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
 static void atk57(void)
 {
-    gActiveBank = GetBankByIdentity(0);
-    EmitCmd55(0, gBattleOutcome);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
+    BtlController_EmitCmd55(0, gBattleOutcome);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 1;
 }
 
-static void atk58_return_to_ball(void)
+static void atk58_returntoball(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    EmitReturnMonToBall(0, 1);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    BtlController_EmitReturnMonToBall(0, 1);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk59_learnmove_inbattle(void)
+static void atk59_handlelearnnewmove(void)
 {
-    const u8* jumpPtr1 = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
-    const u8* jumpPtr2 = BSScriptReadPtr(gBattlescriptCurrInstr + 5);
+    const u8 *jumpPtr1 = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
+    const u8 *jumpPtr2 = BSScriptReadPtr(gBattlescriptCurrInstr + 5);
 
-    u16 ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterId], gBattlescriptCurrInstr[9]);
+    u16 ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterMonId], gBattlescriptCurrInstr[9]);
     while (ret == 0xFFFE)
-        ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterId], 0);
+        ret = MonTryLearningNewMove(&gPlayerParty[gBattleStruct->expGetterMonId], 0);
 
     if (ret == 0)
     {
@@ -6086,20 +5946,20 @@ static void atk59_learnmove_inbattle(void)
     }
     else
     {
-        gActiveBank = GetBankByIdentity(0);
+        gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
 
-        if (gBattlePartyID[gActiveBank] == gBattleStruct->expGetterId
-            && !(gBattleMons[gActiveBank].status2 & STATUS2_TRANSFORMED))
+        if (gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterMonId
+            && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
         {
-            GiveMoveToBattleMon(&gBattleMons[gActiveBank], ret);
+            GiveMoveToBattleMon(&gBattleMons[gActiveBattler], ret);
         }
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
         {
-            gActiveBank = GetBankByIdentity(2);
-            if (gBattlePartyID[gActiveBank] == gBattleStruct->expGetterId
-                && !(gBattleMons[gActiveBank].status2 & STATUS2_TRANSFORMED))
+            gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
+            if (gBattlerPartyIndexes[gActiveBattler] == gBattleStruct->expGetterMonId
+                && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
             {
-                GiveMoveToBattleMon(&gBattleMons[gActiveBank], ret);
+                GiveMoveToBattleMon(&gBattleMons[gActiveBattler], ret);
             }
         }
 
@@ -6109,7 +5969,7 @@ static void atk59_learnmove_inbattle(void)
 
 static void atk5A_yesnoboxlearnmove(void)
 {
-    gActiveBank = 0;
+    gActiveBattler = 0;
 
     switch (gBattleScripting.learnMoveState)
     {
@@ -6159,7 +6019,7 @@ static void atk5A_yesnoboxlearnmove(void)
         if (!gPaletteFade.active)
         {
             FreeAllWindowBuffers();
-            sub_81BFA38(gPlayerParty, gBattleStruct->expGetterId, gPlayerPartyCount - 1, ReshowBattleScreenAfterMenu, gMoveToLearn);
+            sub_81BFA38(gPlayerParty, gBattleStruct->expGetterMonId, gPlayerPartyCount - 1, ReshowBattleScreenAfterMenu, gMoveToLearn);
             gBattleScripting.learnMoveState++;
         }
         break;
@@ -6179,10 +6039,10 @@ static void atk5A_yesnoboxlearnmove(void)
             }
             else
             {
-                u16 moveId = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_MOVE1 + movePosition);
+                u16 moveId = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_MOVE1 + movePosition);
                 if (IsHMMove2(moveId))
                 {
-                    PrepareStringBattle(STRINGID_HMMOVESCANTBEFORGOTTEN, gActiveBank);
+                    PrepareStringBattle(STRINGID_HMMOVESCANTBEFORGOTTEN, gActiveBattler);
                     gBattleScripting.learnMoveState = 6;
                 }
                 else
@@ -6191,10 +6051,10 @@ static void atk5A_yesnoboxlearnmove(void)
 
                     PREPARE_MOVE_BUFFER(gBattleTextBuff2, moveId)
 
-                    RemoveMonPPBonus(&gPlayerParty[gBattleStruct->expGetterId], movePosition);
-                    SetMonMoveSlot(&gPlayerParty[gBattleStruct->expGetterId], gMoveToLearn, movePosition);
+                    RemoveMonPPBonus(&gPlayerParty[gBattleStruct->expGetterMonId], movePosition);
+                    SetMonMoveSlot(&gPlayerParty[gBattleStruct->expGetterMonId], gMoveToLearn, movePosition);
 
-                    if (gBattlePartyID[0] == gBattleStruct->expGetterId
+                    if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId
                         && !(gBattleMons[0].status2 & STATUS2_TRANSFORMED)
                         && !(gDisableStructs[0].unk18_b & gBitTable[movePosition]))
                     {
@@ -6202,7 +6062,7 @@ static void atk5A_yesnoboxlearnmove(void)
                         SetBattleMonMoveSlot(&gBattleMons[0], gMoveToLearn, movePosition);
                     }
                     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE
-                        && gBattlePartyID[2] == gBattleStruct->expGetterId
+                        && gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId
                         && !(gBattleMons[2].status2 & STATUS2_TRANSFORMED)
                         && !(gDisableStructs[2].unk18_b & gBitTable[movePosition]))
                     {
@@ -6218,7 +6078,7 @@ static void atk5A_yesnoboxlearnmove(void)
         gBattlescriptCurrInstr += 5;
         break;
     case 6:
-        if (gBattleExecBuffer == 0)
+        if (gBattleControllerExecFlags == 0)
         {
             gBattleScripting.learnMoveState = 2;
         }
@@ -6275,16 +6135,16 @@ static void atk5B_yesnoboxstoplearningmove(void)
 
 static void atk5C_hitanimation(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    if (gBattleMoveFlags & MOVESTATUS_NOEFFECT)
+    if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT)
     {
         gBattlescriptCurrInstr += 2;
     }
-    else if (!(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE) || !(gBattleMons[gActiveBank].status2 & STATUS2_SUBSTITUTE) || gDisableStructs[gActiveBank].substituteHP == 0)
+    else if (!(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE) || !(gBattleMons[gActiveBattler].status2 & STATUS2_SUBSTITUTE) || gDisableStructs[gActiveBattler].substituteHP == 0)
     {
-        EmitHitAnimation(0);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitHitAnimation(0);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 2;
     }
     else
@@ -6301,7 +6161,7 @@ static u32 GetTrainerMoneyToGive(u16 trainerId)
 
     if (trainerId == SECRET_BASE_OPPONENT)
     {
-        moneyReward = 20 * gBattleResources->secretBase->partyLevels[0] * gBattleStruct->moneyMultiplier;
+        moneyReward = 20 * gBattleResources->secretBase->party.levels[0] * gBattleStruct->moneyMultiplier;
     }
     else
     {
@@ -6313,19 +6173,19 @@ static u32 GetTrainerMoneyToGive(u16 trainerId)
                 lastMonLevel = party[gTrainers[trainerId].partySize - 1].lvl;
             }
             break;
-        case PARTY_FLAG_CUSTOM_MOVES:
+        case F_TRAINER_PARTY_CUSTOM_MOVESET:
             {
                 const struct TrainerMonNoItemCustomMoves *party = gTrainers[trainerId].party.NoItemCustomMoves;
                 lastMonLevel = party[gTrainers[trainerId].partySize - 1].lvl;
             }
             break;
-        case PARTY_FLAG_HAS_ITEM:
+        case F_TRAINER_PARTY_HELD_ITEM:
             {
                 const struct TrainerMonItemDefaultMoves *party = gTrainers[trainerId].party.ItemDefaultMoves;
                 lastMonLevel = party[gTrainers[trainerId].partySize - 1].lvl;
             }
             break;
-        case PARTY_FLAG_CUSTOM_MOVES | PARTY_FLAG_HAS_ITEM:
+        case F_TRAINER_PARTY_CUSTOM_MOVESET | F_TRAINER_PARTY_HELD_ITEM:
             {
                 const struct TrainerMonItemCustomMoves *party = gTrainers[trainerId].party.ItemCustomMoves;
                 lastMonLevel = party[gTrainers[trainerId].partySize - 1].lvl;
@@ -6363,26 +6223,26 @@ static void atk5D_getmoneyreward(void)
     gBattlescriptCurrInstr++;
 }
 
-static void atk5E_8025A70(void)
+static void atk5E(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
     switch (gBattleCommunication[0])
     {
     case 0:
-        EmitGetMonData(0, REQUEST_ALL_BATTLE, 0);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitGetMonData(0, REQUEST_ALL_BATTLE, 0);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattleCommunication[0]++;
         break;
     case 1:
-         if (gBattleExecBuffer == 0)
+         if (gBattleControllerExecFlags == 0)
          {
             s32 i;
-            struct BattlePokemon* bufferPoke = (struct BattlePokemon*) &gBattleBufferB[gActiveBank][4];
+            struct BattlePokemon* bufferPoke = (struct BattlePokemon*) &gBattleBufferB[gActiveBattler][4];
             for (i = 0; i < 4; i++)
             {
-                gBattleMons[gActiveBank].moves[i] = bufferPoke->moves[i];
-                gBattleMons[gActiveBank].pp[i] = bufferPoke->pp[i];
+                gBattleMons[gActiveBattler].moves[i] = bufferPoke->moves[i];
+                gBattleMons[gActiveBattler].pp[i] = bufferPoke->pp[i];
             }
             gBattlescriptCurrInstr += 2;
          }
@@ -6390,11 +6250,11 @@ static void atk5E_8025A70(void)
     }
 }
 
-static void atk5F_8025B24(void)
+static void atk5F(void)
 {
-    gActiveBank = gBankAttacker;
-    gBankAttacker = gBankTarget;
-    gBankTarget = gActiveBank;
+    gActiveBattler = gBattlerAttacker;
+    gBattlerAttacker = gBattlerTarget;
+    gBattlerTarget = gActiveBattler;
 
     if (gHitMarker & HITMARKER_PURSUIT_TRAP)
         gHitMarker &= ~(HITMARKER_PURSUIT_TRAP);
@@ -6404,26 +6264,26 @@ static void atk5F_8025B24(void)
     gBattlescriptCurrInstr++;
 }
 
-static void atk60_increment_gamestat(void)
+static void atk60_incrementgamestat(void)
 {
-    if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
+    if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
         IncrementGameStat(gBattlescriptCurrInstr[1]);
 
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk61_draw_party_status_summary(void)
+static void atk61_drawpartystatussummary(void)
 {
     s32 i;
     struct Pokemon* party;
     struct HpAndStatus hpStatuses[6];
 
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -6443,42 +6303,42 @@ static void atk61_draw_party_status_summary(void)
         }
     }
 
-    EmitDrawPartyStatusSummary(0, hpStatuses, 1);
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitDrawPartyStatusSummary(0, hpStatuses, 1);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk62_08025C6C(void)
+static void atk62(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    EmitCmd49(0);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    BtlController_EmitCmd49(0);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
 static void atk63_jumptorandomattack(void)
 {
-    if (gBattlescriptCurrInstr[1] != 0)
+    if (gBattlescriptCurrInstr[1])
         gCurrentMove = gRandomMove;
     else
-        gLastUsedMove = gCurrentMove = gRandomMove;
+        gChosenMove = gCurrentMove = gRandomMove;
 
     gBattlescriptCurrInstr = gBattleScriptsForMoveEffects[gBattleMoves[gCurrentMove].effect];
 }
 
 static void atk64_statusanimation(void)
 {
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        if (!(gStatuses3[gActiveBank] & STATUS3_SEMI_INVULNERABLE)
-            && gDisableStructs[gActiveBank].substituteHP == 0
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE)
+            && gDisableStructs[gActiveBattler].substituteHP == 0
             && !(gHitMarker & HITMARKER_NO_ANIMATIONS))
         {
-            EmitStatusAnimation(0, FALSE, gBattleMons[gActiveBank].status1);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitStatusAnimation(0, FALSE, gBattleMons[gActiveBattler].status1);
+            MarkBattlerForControllerExec(gActiveBattler);
         }
         gBattlescriptCurrInstr += 2;
     }
@@ -6488,16 +6348,16 @@ static void atk65_status2animation(void)
 {
     u32 wantedToAnimate;
 
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
         wantedToAnimate = BSScriptRead32(gBattlescriptCurrInstr + 2);
-        if (!(gStatuses3[gActiveBank] & STATUS3_SEMI_INVULNERABLE)
-            && gDisableStructs[gActiveBank].substituteHP == 0
+        if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE)
+            && gDisableStructs[gActiveBattler].substituteHP == 0
             && !(gHitMarker & HITMARKER_NO_ANIMATIONS))
         {
-            EmitStatusAnimation(0, TRUE, gBattleMons[gActiveBank].status2 & wantedToAnimate);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitStatusAnimation(0, TRUE, gBattleMons[gActiveBattler].status2 & wantedToAnimate);
+            MarkBattlerForControllerExec(gActiveBattler);
         }
         gBattlescriptCurrInstr += 6;
     }
@@ -6507,16 +6367,16 @@ static void atk66_chosenstatusanimation(void)
 {
     u32 wantedStatus;
 
-    if (gBattleExecBuffer == 0)
+    if (gBattleControllerExecFlags == 0)
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
         wantedStatus = BSScriptRead32(gBattlescriptCurrInstr + 3);
-        if (!(gStatuses3[gActiveBank] & STATUS3_SEMI_INVULNERABLE)
-            && gDisableStructs[gActiveBank].substituteHP == 0
+        if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE)
+            && gDisableStructs[gActiveBattler].substituteHP == 0
             && !(gHitMarker & HITMARKER_NO_ANIMATIONS))
         {
-            EmitStatusAnimation(0, gBattlescriptCurrInstr[2], wantedStatus);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitStatusAnimation(0, gBattlescriptCurrInstr[2], wantedStatus);
+            MarkBattlerForControllerExec(gActiveBattler);
         }
         gBattlescriptCurrInstr += 7;
     }
@@ -6565,56 +6425,57 @@ static void atk67_yesnobox(void)
     }
 }
 
-static void atk68_80246A0(void)
+static void atk68_cancelallactions(void)
 {
     s32 i;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
-        gActionsByTurnOrder[i] = ACTION_CANCEL_PARTNER;
+    for (i = 0; i < gBattlersCount; i++)
+        gActionsByTurnOrder[i] = B_ACTION_CANCEL_PARTNER;
 
     gBattlescriptCurrInstr++;
 }
 
-static void atk69_dmg_adjustment3(void) // The same as 0x7, except there's no random damage multiplier.
+static void atk69_adjustsetdamage(void) // The same as 0x7, except there's no random damage multiplier.
 {
-    u8 holdEffect, quality;
+    u8 holdEffect, param;
 
-    if (gBattleMons[gBankTarget].item == ITEM_ENIGMA_BERRY)
+    if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
     {
-        holdEffect = gEnigmaBerries[gBankTarget].holdEffect, quality = gEnigmaBerries[gBankTarget].holdEffectParam;
+        holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect;
+        param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     }
     else
     {
-        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBankTarget].item);
-        quality = ItemId_GetHoldEffectParam(gBattleMons[gBankTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
-    gStringBank = gBankTarget;
+    gPotentialItemEffectBattler = gBattlerTarget;
 
-    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < quality)
+    if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemEffectBattle(gBankTarget, holdEffect);
-        gSpecialStatuses[gBankTarget].focusBanded = 1;
+        RecordItemEffectBattle(gBattlerTarget, holdEffect);
+        gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
-    if (gBattleMons[gBankTarget].status2 & STATUS2_SUBSTITUTE)
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE)
         goto END;
-    if (gBattleMoves[gCurrentMove].effect != EFFECT_FALSE_SWIPE && !gProtectStructs[gBankTarget].endured
-     && !gSpecialStatuses[gBankTarget].focusBanded)
+    if (gBattleMoves[gCurrentMove].effect != EFFECT_FALSE_SWIPE && !gProtectStructs[gBattlerTarget].endured
+     && !gSpecialStatuses[gBattlerTarget].focusBanded)
         goto END;
 
-    if (gBattleMons[gBankTarget].hp > gBattleMoveDamage)
+    if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
         goto END;
 
-    gBattleMoveDamage = gBattleMons[gBankTarget].hp - 1;
+    gBattleMoveDamage = gBattleMons[gBattlerTarget].hp - 1;
 
-    if (gProtectStructs[gBankTarget].endured)
+    if (gProtectStructs[gBattlerTarget].endured)
     {
-        gBattleMoveFlags |= MOVESTATUS_ENDURED;
+        gMoveResultFlags |= MOVE_RESULT_FOE_ENDURED;
     }
-    else if (gSpecialStatuses[gBankTarget].focusBanded)
+    else if (gSpecialStatuses[gBattlerTarget].focusBanded)
     {
-        gBattleMoveFlags |= MOVESTATUS_HUNGON;
-        gLastUsedItem = gBattleMons[gBankTarget].item;
+        gMoveResultFlags |= MOVE_RESULT_FOE_HUNG_ON;
+        gLastUsedItem = gBattleMons[gBattlerTarget].item;
     }
 
     END:
@@ -6625,26 +6486,26 @@ static void atk6A_removeitem(void)
 {
     u16* usedHeldItem;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    usedHeldItem = &gBattleStruct->usedHeldItems[gActiveBank];
-    *usedHeldItem = gBattleMons[gActiveBank].item;
-    gBattleMons[gActiveBank].item = 0;
+    usedHeldItem = &gBattleStruct->usedHeldItems[gActiveBattler];
+    *usedHeldItem = gBattleMons[gActiveBattler].item;
+    gBattleMons[gActiveBattler].item = 0;
 
-    EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gActiveBank].item);
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gActiveBattler].item);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
 static void atk6B_atknameinbuff1(void)
 {
-    PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, gBankAttacker, gBattlePartyID[gBankAttacker])
+    PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, gBattlerAttacker, gBattlerPartyIndexes[gBattlerAttacker])
 
     gBattlescriptCurrInstr++;
 }
 
-static void atk6C_draw_lvlupbox(void)
+static void atk6C_drawlvlupbox(void)
 {
     if (gBattleScripting.atk6C_state == 0)
     {
@@ -6740,7 +6601,7 @@ static void sub_804F100(void)
 {
     struct StatsArray currentStats;
 
-    sub_81D388C(&gPlayerParty[gBattleStruct->expGetterId], &currentStats);
+    sub_81D388C(&gPlayerParty[gBattleStruct->expGetterMonId], &currentStats);
     sub_81D3640(0xD, gBattleResources->statsBeforeLvlUp, &currentStats, 0xE, 0xD, 0xF);
 }
 
@@ -6748,7 +6609,7 @@ static void sub_804F144(void)
 {
     struct StatsArray currentStats;
 
-    sub_81D388C(&gPlayerParty[gBattleStruct->expGetterId], &currentStats);
+    sub_81D388C(&gPlayerParty[gBattleStruct->expGetterMonId], &currentStats);
     sub_81D3784(0xD, &currentStats, 0xE, 0xD, 0xF);
 }
 
@@ -6791,9 +6652,9 @@ static void PutLevelAndGenderOnLvlUpBox(void)
     u8 *txtPtr;
     u32 var;
 
-    monLevel = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_LEVEL);
-    monGender = GetMonGender(&gPlayerParty[gBattleStruct->expGetterId]);
-    GetMonNickname(&gPlayerParty[gBattleStruct->expGetterId], gStringVar4);
+    monLevel = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL);
+    monGender = GetMonGender(&gPlayerParty[gBattleStruct->expGetterMonId]);
+    GetMonNickname(&gPlayerParty[gBattleStruct->expGetterMonId], gStringVar4);
 
     subPrinter.current_text_offset = gStringVar4;
     subPrinter.windowId = 14;
@@ -6805,7 +6666,7 @@ static void PutLevelAndGenderOnLvlUpBox(void)
     subPrinter.letterSpacing = 0;
     subPrinter.lineSpacing = 0;
     subPrinter.fontColor_l = TEXT_COLOR_TRANSPARENT;
-    subPrinter.fontColor_h = TEXT_COLOR_WHITE;
+    subPrinter.fgColor = TEXT_COLOR_WHITE;
     subPrinter.bgColor = TEXT_COLOR_TRANSPARENT;
     subPrinter.shadowColor = TEXT_COLOR_DARK_GREY;
 
@@ -6859,8 +6720,8 @@ static bool8 sub_804F344(void)
     return (gBattle_BG2_X != 0x1A0);
 }
 
-#define sDestroy                    data0
-#define sSavedLvlUpBoxXPosition     data1
+#define sDestroy                    data[0]
+#define sSavedLvlUpBoxXPosition     data[1]
 
 static void PutMonIconOnLvlUpBox(void)
 {
@@ -6869,8 +6730,8 @@ static void PutMonIconOnLvlUpBox(void)
     struct SpriteSheet iconSheet;
     struct SpritePalette iconPalSheet;
 
-    u16 species = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_SPECIES);
-    u32 personality = GetMonData(&gPlayerParty[gBattleStruct->expGetterId], MON_DATA_PERSONALITY);
+    u16 species = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPECIES);
+    u32 personality = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_PERSONALITY);
 
     const u8* iconPtr = GetMonIconPtr(species, personality, 1);
     iconSheet.data = iconPtr;
@@ -6910,40 +6771,40 @@ static void SpriteCB_MonIconOnLvlUpBox(struct Sprite* sprite)
 
 static bool32 IsMonGettingExpSentOut(void)
 {
-    if (gBattlePartyID[0] == gBattleStruct->expGetterId)
+    if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId)
         return TRUE;
-    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && gBattlePartyID[2] == gBattleStruct->expGetterId)
+    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId)
         return TRUE;
 
     return FALSE;
 }
 
-static void atk6D_reset_sentpokes_value(void)
+static void atk6D_resetsentmonsvalue(void)
 {
     ResetSentPokesToOpponentValue();
     gBattlescriptCurrInstr++;
 }
 
-static void atk6E_set_atk_to_player0(void)
+static void atk6E_setatktoplayer0(void)
 {
-    gBankAttacker = GetBankByIdentity(0);
+    gBattlerAttacker = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
     gBattlescriptCurrInstr++;
 }
 
-static void atk6F_set_visible(void)
+static void atk6F_makevisible(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    EmitSpriteInvisibility(0, FALSE);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    BtlController_EmitSpriteInvisibility(0, FALSE);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk70_record_last_used_ability(void)
+static void atk70_recordlastability(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-    RecordAbilityBattle(gActiveBank, gLastUsedAbility);
-    gBattlescriptCurrInstr += 1; // UB: Should be + 2, one byte for command and one byte for bank argument.
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+    RecordAbilityBattle(gActiveBattler, gLastUsedAbility);
+    gBattlescriptCurrInstr += 1; // UB: Should be + 2, one byte for command and one byte for battlerId argument.
 }
 
 void BufferMoveToLearnIntoBattleTextBuff2(void)
@@ -6951,29 +6812,29 @@ void BufferMoveToLearnIntoBattleTextBuff2(void)
     PREPARE_MOVE_BUFFER(gBattleTextBuff2, gMoveToLearn);
 }
 
-static void atk71_buffer_move_to_learn(void)
+static void atk71_buffermovetolearn(void)
 {
     BufferMoveToLearnIntoBattleTextBuff2();
     gBattlescriptCurrInstr++;
 }
 
-static void atk72_jump_if_run_attempt_success(void)
+static void atk72_jumpifplayerran(void)
 {
-    if (TryRunFromBattle(gBank1))
+    if (TryRunFromBattle(gBattlerFainted))
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     else
         gBattlescriptCurrInstr += 5;
 }
 
-static void atk73_hp_thresholds(void)
+static void atk73_hpthresholds(void)
 {
     u8 opposingBank;
     s32 result;
 
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        opposingBank = gActiveBank ^ BIT_SIDE;
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        opposingBank = gActiveBattler ^ BIT_SIDE;
 
         result = gBattleMons[opposingBank].hp * 100 / gBattleMons[opposingBank].maxHP;
         if (result == 0)
@@ -6992,7 +6853,7 @@ static void atk73_hp_thresholds(void)
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk74_hp_thresholds2(void)
+static void atk74_hpthresholds2(void)
 {
     u8 opposingBank;
     s32 result;
@@ -7000,9 +6861,9 @@ static void atk74_hp_thresholds2(void)
 
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        opposingBank = gActiveBank ^ BIT_SIDE;
-        hpSwitchout = *(gBattleStruct->hpOnSwitchout + GetBankSide(opposingBank));
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        opposingBank = gActiveBattler ^ BIT_SIDE;
+        hpSwitchout = *(gBattleStruct->hpOnSwitchout + GetBattlerSide(opposingBank));
         result = (hpSwitchout - gBattleMons[opposingBank].hp) * 100 / hpSwitchout;
 
         if (gBattleMons[opposingBank].hp >= hpSwitchout)
@@ -7018,10 +6879,10 @@ static void atk74_hp_thresholds2(void)
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk75_item_effect_on_opponent(void)
+static void atk75_useitemonopponent(void)
 {
-    gBankInMenu = gBankAttacker;
-    ExecuteTableBasedItemEffect(&gEnemyParty[gBattlePartyID[gBankAttacker]], gLastUsedItem, gBattlePartyID[gBankAttacker], 0, 1);
+    gBattlerInMenuId = gBattlerAttacker;
+    ExecuteTableBasedItemEffect(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker]], gLastUsedItem, gBattlerPartyIndexes[gBattlerAttacker], 0, 1);
 
     gBattlescriptCurrInstr += 1;
 }
@@ -7031,52 +6892,52 @@ static void atk76_various(void)
     u8 side;
     s32 i;
 
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
     switch (gBattlescriptCurrInstr[2])
     {
     case VARIOUS_CANCEL_MULTI_TURN_MOVES:
-        CancelMultiTurnMoves(gActiveBank);
+        CancelMultiTurnMoves(gActiveBattler);
         break;
     case VARIOUS_SET_MAGIC_COAT_TARGET:
-        gBankAttacker = gBankTarget;
-        side = GetBankSide(gBankAttacker) ^ 1;
+        gBattlerAttacker = gBattlerTarget;
+        side = GetBattlerSide(gBattlerAttacker) ^ BIT_SIDE;
         if (gSideTimers[side].followmeTimer != 0 && gBattleMons[gSideTimers[side].followmeTarget].hp != 0)
-            gBankTarget = gSideTimers[side].followmeTarget;
+            gBattlerTarget = gSideTimers[side].followmeTarget;
         else
-            gBankTarget = gActiveBank;
+            gBattlerTarget = gActiveBattler;
         break;
-    case VARIOUS_CAN_RUN_FROM_BATTLE:
+    case VARIOUS_IS_RUNNING_IMPOSSIBLE:
         gBattleCommunication[0] = IsRunningFromBattleImpossible();
         break;
     case VARIOUS_GET_MOVE_TARGET:
-        gBankTarget = GetMoveTarget(gCurrentMove, 0);
+        gBattlerTarget = GetMoveTarget(gCurrentMove, 0);
         break;
     case 4:
-        if (gHitMarker & HITMARKER_FAINTED(gActiveBank))
+        if (gHitMarker & HITMARKER_FAINTED(gActiveBattler))
             gBattleCommunication[0] = 1;
         else
             gBattleCommunication[0] = 0;
         break;
     case VARIOUS_RESET_INTIMIDATE_TRACE_BITS:
-        gSpecialStatuses[gActiveBank].intimidatedPoke = 0;
-        gSpecialStatuses[gActiveBank].traced = 0;
+        gSpecialStatuses[gActiveBattler].intimidatedPoke = 0;
+        gSpecialStatuses[gActiveBattler].traced = 0;
         break;
     case VARIOUS_UPDATE_CHOICE_MOVE_ON_LVL_UP:
-        if (gBattlePartyID[0] == gBattleStruct->expGetterId || gBattlePartyID[2] == gBattleStruct->expGetterId)
+        if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId || gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId)
         {
             u16 *choicedMove;
 
-            if (gBattlePartyID[0] == gBattleStruct->expGetterId)
-                gActiveBank = 0;
+            if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId)
+                gActiveBattler = 0;
             else
-                gActiveBank = 2;
+                gActiveBattler = 2;
 
-            choicedMove = &gBattleStruct->choicedMove[gActiveBank];
+            choicedMove = &gBattleStruct->choicedMove[gActiveBattler];
 
             for (i = 0; i < 4; i++)
             {
-                if (gBattleMons[gActiveBank].moves[i] == *choicedMove)
+                if (gBattleMons[gActiveBattler].moves[i] == *choicedMove)
                     break;
             }
             if (i == 4)
@@ -7094,15 +6955,15 @@ static void atk76_various(void)
         break;
     case 8:
         gBattleCommunication[0] = 0;
-        gBattleScripting.bank = gActiveBank = gBattleCommunication[1];
-        if (!(gBattleStruct->field_92 & gBitTable[gActiveBank])
-            && gBattleMons[gActiveBank].maxHP / 2 >= gBattleMons[gActiveBank].hp
-            && gBattleMons[gActiveBank].hp != 0
-            && !(gBattleMons[gActiveBank].status1 & STATUS_SLEEP))
+        gBattleScripting.battler = gActiveBattler = gBattleCommunication[1];
+        if (!(gBattleStruct->field_92 & gBitTable[gActiveBattler])
+            && gBattleMons[gActiveBattler].maxHP / 2 >= gBattleMons[gActiveBattler].hp
+            && gBattleMons[gActiveBattler].hp != 0
+            && !(gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP))
         {
-            gBattleStruct->field_92 |= gBitTable[gActiveBank];
+            gBattleStruct->field_92 |= gBitTable[gActiveBattler];
             gBattleCommunication[0] = 1;
-            gBattleCommunication[MULTISTRING_CHOOSER] = sUnknown_0831C4F8[GetNatureFromPersonality(gBattleMons[gActiveBank].personality)];
+            gBattleCommunication[MULTISTRING_CHOOSER] = sUnknown_0831C4F8[GetNatureFromPersonality(gBattleMons[gActiveBattler].personality)];
         }
         break;
     case 9:
@@ -7115,14 +6976,14 @@ static void atk76_various(void)
     case 10:
         gBattleMons[1].hp = 0;
         gHitMarker |= HITMARKER_FAINTED(1);
-        gBattleStruct->field_2A1 |= gBitTable[gBattlePartyID[1]];
+        gBattleStruct->field_2A1 |= gBitTable[gBattlerPartyIndexes[1]];
         gDisableStructs[1].truantUnknownBit = 1;
         break;
     case 11:
         gBattleMons[0].hp = 0;
         gHitMarker |= HITMARKER_FAINTED(0);
         gHitMarker |= HITMARKER_x400000;
-        gBattleStruct->field_2A0 |= gBitTable[gBattlePartyID[0]];
+        gBattleStruct->field_2A0 |= gBitTable[gBattlerPartyIndexes[0]];
         gDisableStructs[0].truantUnknownBit = 1;
         break;
     case 12:
@@ -7131,14 +6992,14 @@ static void atk76_various(void)
         gHitMarker |= HITMARKER_FAINTED(0);
         gHitMarker |= HITMARKER_FAINTED(1);
         gHitMarker |= HITMARKER_x400000;
-        gBattleStruct->field_2A0 |= gBitTable[gBattlePartyID[0]];
-        gBattleStruct->field_2A1 |= gBitTable[gBattlePartyID[1]];
+        gBattleStruct->field_2A0 |= gBitTable[gBattlerPartyIndexes[0]];
+        gBattleStruct->field_2A1 |= gBitTable[gBattlerPartyIndexes[1]];
         gDisableStructs[0].truantUnknownBit = 1;
         gDisableStructs[1].truantUnknownBit = 1;
         break;
     case VARIOUS_EMIT_YESNOBOX:
-        EmitUnknownYesNoBox(0);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitUnknownYesNoBox(0);
+        MarkBattlerForControllerExec(gActiveBattler);
         break;
     case 14:
         sub_81A5BF8();
@@ -7159,82 +7020,82 @@ static void atk76_various(void)
             return;
         break;
     case VARIOUS_RETURN_OPPONENT_MON1:
-        gActiveBank = 1;
-        if (gBattleMons[gActiveBank].hp != 0)
+        gActiveBattler = 1;
+        if (gBattleMons[gActiveBattler].hp != 0)
         {
-            EmitReturnMonToBall(0, 0);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitReturnMonToBall(0, 0);
+            MarkBattlerForControllerExec(gActiveBattler);
         }
         break;
     case VARIOUS_RETURN_OPPONENT_MON2:
-        if (gNoOfAllBanks > 3)
+        if (gBattlersCount > 3)
         {
-            gActiveBank = 3;
-            if (gBattleMons[gActiveBank].hp != 0)
+            gActiveBattler = 3;
+            if (gBattleMons[gActiveBattler].hp != 0)
             {
-                EmitReturnMonToBall(0, 0);
-                MarkBufferBankForExecution(gActiveBank);
+                BtlController_EmitReturnMonToBall(0, 0);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
         }
         break;
     case 21:
-        m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x55);
+        m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0x55);
         break;
     case 22:
-        m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100);
+        m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0x100);
         break;
     case 23:
-        gBattleStruct->field_2A2 |= gBitTable[gActiveBank];
+        gBattleStruct->field_2A2 |= gBitTable[gActiveBattler];
         break;
     case 24:
-        if (sub_805725C(gActiveBank))
+        if (sub_805725C(gActiveBattler))
             return;
         break;
     case VARIOUS_SET_TELEPORT_OUTCOME:
-        if (GetBankSide(gActiveBank) == SIDE_PLAYER)
-            gBattleOutcome = BATTLE_PLAYER_TELEPORTED;
+        if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
+            gBattleOutcome = B_OUTCOME_PLAYER_TELEPORTED;
         else
-            gBattleOutcome = BATTLE_OPPONENT_TELEPORTED;
+            gBattleOutcome = B_OUTCOME_MON_TELEPORTED;
         break;
     case VARIOUS_PLAY_TRAINER_DEFEATED_MUSIC:
-        EmitPlayFanfareOrBGM(0, BGM_KACHI1, TRUE);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitPlayFanfareOrBGM(0, MUS_KACHI1, TRUE);
+        MarkBattlerForControllerExec(gActiveBattler);
         break;
     }
 
     gBattlescriptCurrInstr += 3;
 }
 
-static void atk77_set_protect_like(void) // protect and endure
+static void atk77_setprotectlike(void) // protect and endure
 {
     bool8 notLastTurn = TRUE;
-    u16 lastMove = gUnknown_02024260[gBankAttacker];
+    u16 lastMove = gLastResultingMoves[gBattlerAttacker];
 
     if (lastMove != MOVE_PROTECT && lastMove != MOVE_DETECT && lastMove != MOVE_ENDURE)
-        gDisableStructs[gBankAttacker].protectUses = 0;
+        gDisableStructs[gBattlerAttacker].protectUses = 0;
 
-    if (gCurrentTurnActionNumber == (gNoOfAllBanks - 1))
+    if (gCurrentTurnActionNumber == (gBattlersCount - 1))
         notLastTurn = FALSE;
 
-    if (sProtectSuccessRates[gDisableStructs[gBankAttacker].protectUses] >= Random() && notLastTurn)
+    if (sProtectSuccessRates[gDisableStructs[gBattlerAttacker].protectUses] >= Random() && notLastTurn)
     {
         if (gBattleMoves[gCurrentMove].effect == EFFECT_PROTECT)
         {
-            gProtectStructs[gBankAttacker].protected = 1;
+            gProtectStructs[gBattlerAttacker].protected = 1;
             gBattleCommunication[MULTISTRING_CHOOSER] = 0;
         }
         if (gBattleMoves[gCurrentMove].effect == EFFECT_ENDURE)
         {
-            gProtectStructs[gBankAttacker].endured = 1;
+            gProtectStructs[gBattlerAttacker].endured = 1;
             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
         }
-        gDisableStructs[gBankAttacker].protectUses++;
+        gDisableStructs[gBattlerAttacker].protectUses++;
     }
     else
     {
-        gDisableStructs[gBankAttacker].protectUses = 0;
+        gDisableStructs[gBattlerAttacker].protectUses = 0;
         gBattleCommunication[MULTISTRING_CHOOSER] = 2;
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
     }
 
     gBattlescriptCurrInstr++;
@@ -7242,88 +7103,90 @@ static void atk77_set_protect_like(void) // protect and endure
 
 static void atk78_faintifabilitynotdamp(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    for (gBankTarget = 0; gBankTarget < gNoOfAllBanks; gBankTarget++)
+    for (gBattlerTarget = 0; gBattlerTarget < gBattlersCount; gBattlerTarget++)
     {
-        if (gBattleMons[gBankTarget].ability == ABILITY_DAMP)
+        if (gBattleMons[gBattlerTarget].ability == ABILITY_DAMP)
             break;
     }
 
-    if (gBankTarget == gNoOfAllBanks)
+    if (gBattlerTarget == gBattlersCount)
     {
-        gActiveBank = gBankAttacker;
-        gBattleMoveDamage = gBattleMons[gActiveBank].hp;
-        EmitHealthBarUpdate(0, INSTANT_HP_BAR_DROP);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = gBattlerAttacker;
+        gBattleMoveDamage = gBattleMons[gActiveBattler].hp;
+        BtlController_EmitHealthBarUpdate(0, INSTANT_HP_BAR_DROP);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr++;
 
-        for (gBankTarget = 0; gBankTarget < gNoOfAllBanks; gBankTarget++)
+        for (gBattlerTarget = 0; gBattlerTarget < gBattlersCount; gBattlerTarget++)
         {
-            if (gBankTarget == gBankAttacker)
+            if (gBattlerTarget == gBattlerAttacker)
                 continue;
-            if (!(gAbsentBankFlags & gBitTable[gBankTarget]))
+            if (!(gAbsentBattlerFlags & gBitTable[gBattlerTarget]))
                 break;
         }
     }
     else
     {
         gLastUsedAbility = ABILITY_DAMP;
-        RecordAbilityBattle(gBankTarget, gBattleMons[gBankTarget].ability);
+        RecordAbilityBattle(gBattlerTarget, gBattleMons[gBattlerTarget].ability);
         gBattlescriptCurrInstr = BattleScript_DampStopsExplosion;
     }
 }
 
 static void atk79_setatkhptozero(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = gBankAttacker;
-    gBattleMons[gActiveBank].hp = 0;
-    EmitSetMonData(0, REQUEST_HP_BATTLE, 0, 2, &gBattleMons[gActiveBank].hp);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = gBattlerAttacker;
+    gBattleMons[gActiveBattler].hp = 0;
+    BtlController_EmitSetMonData(0, REQUEST_HP_BATTLE, 0, 2, &gBattleMons[gActiveBattler].hp);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr++;
 }
 
-static void atk7A_jumpwhiletargetvalid(void) // Used by intimidate to loop through all targets.
+static void atk7A_jumpifnexttargetvalid(void)
 {
-    const u8* jumpPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
+    const u8 *jumpPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
 
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
-        for (gBankTarget++; ; gBankTarget++)
+        for (gBattlerTarget++; ; gBattlerTarget++)
         {
-            if (gBankTarget == gBankAttacker)
+            if (gBattlerTarget == gBattlerAttacker)
                 continue;
-            if (!(gAbsentBankFlags & gBitTable[gBankTarget]))
+            if (!(gAbsentBattlerFlags & gBitTable[gBattlerTarget]))
                 break;
         }
 
-        if (gBankTarget >= gNoOfAllBanks)
+        if (gBattlerTarget >= gBattlersCount)
             gBattlescriptCurrInstr += 5;
         else
             gBattlescriptCurrInstr = jumpPtr;
     }
     else
+    {
         gBattlescriptCurrInstr += 5;
+    }
 }
 
-static void atk7B_healhalfHP_if_possible(void)
+static void atk7B_tryhealhalfhealth(void)
 {
     const u8* failPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
 
-    if (gBattlescriptCurrInstr[5] == BS_GET_ATTACKER)
-        gBankTarget = gBankAttacker;
+    if (gBattlescriptCurrInstr[5] == BS_ATTACKER)
+        gBattlerTarget = gBattlerAttacker;
 
-    gBattleMoveDamage = gBattleMons[gBankTarget].maxHP / 2;
+    gBattleMoveDamage = gBattleMons[gBattlerTarget].maxHP / 2;
     if (gBattleMoveDamage == 0)
         gBattleMoveDamage = 1;
     gBattleMoveDamage *= -1;
 
-    if (gBattleMons[gBankTarget].hp == gBattleMons[gBankTarget].maxHP)
+    if (gBattleMons[gBattlerTarget].hp == gBattleMons[gBattlerTarget].maxHP)
         gBattlescriptCurrInstr = failPtr;
     else
         gBattlescriptCurrInstr += 6;
@@ -7339,12 +7202,12 @@ static void atk7C_trymirrormove(void)
     for (i = 0; i < 3; i++)
         movesArray[i] = 0;
 
-    for (validMovesCount = 0, i = 0; i < gNoOfAllBanks; i++)
+    for (validMovesCount = 0, i = 0; i < gBattlersCount; i++)
     {
-        if (i != gBankAttacker)
+        if (i != gBattlerAttacker)
         {
-            move = *(i * 2 + gBankAttacker * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0)
-                | (*(i * 2 + gBankAttacker * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) << 8);
+            move = *(i * 2 + gBattlerAttacker * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0)
+                | (*(i * 2 + gBattlerAttacker * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) << 8);
 
             if (move != 0 && move != 0xFFFF)
             {
@@ -7354,14 +7217,14 @@ static void atk7C_trymirrormove(void)
         }
     }
 
-    move = *(gBattleStruct->mirrorMoves + gBankAttacker * 2 + 0)
-        | (*(gBattleStruct->mirrorMoves + gBankAttacker * 2 + 1) << 8);
+    move = *(gBattleStruct->mirrorMoves + gBattlerAttacker * 2 + 0)
+        | (*(gBattleStruct->mirrorMoves + gBattlerAttacker * 2 + 1) << 8);
 
     if (move != 0 && move != 0xFFFF)
     {
         gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
         gCurrentMove = move;
-        gBankTarget = GetMoveTarget(gCurrentMove, 0);
+        gBattlerTarget = GetMoveTarget(gCurrentMove, 0);
         gBattlescriptCurrInstr = gBattleScriptsForMoveEffects[gBattleMoves[gCurrentMove].effect];
     }
     else if (validMovesCount)
@@ -7369,21 +7232,21 @@ static void atk7C_trymirrormove(void)
         gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
         i = Random() % validMovesCount;
         gCurrentMove = movesArray[i];
-        gBankTarget = GetMoveTarget(gCurrentMove, 0);
+        gBattlerTarget = GetMoveTarget(gCurrentMove, 0);
         gBattlescriptCurrInstr = gBattleScriptsForMoveEffects[gBattleMoves[gCurrentMove].effect];
     }
     else
     {
-        gSpecialStatuses[gBankAttacker].flag20 = 1;
+        gSpecialStatuses[gBattlerAttacker].flag20 = 1;
         gBattlescriptCurrInstr++;
     }
 }
 
-static void atk7D_set_rain(void)
+static void atk7D_setrain(void)
 {
     if (gBattleWeather & WEATHER_RAIN_ANY)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 2;
     }
     else
@@ -7397,16 +7260,16 @@ static void atk7D_set_rain(void)
 
 static void atk7E_setreflect(void)
 {
-    if (gSideAffecting[GET_BANK_SIDE(gBankAttacker)] & SIDE_STATUS_REFLECT)
+    if (gSideStatuses[GET_BATTLER_SIDE(gBattlerAttacker)] & SIDE_STATUS_REFLECT)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     else
     {
-        gSideAffecting[GET_BANK_SIDE(gBankAttacker)] |= SIDE_STATUS_REFLECT;
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].reflectTimer = 5;
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].reflectBank = gBankAttacker;
+        gSideStatuses[GET_BATTLER_SIDE(gBattlerAttacker)] |= SIDE_STATUS_REFLECT;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].reflectTimer = 5;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].reflectBattlerId = gBattlerAttacker;
 
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && CountAliveMonsInBattle(BATTLE_ALIVE_ATK_SIDE) == 2)
             gBattleCommunication[MULTISTRING_CHOOSER] = 2;
@@ -7418,20 +7281,20 @@ static void atk7E_setreflect(void)
 
 static void atk7F_setseeded(void)
 {
-    if (gBattleMoveFlags & MOVESTATUS_NOEFFECT || gStatuses3[gBankTarget] & STATUS3_LEECHSEED)
+    if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT || gStatuses3[gBattlerTarget] & STATUS3_LEECHSEED)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 1;
     }
-    else if (gBattleMons[gBankTarget].type1 == TYPE_GRASS || gBattleMons[gBankTarget].type2 == TYPE_GRASS)
+    else if (gBattleMons[gBattlerTarget].type1 == TYPE_GRASS || gBattleMons[gBattlerTarget].type2 == TYPE_GRASS)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 2;
     }
     else
     {
-        gStatuses3[gBankTarget] |= gBankAttacker;
-        gStatuses3[gBankTarget] |= STATUS3_LEECHSEED;
+        gStatuses3[gBattlerTarget] |= gBattlerAttacker;
+        gStatuses3[gBattlerTarget] |= STATUS3_LEECHSEED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
 
@@ -7449,8 +7312,8 @@ static void atk80_manipulatedamage(void)
         gBattleMoveDamage /= 2;
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
-        if ((gBattleMons[gBankTarget].maxHP / 2) < gBattleMoveDamage)
-            gBattleMoveDamage = gBattleMons[gBankTarget].maxHP / 2;
+        if ((gBattleMons[gBattlerTarget].maxHP / 2) < gBattleMoveDamage)
+            gBattleMoveDamage = gBattleMons[gBattlerTarget].maxHP / 2;
         break;
     case ATK80_DMG_DOUBLED:
         gBattleMoveDamage *= 2;
@@ -7460,26 +7323,26 @@ static void atk80_manipulatedamage(void)
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk81_setrest(void)
+static void atk81_trysetrest(void)
 {
-    const u8* failJump = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
-    gActiveBank = gBankTarget = gBankAttacker;
-    gBattleMoveDamage = gBattleMons[gBankTarget].maxHP * (-1);
+    const u8 *failJump = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
+    gActiveBattler = gBattlerTarget = gBattlerAttacker;
+    gBattleMoveDamage = gBattleMons[gBattlerTarget].maxHP * (-1);
 
-    if (gBattleMons[gBankTarget].hp == gBattleMons[gBankTarget].maxHP)
+    if (gBattleMons[gBattlerTarget].hp == gBattleMons[gBattlerTarget].maxHP)
     {
         gBattlescriptCurrInstr = failJump;
     }
     else
     {
-        if (gBattleMons[gBankTarget].status1 & ((u8)(~STATUS_SLEEP)))
+        if (gBattleMons[gBattlerTarget].status1 & ((u8)(~STATUS1_SLEEP)))
             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
         else
             gBattleCommunication[MULTISTRING_CHOOSER] = 0;
 
-        gBattleMons[gBankTarget].status1 = 3;
-        EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBank].status1);
-        MarkBufferBankForExecution(gActiveBank);
+        gBattleMons[gBattlerTarget].status1 = 3;
+        BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 5;
     }
 }
@@ -7488,7 +7351,7 @@ static void atk82_jumpifnotfirstturn(void)
 {
     const u8* failJump = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
 
-    if (gDisableStructs[gBankAttacker].isFirstTurn)
+    if (gDisableStructs[gBattlerAttacker].isFirstTurn)
         gBattlescriptCurrInstr += 5;
     else
         gBattlescriptCurrInstr = failJump;
@@ -7499,20 +7362,20 @@ static void atk83_nop(void)
     gBattlescriptCurrInstr++;
 }
 
-bool8 UproarWakeUpCheck(u8 bank)
+bool8 UproarWakeUpCheck(u8 battlerId)
 {
     s32 i;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
-        if (!(gBattleMons[i].status2 & STATUS2_UPROAR) || gBattleMons[bank].ability == ABILITY_SOUNDPROOF)
+        if (!(gBattleMons[i].status2 & STATUS2_UPROAR) || gBattleMons[battlerId].ability == ABILITY_SOUNDPROOF)
             continue;
 
-        gBattleScripting.bank = i;
+        gBattleScripting.battler = i;
 
-        if (gBankTarget == 0xFF)
-            gBankTarget = i;
-        else if (gBankTarget == i)
+        if (gBattlerTarget == 0xFF)
+            gBattlerTarget = i;
+        else if (gBattlerTarget == i)
             gBattleCommunication[MULTISTRING_CHOOSER] = 0;
         else
             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
@@ -7520,27 +7383,27 @@ bool8 UproarWakeUpCheck(u8 bank)
         break;
     }
 
-    if (i == gNoOfAllBanks)
+    if (i == gBattlersCount)
         return FALSE;
     else
         return TRUE;
 }
 
-static void atk84_jump_if_cant_sleep(void)
+static void atk84_jumpifcantmakeasleep(void)
 {
-    const u8* jumpPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
+    const u8 *jumpPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
 
-    if (UproarWakeUpCheck(gBankTarget))
+    if (UproarWakeUpCheck(gBattlerTarget))
     {
         gBattlescriptCurrInstr = jumpPtr;
     }
-    else if (gBattleMons[gBankTarget].ability == ABILITY_INSOMNIA
-            || gBattleMons[gBankTarget].ability == ABILITY_VITAL_SPIRIT)
+    else if (gBattleMons[gBattlerTarget].ability == ABILITY_INSOMNIA
+            || gBattleMons[gBattlerTarget].ability == ABILITY_VITAL_SPIRIT)
     {
-        gLastUsedAbility = gBattleMons[gBankTarget].ability;
+        gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
         gBattleCommunication[MULTISTRING_CHOOSER] = 2;
         gBattlescriptCurrInstr = jumpPtr;
-        RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+        RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
     }
     else
     {
@@ -7550,16 +7413,16 @@ static void atk84_jump_if_cant_sleep(void)
 
 static void atk85_stockpile(void)
 {
-    if (gDisableStructs[gBankAttacker].stockpileCounter == 3)
+    if (gDisableStructs[gBattlerAttacker].stockpileCounter == 3)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 1;
     }
     else
     {
-        gDisableStructs[gBankAttacker].stockpileCounter++;
+        gDisableStructs[gBattlerAttacker].stockpileCounter++;
 
-        PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff1, 1, gDisableStructs[gBankAttacker].stockpileCounter)
+        PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff1, 1, gDisableStructs[gBattlerAttacker].stockpileCounter)
 
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
@@ -7569,7 +7432,7 @@ static void atk85_stockpile(void)
 static void atk86_stockpiletobasedamage(void)
 {
     const u8* jumpPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
-    if (gDisableStructs[gBankAttacker].stockpileCounter == 0)
+    if (gDisableStructs[gBattlerAttacker].stockpileCounter == 0)
     {
         gBattlescriptCurrInstr = jumpPtr;
     }
@@ -7577,17 +7440,17 @@ static void atk86_stockpiletobasedamage(void)
     {
         if (gBattleCommunication[6] != 1)
         {
-            gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[gBankAttacker], &gBattleMons[gBankTarget], gCurrentMove,
-                                                    gSideAffecting[GET_BANK_SIDE(gBankTarget)], 0,
-                                                    0, gBankAttacker, gBankTarget)
-                                * gDisableStructs[gBankAttacker].stockpileCounter;
-            gBattleScripting.animTurn = gDisableStructs[gBankAttacker].stockpileCounter;
+            gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[gBattlerAttacker], &gBattleMons[gBattlerTarget], gCurrentMove,
+                                                    gSideStatuses[GET_BATTLER_SIDE(gBattlerTarget)], 0,
+                                                    0, gBattlerAttacker, gBattlerTarget)
+                                * gDisableStructs[gBattlerAttacker].stockpileCounter;
+            gBattleScripting.animTurn = gDisableStructs[gBattlerAttacker].stockpileCounter;
 
-            if (gProtectStructs[gBankAttacker].helpingHand)
+            if (gProtectStructs[gBattlerAttacker].helpingHand)
                 gBattleMoveDamage = gBattleMoveDamage * 15 / 10;
         }
 
-        gDisableStructs[gBankAttacker].stockpileCounter = 0;
+        gDisableStructs[gBattlerAttacker].stockpileCounter = 0;
         gBattlescriptCurrInstr += 5;
     }
 }
@@ -7596,30 +7459,30 @@ static void atk87_stockpiletohpheal(void)
 {
     const u8* jumpPtr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
 
-    if (gDisableStructs[gBankAttacker].stockpileCounter == 0)
+    if (gDisableStructs[gBattlerAttacker].stockpileCounter == 0)
     {
         gBattlescriptCurrInstr = jumpPtr;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
-    else if (gBattleMons[gBankAttacker].maxHP == gBattleMons[gBankAttacker].hp)
+    else if (gBattleMons[gBattlerAttacker].maxHP == gBattleMons[gBattlerAttacker].hp)
     {
-        gDisableStructs[gBankAttacker].stockpileCounter = 0;
+        gDisableStructs[gBattlerAttacker].stockpileCounter = 0;
         gBattlescriptCurrInstr = jumpPtr;
-        gBankTarget = gBankAttacker;
+        gBattlerTarget = gBattlerAttacker;
         gBattleCommunication[MULTISTRING_CHOOSER] = 1;
     }
     else
     {
-        gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / (1 << (3 - gDisableStructs[gBankAttacker].stockpileCounter));
+        gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / (1 << (3 - gDisableStructs[gBattlerAttacker].stockpileCounter));
 
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
         gBattleMoveDamage *= -1;
 
-        gBattleScripting.animTurn = gDisableStructs[gBankAttacker].stockpileCounter;
-        gDisableStructs[gBankAttacker].stockpileCounter = 0;
+        gBattleScripting.animTurn = gDisableStructs[gBattlerAttacker].stockpileCounter;
+        gDisableStructs[gBattlerAttacker].stockpileCounter = 0;
         gBattlescriptCurrInstr += 5;
-        gBankTarget = gBankAttacker;
+        gBattlerTarget = gBattlerAttacker;
     }
 }
 
@@ -7632,16 +7495,16 @@ static void atk88_negativedamage(void)
     gBattlescriptCurrInstr++;
 }
 
-static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8 flags, const u8* BS_ptr)
+static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8 flags, const u8 *BS_ptr)
 {
-    bool8 certain = 0;
+    bool8 certain = FALSE;
     bool8 notProtectAffected = FALSE;
     u32 index;
 
     if (flags & MOVE_EFFECT_AFFECTS_USER)
-        gActiveBank = gBankAttacker;
+        gActiveBattler = gBattlerAttacker;
     else
-        gActiveBank = gBankTarget;
+        gActiveBattler = gBattlerTarget;
 
     flags &= ~(MOVE_EFFECT_AFFECTS_USER);
 
@@ -7657,21 +7520,21 @@ static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8 flags, const u8* BS_ptr)
 
     if ((statValue << 0x18) < 0) // stat decrease
     {
-        if (gSideTimers[GET_BANK_SIDE(gActiveBank)].mistTimer
+        if (gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].mistTimer
             && !certain && gCurrentMove != MOVE_CURSE)
         {
             if (flags == STAT_CHANGE_BS_PTR)
             {
-                if (gSpecialStatuses[gActiveBank].statLowered)
+                if (gSpecialStatuses[gActiveBattler].statLowered)
                 {
                     gBattlescriptCurrInstr = BS_ptr;
                 }
                 else
                 {
                     BattleScriptPush(BS_ptr);
-                    gBattleScripting.bank = gActiveBank;
+                    gBattleScripting.battler = gActiveBattler;
                     gBattlescriptCurrInstr = BattleScript_MistProtected;
-                    gSpecialStatuses[gActiveBank].statLowered = 1;
+                    gSpecialStatuses[gActiveBattler].statLowered = 1;
                 }
             }
             return STAT_CHANGE_DIDNT_WORK;
@@ -7682,55 +7545,55 @@ static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8 flags, const u8* BS_ptr)
             gBattlescriptCurrInstr = BattleScript_ButItFailed;
             return STAT_CHANGE_DIDNT_WORK;
         }
-        else if ((gBattleMons[gActiveBank].ability == ABILITY_CLEAR_BODY
-                  || gBattleMons[gActiveBank].ability == ABILITY_WHITE_SMOKE)
+        else if ((gBattleMons[gActiveBattler].ability == ABILITY_CLEAR_BODY
+                  || gBattleMons[gActiveBattler].ability == ABILITY_WHITE_SMOKE)
                  && !certain && gCurrentMove != MOVE_CURSE)
         {
             if (flags == STAT_CHANGE_BS_PTR)
             {
-                if (gSpecialStatuses[gActiveBank].statLowered)
+                if (gSpecialStatuses[gActiveBattler].statLowered)
                 {
                     gBattlescriptCurrInstr = BS_ptr;
                 }
                 else
                 {
                     BattleScriptPush(BS_ptr);
-                    gBattleScripting.bank = gActiveBank;
+                    gBattleScripting.battler = gActiveBattler;
                     gBattlescriptCurrInstr = BattleScript_AbilityNoStatLoss;
-                    gLastUsedAbility = gBattleMons[gActiveBank].ability;
-                    RecordAbilityBattle(gActiveBank, gLastUsedAbility);
-                    gSpecialStatuses[gActiveBank].statLowered = 1;
+                    gLastUsedAbility = gBattleMons[gActiveBattler].ability;
+                    RecordAbilityBattle(gActiveBattler, gLastUsedAbility);
+                    gSpecialStatuses[gActiveBattler].statLowered = 1;
                 }
             }
             return STAT_CHANGE_DIDNT_WORK;
         }
-        else if (gBattleMons[gActiveBank].ability == ABILITY_KEEN_EYE
-                 && !certain && statId == STAT_STAGE_ACC)
+        else if (gBattleMons[gActiveBattler].ability == ABILITY_KEEN_EYE
+                 && !certain && statId == STAT_ACC)
         {
             if (flags == STAT_CHANGE_BS_PTR)
             {
                 BattleScriptPush(BS_ptr);
-                gBattleScripting.bank = gActiveBank;
+                gBattleScripting.battler = gActiveBattler;
                 gBattlescriptCurrInstr = BattleScript_AbilityNoSpecificStatLoss;
-                gLastUsedAbility = gBattleMons[gActiveBank].ability;
-                RecordAbilityBattle(gActiveBank, gLastUsedAbility);
+                gLastUsedAbility = gBattleMons[gActiveBattler].ability;
+                RecordAbilityBattle(gActiveBattler, gLastUsedAbility);
             }
             return STAT_CHANGE_DIDNT_WORK;
         }
-        else if (gBattleMons[gActiveBank].ability == ABILITY_HYPER_CUTTER
-                 && !certain && statId == STAT_STAGE_ATK)
+        else if (gBattleMons[gActiveBattler].ability == ABILITY_HYPER_CUTTER
+                 && !certain && statId == STAT_ATK)
         {
             if (flags == STAT_CHANGE_BS_PTR)
             {
                 BattleScriptPush(BS_ptr);
-                gBattleScripting.bank = gActiveBank;
+                gBattleScripting.battler = gActiveBattler;
                 gBattlescriptCurrInstr = BattleScript_AbilityNoSpecificStatLoss;
-                gLastUsedAbility = gBattleMons[gActiveBank].ability;
-                RecordAbilityBattle(gActiveBank, gLastUsedAbility);
+                gLastUsedAbility = gBattleMons[gActiveBattler].ability;
+                RecordAbilityBattle(gActiveBattler, gLastUsedAbility);
             }
             return STAT_CHANGE_DIDNT_WORK;
         }
-        else if (gBattleMons[gActiveBank].ability == ABILITY_SHIELD_DUST && flags == 0)
+        else if (gBattleMons[gActiveBattler].ability == ABILITY_SHIELD_DUST && flags == 0)
         {
             return STAT_CHANGE_DIDNT_WORK;
         }
@@ -7742,22 +7605,22 @@ static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8 flags, const u8* BS_ptr)
             if (statValue == -2)
             {
                 gBattleTextBuff2[1] = B_BUFF_STRING;
-                gBattleTextBuff2[2] = 0xD3; // harshly
-                gBattleTextBuff2[3] = 0xD3 >> 8;
+                gBattleTextBuff2[2] = STRINGID_STATHARSHLY;
+                gBattleTextBuff2[3] = STRINGID_STATHARSHLY >> 8;
                 index = 4;
             }
             gBattleTextBuff2[index] = B_BUFF_STRING;
             index++;
-            gBattleTextBuff2[index] = 0xD4; // fell
+            gBattleTextBuff2[index] = STRINGID_STATFELL;
             index++;
-            gBattleTextBuff2[index] = 0xD4 >> 8;
+            gBattleTextBuff2[index] = STRINGID_STATFELL >> 8;
             index++;
             gBattleTextBuff2[index] = B_BUFF_EOS;
 
-            if (gBattleMons[gActiveBank].statStages[statId] == 0)
+            if (gBattleMons[gActiveBattler].statStages[statId] == 0)
                 gBattleCommunication[MULTISTRING_CHOOSER] = 2;
             else
-                gBattleCommunication[MULTISTRING_CHOOSER] = (gBankTarget == gActiveBank);
+                gBattleCommunication[MULTISTRING_CHOOSER] = (gBattlerTarget == gActiveBattler);
 
         }
     }
@@ -7769,32 +7632,32 @@ static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8 flags, const u8* BS_ptr)
         if (statValue == 2)
         {
             gBattleTextBuff2[1] = B_BUFF_STRING;
-            gBattleTextBuff2[2] = 0xD1; // sharply
-            gBattleTextBuff2[3] = 0xD1 >> 8;
+            gBattleTextBuff2[2] = STRINGID_STATSHARPLY;
+            gBattleTextBuff2[3] = STRINGID_STATSHARPLY >> 8;
             index = 4;
         }
         gBattleTextBuff2[index] = B_BUFF_STRING;
         index++;
-        gBattleTextBuff2[index] = 0xD2; // rose
+        gBattleTextBuff2[index] = STRINGID_STATROSE;
         index++;
-        gBattleTextBuff2[index] = 0xD2 >> 8;
+        gBattleTextBuff2[index] = STRINGID_STATROSE >> 8;
         index++;
         gBattleTextBuff2[index] = B_BUFF_EOS;
 
-        if (gBattleMons[gActiveBank].statStages[statId] == 0xC)
+        if (gBattleMons[gActiveBattler].statStages[statId] == 0xC)
             gBattleCommunication[MULTISTRING_CHOOSER] = 2;
         else
-            gBattleCommunication[MULTISTRING_CHOOSER] = (gBankTarget == gActiveBank);
+            gBattleCommunication[MULTISTRING_CHOOSER] = (gBattlerTarget == gActiveBattler);
     }
 
-    gBattleMons[gActiveBank].statStages[statId] += statValue;
-    if (gBattleMons[gActiveBank].statStages[statId] < 0)
-        gBattleMons[gActiveBank].statStages[statId] = 0;
-    if (gBattleMons[gActiveBank].statStages[statId] > 0xC)
-        gBattleMons[gActiveBank].statStages[statId] = 0xC;
+    gBattleMons[gActiveBattler].statStages[statId] += statValue;
+    if (gBattleMons[gActiveBattler].statStages[statId] < 0)
+        gBattleMons[gActiveBattler].statStages[statId] = 0;
+    if (gBattleMons[gActiveBattler].statStages[statId] > 0xC)
+        gBattleMons[gActiveBattler].statStages[statId] = 0xC;
 
     if (gBattleCommunication[MULTISTRING_CHOOSER] == 2 && flags & STAT_CHANGE_BS_PTR)
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
 
     if (gBattleCommunication[MULTISTRING_CHOOSER] == 2 && !(flags & STAT_CHANGE_BS_PTR))
         return STAT_CHANGE_DIDNT_WORK;
@@ -7813,7 +7676,7 @@ static void atk8A_normalisebuffs(void) // haze
 {
     s32 i, j;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
         for (j = 0; j < BATTLE_STATS_NO; j++)
             gBattleMons[i].statStages[j] = 6;
@@ -7824,23 +7687,23 @@ static void atk8A_normalisebuffs(void) // haze
 
 static void atk8B_setbide(void)
 {
-    gBattleMons[gBankAttacker].status2 |= STATUS2_MULTIPLETURNS;
-    gLockedMoves[gBankAttacker] = gCurrentMove;
-    gTakenDmg[gBankAttacker] = 0;
-    gBattleMons[gBankAttacker].status2 |= (STATUS2_BIDE - 0x100); // 2 turns
+    gBattleMons[gBattlerAttacker].status2 |= STATUS2_MULTIPLETURNS;
+    gLockedMoves[gBattlerAttacker] = gCurrentMove;
+    gTakenDmg[gBattlerAttacker] = 0;
+    gBattleMons[gBattlerAttacker].status2 |= (STATUS2_BIDE - 0x100); // 2 turns
 
     gBattlescriptCurrInstr++;
 }
 
 static void atk8C_confuseifrepeatingattackends(void)
 {
-    if (!(gBattleMons[gBankAttacker].status2 & STATUS2_LOCK_CONFUSE))
+    if (!(gBattleMons[gBattlerAttacker].status2 & STATUS2_LOCK_CONFUSE))
         gBattleCommunication[MOVE_EFFECT_BYTE] = (MOVE_EFFECT_THRASH | MOVE_EFFECT_AFFECTS_USER);
 
     gBattlescriptCurrInstr++;
 }
 
-static void atk8D_setmultihit_counter(void)
+static void atk8D_setmultihitcounter(void)
 {
     if (gBattlescriptCurrInstr[1])
     {
@@ -7858,39 +7721,39 @@ static void atk8D_setmultihit_counter(void)
     gBattlescriptCurrInstr += 2;
 }
 
-static void atk8E_init_multihit_string(void)
+static void atk8E_initmultihitstring(void)
 {
     PREPARE_BYTE_NUMBER_BUFFER(gBattleScripting.multihitString, 1, 0)
 
     gBattlescriptCurrInstr++;
 }
 
-static bool8 sub_8051064(void)
+static bool8 TryDoForceSwitchOut(void)
 {
-    if (gBattleMons[gBankAttacker].level >= gBattleMons[gBankTarget].level)
+    if (gBattleMons[gBattlerAttacker].level >= gBattleMons[gBattlerTarget].level)
     {
-        *(gBattleStruct->field_58 + gBankTarget) = gBattlePartyID[gBankTarget];
+        *(gBattleStruct->field_58 + gBattlerTarget) = gBattlerPartyIndexes[gBattlerTarget];
     }
     else
     {
         u16 random = Random() & 0xFF;
-        if ((u32)((random * (gBattleMons[gBankAttacker].level + gBattleMons[gBankTarget].level) >> 8) + 1) <= (gBattleMons[gBankTarget].level / 4))
+        if ((u32)((random * (gBattleMons[gBattlerAttacker].level + gBattleMons[gBattlerTarget].level) >> 8) + 1) <= (gBattleMons[gBattlerTarget].level / 4))
         {
             gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
             return FALSE;
         }
-        *(gBattleStruct->field_58 + gBankTarget) = gBattlePartyID[gBankTarget];
+        *(gBattleStruct->field_58 + gBattlerTarget) = gBattlerPartyIndexes[gBattlerTarget];
     }
 
-    gBattlescriptCurrInstr = gUnknown_082DADD8;
+    gBattlescriptCurrInstr = BattleScript_SuccessForceOut;
     return TRUE;
 }
 
 static void atk8F_forcerandomswitch(void)
 {
     s32 i;
-    s32 bank1PartyId = 0;
-    s32 bank2PartyId = 0;
+    s32 battler1PartyId = 0;
+    s32 battler2PartyId = 0;
 
     #ifdef NONMATCHING
         s32 lastMonId = 0; // + 1
@@ -7906,7 +7769,7 @@ static void atk8F_forcerandomswitch(void)
 
     if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER))
     {
-        if (GetBankSide(gBankTarget) == SIDE_PLAYER)
+        if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER)
             party = gPlayerParty;
         else
             party = gEnemyParty;
@@ -7915,7 +7778,7 @@ static void atk8F_forcerandomswitch(void)
             || (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER && gBattleTypeFlags & BATTLE_TYPE_x2000000)
             || (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER))
         {
-            if ((gBankTarget & BIT_MON) != 0)
+            if ((gBattlerTarget & BIT_FLANK) != 0)
             {
                 firstMonId = 3;
                 lastMonId = 6;
@@ -7927,13 +7790,13 @@ static void atk8F_forcerandomswitch(void)
             }
             monsCount = 3;
             minNeeded = 1;
-            bank2PartyId = gBattlePartyID[gBankTarget];
-            bank1PartyId = gBattlePartyID[gBankTarget ^ BIT_MON];
+            battler2PartyId = gBattlerPartyIndexes[gBattlerTarget];
+            battler1PartyId = gBattlerPartyIndexes[gBattlerTarget ^ BIT_FLANK];
         }
         else if ((gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK)
                  || (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_x2000000))
         {
-            if (sub_806D82C(GetBankMultiplayerId(gBankTarget)) == 1)
+            if (sub_806D82C(GetBattlerMultiplayerId(gBattlerTarget)) == 1)
             {
                 firstMonId = 3;
                 lastMonId = 6;
@@ -7945,12 +7808,12 @@ static void atk8F_forcerandomswitch(void)
             }
             monsCount = 3;
             minNeeded = 1;
-            bank2PartyId = gBattlePartyID[gBankTarget];
-            bank1PartyId = gBattlePartyID[gBankTarget ^ BIT_MON];
+            battler2PartyId = gBattlerPartyIndexes[gBattlerTarget];
+            battler1PartyId = gBattlerPartyIndexes[gBattlerTarget ^ BIT_FLANK];
         }
         else if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)
         {
-            if (GetBankSide(gBankTarget) == SIDE_PLAYER)
+            if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER)
             {
                 firstMonId = 0;
                 lastMonId = 6;
@@ -7959,7 +7822,7 @@ static void atk8F_forcerandomswitch(void)
             }
             else
             {
-                if ((gBankTarget & BIT_MON) != 0)
+                if ((gBattlerTarget & BIT_FLANK) != 0)
                 {
                     firstMonId = 3;
                     lastMonId = 6;
@@ -7972,8 +7835,8 @@ static void atk8F_forcerandomswitch(void)
                 monsCount = 3;
                 minNeeded = 1;
             }
-            bank2PartyId = gBattlePartyID[gBankTarget];
-            bank1PartyId = gBattlePartyID[gBankTarget ^ BIT_MON];
+            battler2PartyId = gBattlerPartyIndexes[gBattlerTarget];
+            battler1PartyId = gBattlerPartyIndexes[gBattlerTarget ^ BIT_FLANK];
         }
         else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
         {
@@ -7981,8 +7844,8 @@ static void atk8F_forcerandomswitch(void)
             lastMonId = 6;
             monsCount = 6;
             minNeeded = 2;
-            bank2PartyId = gBattlePartyID[gBankTarget];
-            bank1PartyId = gBattlePartyID[gBankTarget ^ BIT_MON];
+            battler2PartyId = gBattlerPartyIndexes[gBattlerTarget];
+            battler1PartyId = gBattlerPartyIndexes[gBattlerTarget ^ BIT_FLANK];
         }
         else
         {
@@ -7990,8 +7853,8 @@ static void atk8F_forcerandomswitch(void)
             lastMonId = 6;
             monsCount = 6;
             minNeeded = 1;
-            bank2PartyId = gBattlePartyID[gBankTarget]; // there is only one pokemon out in single battles
-            bank1PartyId = gBattlePartyID[gBankTarget];
+            battler2PartyId = gBattlerPartyIndexes[gBattlerTarget]; // there is only one pokemon out in single battles
+            battler1PartyId = gBattlerPartyIndexes[gBattlerTarget];
         }
 
         for (i = firstMonId; i < lastMonId; i++)
@@ -8010,44 +7873,44 @@ static void atk8F_forcerandomswitch(void)
         }
         else
         {
-            if (sub_8051064())
+            if (TryDoForceSwitchOut())
             {
                 do
                 {
                     i = Random() % monsCount;
                     i += firstMonId;
                 }
-                while (i == bank2PartyId
-                       || i == bank1PartyId
+                while (i == battler2PartyId
+                       || i == battler1PartyId
                        || GetMonData(&party[i], MON_DATA_SPECIES) == SPECIES_NONE
                        || GetMonData(&party[i], MON_DATA_IS_EGG) == TRUE
                        || GetMonData(&party[i], MON_DATA_HP) == 0);
             }
-            *(gBattleStruct->field_5C + gBankTarget) = i;
+            *(gBattleStruct->monToSwitchIntoId + gBattlerTarget) = i;
 
             if (!sub_81B1250())
-                sub_803BDA0(gBankTarget);
+                sub_803BDA0(gBattlerTarget);
 
             if ((gBattleTypeFlags & BATTLE_TYPE_LINK && gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
                 || (gBattleTypeFlags & BATTLE_TYPE_LINK && gBattleTypeFlags & BATTLE_TYPE_MULTI)
                 || (gBattleTypeFlags & BATTLE_TYPE_x2000000 && gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
                 || (gBattleTypeFlags & BATTLE_TYPE_x2000000 && gBattleTypeFlags & BATTLE_TYPE_MULTI))
             {
-                sub_81B8E80(gBankTarget, i, 0);
-                sub_81B8E80(gBankTarget ^ BIT_MON, i, 1);
+                sub_81B8E80(gBattlerTarget, i, 0);
+                sub_81B8E80(gBattlerTarget ^ BIT_FLANK, i, 1);
             }
 
             if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER)
-                sub_80571DC(gBankTarget, i);
+                sub_80571DC(gBattlerTarget, i);
         }
     }
     else
     {
-        sub_8051064();
+        TryDoForceSwitchOut();
     }
 }
 
-static void atk90_conversion_type_change(void) // randomly changes user's type to one of its moves' type
+static void atk90_tryconversiontypechange(void) // randomly changes user's type to one of its moves' type
 {
     u8 validMoves = 0;
     u8 moveChecked;
@@ -8055,7 +7918,7 @@ static void atk90_conversion_type_change(void) // randomly changes user's type t
 
     while (validMoves < 4)
     {
-        if (gBattleMons[gBankAttacker].moves[validMoves] == 0)
+        if (gBattleMons[gBattlerAttacker].moves[validMoves] == 0)
             break;
 
         validMoves++;
@@ -8063,17 +7926,17 @@ static void atk90_conversion_type_change(void) // randomly changes user's type t
 
     for (moveChecked = 0; moveChecked < validMoves; moveChecked++)
     {
-        moveType = gBattleMoves[gBattleMons[gBankAttacker].moves[moveChecked]].type;
+        moveType = gBattleMoves[gBattleMons[gBattlerAttacker].moves[moveChecked]].type;
 
         if (moveType == TYPE_MYSTERY)
         {
-            if (gBattleMons[gBankAttacker].type1 == TYPE_GHOST || gBattleMons[gBankAttacker].type2 == TYPE_GHOST)
+            if (gBattleMons[gBattlerAttacker].type1 == TYPE_GHOST || gBattleMons[gBattlerAttacker].type2 == TYPE_GHOST)
                 moveType = TYPE_GHOST;
             else
                 moveType = TYPE_NORMAL;
         }
-        if (moveType != gBattleMons[gBankAttacker].type1
-            && moveType != gBattleMons[gBankAttacker].type2)
+        if (moveType != gBattleMons[gBattlerAttacker].type1
+            && moveType != gBattleMons[gBattlerAttacker].type2)
         {
             break;
         }
@@ -8090,20 +7953,20 @@ static void atk90_conversion_type_change(void) // randomly changes user's type t
 
             while ((moveChecked = Random() & 3) >= validMoves);
 
-            moveType = gBattleMoves[gBattleMons[gBankAttacker].moves[moveChecked]].type;
+            moveType = gBattleMoves[gBattleMons[gBattlerAttacker].moves[moveChecked]].type;
 
             if (moveType == TYPE_MYSTERY)
             {
-                if (gBattleMons[gBankAttacker].type1 == TYPE_GHOST || gBattleMons[gBankAttacker].type2 == TYPE_GHOST)
+                if (gBattleMons[gBattlerAttacker].type1 == TYPE_GHOST || gBattleMons[gBattlerAttacker].type2 == TYPE_GHOST)
                     moveType = TYPE_GHOST;
                 else
                     moveType = TYPE_NORMAL;
             }
         }
-        while (moveType == gBattleMons[gBankAttacker].type1 || moveType == gBattleMons[gBankAttacker].type2);
+        while (moveType == gBattleMons[gBattlerAttacker].type1 || moveType == gBattleMons[gBattlerAttacker].type2);
 
-        gBattleMons[gBankAttacker].type1 = moveType;
-        gBattleMons[gBankAttacker].type2 = moveType;
+        gBattleMons[gBattlerAttacker].type1 = moveType;
+        gBattleMons[gBattlerAttacker].type2 = moveType;
 
         PREPARE_TYPE_BUFFER(gBattleTextBuff1, moveType)
 
@@ -8131,16 +7994,16 @@ static void atk91_givepaydaymoney(void)
 
 static void atk92_setlightscreen(void)
 {
-    if (gSideAffecting[GET_BANK_SIDE(gBankAttacker)] & SIDE_STATUS_LIGHTSCREEN)
+    if (gSideStatuses[GET_BATTLER_SIDE(gBattlerAttacker)] & SIDE_STATUS_LIGHTSCREEN)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     else
     {
-        gSideAffecting[GET_BANK_SIDE(gBankAttacker)] |= SIDE_STATUS_LIGHTSCREEN;
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].lightscreenTimer = 5;
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].lightscreenBank = gBankAttacker;
+        gSideStatuses[GET_BATTLER_SIDE(gBattlerAttacker)] |= SIDE_STATUS_LIGHTSCREEN;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].lightscreenTimer = 5;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].lightscreenBattlerId = gBattlerAttacker;
 
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && CountAliveMonsInBattle(BATTLE_ALIVE_ATK_SIDE) == 2)
             gBattleCommunication[MULTISTRING_CHOOSER] = 4;
@@ -8151,84 +8014,84 @@ static void atk92_setlightscreen(void)
     gBattlescriptCurrInstr++;
 }
 
-static void atk93_ko_move(void)
+static void atk93_tryKO(void)
 {
     u8 holdEffect, param;
 
-    if (gBattleMons[gBankTarget].item == ITEM_ENIGMA_BERRY)
+    if (gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY)
     {
-       holdEffect = gEnigmaBerries[gBankTarget].holdEffect;
-       param = gEnigmaBerries[gBankTarget].holdEffectParam;
+       holdEffect = gEnigmaBerries[gBattlerTarget].holdEffect;
+       param = gEnigmaBerries[gBattlerTarget].holdEffectParam;
     }
     else
     {
-        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBankTarget].item);
-        param = ItemId_GetHoldEffectParam(gBattleMons[gBankTarget].item);
+        holdEffect = ItemId_GetHoldEffect(gBattleMons[gBattlerTarget].item);
+        param = ItemId_GetHoldEffectParam(gBattleMons[gBattlerTarget].item);
     }
 
-    gStringBank = gBankTarget;
+    gPotentialItemEffectBattler = gBattlerTarget;
 
     if (holdEffect == HOLD_EFFECT_FOCUS_BAND && (Random() % 100) < param)
     {
-        RecordItemEffectBattle(gBankTarget, HOLD_EFFECT_FOCUS_BAND);
-        gSpecialStatuses[gBankTarget].focusBanded = 1;
+        RecordItemEffectBattle(gBattlerTarget, HOLD_EFFECT_FOCUS_BAND);
+        gSpecialStatuses[gBattlerTarget].focusBanded = 1;
     }
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_STURDY)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_STURDY)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gLastUsedAbility = ABILITY_STURDY;
         gBattlescriptCurrInstr = BattleScript_SturdyPreventsOHKO;
-        RecordAbilityBattle(gBankTarget, ABILITY_STURDY);
+        RecordAbilityBattle(gBattlerTarget, ABILITY_STURDY);
     }
     else
     {
         u16 chance;
-        if (!(gStatuses3[gBankTarget] & STATUS3_ALWAYS_HITS))
+        if (!(gStatuses3[gBattlerTarget] & STATUS3_ALWAYS_HITS))
         {
-            chance = gBattleMoves[gCurrentMove].accuracy + (gBattleMons[gBankAttacker].level - gBattleMons[gBankTarget].level);
-            if (Random() % 100 + 1 < chance && gBattleMons[gBankAttacker].level >= gBattleMons[gBankTarget].level)
+            chance = gBattleMoves[gCurrentMove].accuracy + (gBattleMons[gBattlerAttacker].level - gBattleMons[gBattlerTarget].level);
+            if (Random() % 100 + 1 < chance && gBattleMons[gBattlerAttacker].level >= gBattleMons[gBattlerTarget].level)
                 chance = TRUE;
             else
                 chance = FALSE;
         }
-        else if (gDisableStructs[gBankTarget].bankWithSureHit == gBankAttacker
-                 && gBattleMons[gBankAttacker].level >= gBattleMons[gBankTarget].level)
+        else if (gDisableStructs[gBattlerTarget].battlerWithSureHit == gBattlerAttacker
+                 && gBattleMons[gBattlerAttacker].level >= gBattleMons[gBattlerTarget].level)
         {
             chance = TRUE;
         }
         else
         {
-            chance = gBattleMoves[gCurrentMove].accuracy + (gBattleMons[gBankAttacker].level - gBattleMons[gBankTarget].level);
-            if (Random() % 100 + 1 < chance && gBattleMons[gBankAttacker].level >= gBattleMons[gBankTarget].level)
+            chance = gBattleMoves[gCurrentMove].accuracy + (gBattleMons[gBattlerAttacker].level - gBattleMons[gBattlerTarget].level);
+            if (Random() % 100 + 1 < chance && gBattleMons[gBattlerAttacker].level >= gBattleMons[gBattlerTarget].level)
                 chance = TRUE;
             else
                 chance = FALSE;
         }
         if (chance)
         {
-            if (gProtectStructs[gBankTarget].endured)
+            if (gProtectStructs[gBattlerTarget].endured)
             {
-                gBattleMoveDamage = gBattleMons[gBankTarget].hp - 1;
-                gBattleMoveFlags |= MOVESTATUS_ENDURED;
+                gBattleMoveDamage = gBattleMons[gBattlerTarget].hp - 1;
+                gMoveResultFlags |= MOVE_RESULT_FOE_ENDURED;
             }
-            else if (gSpecialStatuses[gBankTarget].focusBanded)
+            else if (gSpecialStatuses[gBattlerTarget].focusBanded)
             {
-                gBattleMoveDamage = gBattleMons[gBankTarget].hp - 1;
-                gBattleMoveFlags |= MOVESTATUS_HUNGON;
-                gLastUsedItem = gBattleMons[gBankTarget].item;
+                gBattleMoveDamage = gBattleMons[gBattlerTarget].hp - 1;
+                gMoveResultFlags |= MOVE_RESULT_FOE_HUNG_ON;
+                gLastUsedItem = gBattleMons[gBattlerTarget].item;
             }
             else
             {
-                gBattleMoveDamage = gBattleMons[gBankTarget].hp;
-                gBattleMoveFlags |= MOVESTATUS_ONEHITKO;
+                gBattleMoveDamage = gBattleMons[gBattlerTarget].hp;
+                gMoveResultFlags |= MOVE_RESULT_ONE_HIT_KO;
             }
             gBattlescriptCurrInstr += 5;
         }
         else
         {
-            gBattleMoveFlags |= MOVESTATUS_MISSED;
-            if (gBattleMons[gBankAttacker].level >= gBattleMons[gBankTarget].level)
+            gMoveResultFlags |= MOVE_RESULT_MISSED;
+            if (gBattleMons[gBattlerAttacker].level >= gBattleMons[gBattlerTarget].level)
                 gBattleCommunication[MULTISTRING_CHOOSER] = 0;
             else
                 gBattleCommunication[MULTISTRING_CHOOSER] = 1;
@@ -8239,7 +8102,7 @@ static void atk93_ko_move(void)
 
 static void atk94_damagetohalftargethp(void) // super fang
 {
-    gBattleMoveDamage = gBattleMons[gBankTarget].hp / 2;
+    gBattleMoveDamage = gBattleMons[gBattlerTarget].hp / 2;
     if (gBattleMoveDamage == 0)
         gBattleMoveDamage = 1;
 
@@ -8250,7 +8113,7 @@ static void atk95_setsandstorm(void)
 {
     if (gBattleWeather & WEATHER_SANDSTORM_ANY)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 2;
     }
     else
@@ -8268,17 +8131,17 @@ static void atk96_weatherdamage(void)
     {
         if (gBattleWeather & WEATHER_SANDSTORM_ANY)
         {
-            if (gBattleMons[gBankAttacker].type1 != TYPE_ROCK
-                && gBattleMons[gBankAttacker].type1 != TYPE_STEEL
-                && gBattleMons[gBankAttacker].type1 != TYPE_GROUND
-                && gBattleMons[gBankAttacker].type2 != TYPE_ROCK
-                && gBattleMons[gBankAttacker].type2 != TYPE_STEEL
-                && gBattleMons[gBankAttacker].type2 != TYPE_GROUND
-                && gBattleMons[gBankAttacker].ability != ABILITY_SAND_VEIL
-                && !(gStatuses3[gBankAttacker] & STATUS3_UNDERGROUND)
-                && !(gStatuses3[gBankAttacker] & STATUS3_UNDERWATER))
-            {
-                gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / 16;
+            if (gBattleMons[gBattlerAttacker].type1 != TYPE_ROCK
+                && gBattleMons[gBattlerAttacker].type1 != TYPE_STEEL
+                && gBattleMons[gBattlerAttacker].type1 != TYPE_GROUND
+                && gBattleMons[gBattlerAttacker].type2 != TYPE_ROCK
+                && gBattleMons[gBattlerAttacker].type2 != TYPE_STEEL
+                && gBattleMons[gBattlerAttacker].type2 != TYPE_GROUND
+                && gBattleMons[gBattlerAttacker].ability != ABILITY_SAND_VEIL
+                && !(gStatuses3[gBattlerAttacker] & STATUS3_UNDERGROUND)
+                && !(gStatuses3[gBattlerAttacker] & STATUS3_UNDERWATER))
+            {
+                gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 16;
                 if (gBattleMoveDamage == 0)
                     gBattleMoveDamage = 1;
             }
@@ -8289,12 +8152,12 @@ static void atk96_weatherdamage(void)
         }
         if (gBattleWeather & WEATHER_HAIL)
         {
-            if (gBattleMons[gBankAttacker].type1 != TYPE_ICE
-                && gBattleMons[gBankAttacker].type2 != TYPE_ICE
-                && !(gStatuses3[gBankAttacker] & STATUS3_UNDERGROUND)
-                && !(gStatuses3[gBankAttacker] & STATUS3_UNDERWATER))
+            if (gBattleMons[gBattlerAttacker].type1 != TYPE_ICE
+                && gBattleMons[gBattlerAttacker].type2 != TYPE_ICE
+                && !(gStatuses3[gBattlerAttacker] & STATUS3_UNDERGROUND)
+                && !(gStatuses3[gBattlerAttacker] & STATUS3_UNDERWATER))
             {
-                gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / 16;
+                gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 16;
                 if (gBattleMoveDamage == 0)
                     gBattleMoveDamage = 1;
             }
@@ -8309,27 +8172,27 @@ static void atk96_weatherdamage(void)
         gBattleMoveDamage = 0;
     }
 
-    if (gAbsentBankFlags & gBitTable[gBankAttacker])
+    if (gAbsentBattlerFlags & gBitTable[gBattlerAttacker])
         gBattleMoveDamage = 0;
 
     gBattlescriptCurrInstr++;
 }
 
-static void atk97_try_infatuation(void)
+static void atk97_tryinfatuating(void)
 {
     struct Pokemon *monAttacker, *monTarget;
     u16 speciesAttacker, speciesTarget;
     u32 personalityAttacker, personalityTarget;
 
-    if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
-        monAttacker = &gPlayerParty[gBattlePartyID[gBankAttacker]];
+    if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
+        monAttacker = &gPlayerParty[gBattlerPartyIndexes[gBattlerAttacker]];
     else
-        monAttacker = &gEnemyParty[gBattlePartyID[gBankAttacker]];
+        monAttacker = &gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker]];
 
-    if (GetBankSide(gBankTarget) == SIDE_PLAYER)
-        monTarget = &gPlayerParty[gBattlePartyID[gBankTarget]];
+    if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER)
+        monTarget = &gPlayerParty[gBattlerPartyIndexes[gBattlerTarget]];
     else
-        monTarget = &gEnemyParty[gBattlePartyID[gBankTarget]];
+        monTarget = &gEnemyParty[gBattlerPartyIndexes[gBattlerTarget]];
 
     speciesAttacker = GetMonData(monAttacker, MON_DATA_SPECIES);
     personalityAttacker = GetMonData(monAttacker, MON_DATA_PERSONALITY);
@@ -8337,16 +8200,16 @@ static void atk97_try_infatuation(void)
     speciesTarget = GetMonData(monTarget, MON_DATA_SPECIES);
     personalityTarget = GetMonData(monTarget, MON_DATA_PERSONALITY);
 
-    if (gBattleMons[gBankTarget].ability == ABILITY_OBLIVIOUS)
+    if (gBattleMons[gBattlerTarget].ability == ABILITY_OBLIVIOUS)
     {
         gBattlescriptCurrInstr = BattleScript_ObliviousPreventsAttraction;
         gLastUsedAbility = ABILITY_OBLIVIOUS;
-        RecordAbilityBattle(gBankTarget, ABILITY_OBLIVIOUS);
+        RecordAbilityBattle(gBattlerTarget, ABILITY_OBLIVIOUS);
     }
     else
     {
         if (GetGenderFromSpeciesAndPersonality(speciesAttacker, personalityAttacker) == GetGenderFromSpeciesAndPersonality(speciesTarget, personalityTarget)
-            || gBattleMons[gBankTarget].status2 & STATUS2_INFATUATION
+            || gBattleMons[gBattlerTarget].status2 & STATUS2_INFATUATION
             || GetGenderFromSpeciesAndPersonality(speciesAttacker, personalityAttacker) == MON_GENDERLESS
             || GetGenderFromSpeciesAndPersonality(speciesTarget, personalityTarget) == MON_GENDERLESS)
         {
@@ -8354,39 +8217,39 @@ static void atk97_try_infatuation(void)
         }
         else
         {
-            gBattleMons[gBankTarget].status2 |= STATUS2_INFATUATED_WITH(gBankAttacker);
+            gBattleMons[gBattlerTarget].status2 |= STATUS2_INFATUATED_WITH(gBattlerAttacker);
             gBattlescriptCurrInstr += 5;
         }
     }
 }
 
-static void atk98_status_icon_update(void)
+static void atk98_updatestatusicon(void)
 {
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
     if (gBattlescriptCurrInstr[1] != BS_ATTACKER_WITH_PARTNER)
     {
-        gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
-        EmitStatusIconUpdate(0, gBattleMons[gActiveBank].status1, gBattleMons[gActiveBank].status2);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
+        BtlController_EmitStatusIconUpdate(0, gBattleMons[gActiveBattler].status1, gBattleMons[gActiveBattler].status2);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 2;
     }
     else
     {
-        gActiveBank = gBankAttacker;
-        if (!(gAbsentBankFlags & gBitTable[gActiveBank]))
+        gActiveBattler = gBattlerAttacker;
+        if (!(gAbsentBattlerFlags & gBitTable[gActiveBattler]))
         {
-            EmitStatusIconUpdate(0, gBattleMons[gActiveBank].status1, gBattleMons[gActiveBank].status2);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitStatusIconUpdate(0, gBattleMons[gActiveBattler].status1, gBattleMons[gActiveBattler].status2);
+            MarkBattlerForControllerExec(gActiveBattler);
         }
         if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
         {
-            gActiveBank = GetBankByIdentity(GetBankIdentity(gBankAttacker) ^ BIT_MON);
-            if (!(gAbsentBankFlags & gBitTable[gActiveBank]))
+            gActiveBattler = GetBattlerAtPosition(GetBattlerPosition(gBattlerAttacker) ^ BIT_FLANK);
+            if (!(gAbsentBattlerFlags & gBitTable[gActiveBattler]))
             {
-                EmitStatusIconUpdate(0, gBattleMons[gActiveBank].status1, gBattleMons[gActiveBank].status2);
-                MarkBufferBankForExecution(gActiveBank);
+                BtlController_EmitStatusIconUpdate(0, gBattleMons[gActiveBattler].status1, gBattleMons[gActiveBattler].status2);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
         }
         gBattlescriptCurrInstr += 2;
@@ -8395,31 +8258,31 @@ static void atk98_status_icon_update(void)
 
 static void atk99_setmist(void)
 {
-    if (gSideTimers[GET_BANK_SIDE(gBankAttacker)].mistTimer)
+    if (gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].mistTimer)
     {
-        gBattleMoveFlags |= MOVESTATUS_FAILED;
+        gMoveResultFlags |= MOVE_RESULT_FAILED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 1;
     }
     else
     {
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].mistTimer = 5;
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].mistBank = gBankAttacker;
-        gSideAffecting[GET_BANK_SIDE(gBankAttacker)] |= SIDE_STATUS_MIST;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].mistTimer = 5;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].mistBattlerId = gBattlerAttacker;
+        gSideStatuses[GET_BATTLER_SIDE(gBattlerAttacker)] |= SIDE_STATUS_MIST;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     gBattlescriptCurrInstr++;
 }
 
-static void atk9A_set_focusenergy(void)
+static void atk9A_setfocusenergy(void)
 {
-    if (gBattleMons[gBankAttacker].status2 & STATUS2_FOCUS_ENERGY)
+    if (gBattleMons[gBattlerAttacker].status2 & STATUS2_FOCUS_ENERGY)
     {
-        gBattleMoveFlags |= MOVESTATUS_FAILED;
+        gMoveResultFlags |= MOVE_RESULT_FAILED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 1;
     }
     else
     {
-        gBattleMons[gBankAttacker].status2 |= STATUS2_FOCUS_ENERGY;
+        gBattleMons[gBattlerAttacker].status2 |= STATUS2_FOCUS_ENERGY;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     gBattlescriptCurrInstr++;
@@ -8427,12 +8290,12 @@ static void atk9A_set_focusenergy(void)
 
 static void atk9B_transformdataexecution(void)
 {
-    gLastUsedMove = 0xFFFF;
+    gChosenMove = 0xFFFF;
     gBattlescriptCurrInstr++;
-    if (gBattleMons[gBankTarget].status2 & STATUS2_TRANSFORMED
-        || gStatuses3[gBankTarget] & STATUS3_SEMI_INVULNERABLE)
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_TRANSFORMED
+        || gStatuses3[gBattlerTarget] & STATUS3_SEMI_INVULNERABLE)
     {
-        gBattleMoveFlags |= MOVESTATUS_FAILED;
+        gMoveResultFlags |= MOVE_RESULT_FAILED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 1;
     }
     else
@@ -8440,55 +8303,55 @@ static void atk9B_transformdataexecution(void)
         s32 i;
         u8 *battleMonAttacker, *battleMonTarget;
 
-        gBattleMons[gBankAttacker].status2 |= STATUS2_TRANSFORMED;
-        gDisableStructs[gBankAttacker].disabledMove = 0;
-        gDisableStructs[gBankAttacker].disableTimer1 = 0;
-        gDisableStructs[gBankAttacker].transformedMonPersonality = gBattleMons[gBankTarget].personality;
-        gDisableStructs[gBankAttacker].unk18_b = 0;
+        gBattleMons[gBattlerAttacker].status2 |= STATUS2_TRANSFORMED;
+        gDisableStructs[gBattlerAttacker].disabledMove = 0;
+        gDisableStructs[gBattlerAttacker].disableTimer1 = 0;
+        gDisableStructs[gBattlerAttacker].transformedMonPersonality = gBattleMons[gBattlerTarget].personality;
+        gDisableStructs[gBattlerAttacker].unk18_b = 0;
 
-        PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[gBankTarget].species)
+        PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerTarget].species)
 
-        battleMonAttacker = (u8*)(&gBattleMons[gBankAttacker]);
-        battleMonTarget = (u8*)(&gBattleMons[gBankTarget]);
+        battleMonAttacker = (u8*)(&gBattleMons[gBattlerAttacker]);
+        battleMonTarget = (u8*)(&gBattleMons[gBattlerTarget]);
 
         for (i = 0; i < offsetof(struct BattlePokemon, pp); i++)
             battleMonAttacker[i] = battleMonTarget[i];
 
         for (i = 0; i < 4; i++)
         {
-            if (gBattleMoves[gBattleMons[gBankAttacker].moves[i]].pp < 5)
-                gBattleMons[gBankAttacker].pp[i] = gBattleMoves[gBattleMons[gBankAttacker].moves[i]].pp;
+            if (gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].pp < 5)
+                gBattleMons[gBattlerAttacker].pp[i] = gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].pp;
             else
-                gBattleMons[gBankAttacker].pp[i] = 5;
+                gBattleMons[gBattlerAttacker].pp[i] = 5;
         }
 
-        gActiveBank = gBankAttacker;
-        EmitResetActionMoveSelection(0, RESET_MOVE_SELECTION);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = gBattlerAttacker;
+        BtlController_EmitResetActionMoveSelection(0, RESET_MOVE_SELECTION);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
 }
 
-static void atk9C_set_substitute(void)
+static void atk9C_setsubstitute(void)
 {
-    u32 hp = gBattleMons[gBankAttacker].maxHP / 4;
-    if (gBattleMons[gBankAttacker].maxHP / 4 == 0)
+    u32 hp = gBattleMons[gBattlerAttacker].maxHP / 4;
+    if (gBattleMons[gBattlerAttacker].maxHP / 4 == 0)
         hp = 1;
 
-    if (gBattleMons[gBankAttacker].hp <= hp)
+    if (gBattleMons[gBattlerAttacker].hp <= hp)
     {
         gBattleMoveDamage = 0;
         gBattleCommunication[MULTISTRING_CHOOSER] = 1;
     }
     else
     {
-        gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / 4; // one bit value will only work for pokemon which max hp can go to 1020(which is more than possible in games)
+        gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 4; // one bit value will only work for pokemon which max hp can go to 1020(which is more than possible in games)
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
 
-        gBattleMons[gBankAttacker].status2 |= STATUS2_SUBSTITUTE;
-        gBattleMons[gBankAttacker].status2 &= ~(STATUS2_WRAPPED);
-        gDisableStructs[gBankAttacker].substituteHP = gBattleMoveDamage;
+        gBattleMons[gBattlerAttacker].status2 |= STATUS2_SUBSTITUTE;
+        gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_WRAPPED);
+        gDisableStructs[gBattlerAttacker].substituteHP = gBattleMoveDamage;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
         gHitMarker |= HITMARKER_IGNORE_SUBSTITUTE;
     }
@@ -8507,12 +8370,12 @@ static bool8 IsMoveUncopyableByMimic(u16 move)
 
 static void atk9D_mimicattackcopy(void)
 {
-    gLastUsedMove = 0xFFFF;
+    gChosenMove = 0xFFFF;
 
-    if (IsMoveUncopyableByMimic(gLastUsedMovesByBanks[gBankTarget])
-        || gBattleMons[gBankAttacker].status2 & STATUS2_TRANSFORMED
-        || gLastUsedMovesByBanks[gBankTarget] == 0
-        || gLastUsedMovesByBanks[gBankTarget] == 0xFFFF)
+    if (IsMoveUncopyableByMimic(gLastMoves[gBattlerTarget])
+        || gBattleMons[gBattlerAttacker].status2 & STATUS2_TRANSFORMED
+        || gLastMoves[gBattlerTarget] == 0
+        || gLastMoves[gBattlerTarget] == 0xFFFF)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
@@ -8522,22 +8385,22 @@ static void atk9D_mimicattackcopy(void)
 
         for (i = 0; i < 4; i++)
         {
-            if (gBattleMons[gBankAttacker].moves[i] == gLastUsedMovesByBanks[gBankTarget])
+            if (gBattleMons[gBattlerAttacker].moves[i] == gLastMoves[gBattlerTarget])
                 break;
         }
 
         if (i == 4)
         {
-            gBattleMons[gBankAttacker].moves[gCurrMovePos] = gLastUsedMovesByBanks[gBankTarget];
-            if (gBattleMoves[gLastUsedMovesByBanks[gBankTarget]].pp < 5)
-                gBattleMons[gBankAttacker].pp[gCurrMovePos] = gBattleMoves[gLastUsedMovesByBanks[gBankTarget]].pp;
+            gBattleMons[gBattlerAttacker].moves[gCurrMovePos] = gLastMoves[gBattlerTarget];
+            if (gBattleMoves[gLastMoves[gBattlerTarget]].pp < 5)
+                gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = gBattleMoves[gLastMoves[gBattlerTarget]].pp;
             else
-                gBattleMons[gBankAttacker].pp[gCurrMovePos] = 5;
+                gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = 5;
 
 
-            PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastUsedMovesByBanks[gBankTarget])
+            PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastMoves[gBattlerTarget])
 
-            gDisableStructs[gBankAttacker].unk18_b |= gBitTable[gCurrMovePos];
+            gDisableStructs[gBattlerAttacker].unk18_b |= gBitTable[gCurrMovePos];
             gBattlescriptCurrInstr += 5;
         }
         else
@@ -8547,13 +8410,11 @@ static void atk9D_mimicattackcopy(void)
     }
 }
 
-#ifdef NONMATCHING
 static void atk9E_metronome(void)
 {
     while (1)
     {
-        const u16 *move;
-        s32 i, j;
+        s32 i;
 
         gCurrentMove = (Random() & 0x1FF) + 1;
         if (gCurrentMove > LAST_MOVE_INDEX)
@@ -8561,105 +8422,29 @@ static void atk9E_metronome(void)
 
         for (i = 0; i < 4; i++); // ?
 
-        for (move = sMovesForbiddenToCopy; ; move++)
+        i = -1;
+        while (1)
         {
-            if (*move == gCurrentMove)
+            i++;
+            if (sMovesForbiddenToCopy[i] == gCurrentMove)
                 break;
-            if (*move == METRONOME_FORBIDDEN_END)
+            if (sMovesForbiddenToCopy[i] == METRONOME_FORBIDDEN_END)
                 break;
         }
 
-        if (*move == METRONOME_FORBIDDEN_END)
-            break;
+        if (sMovesForbiddenToCopy[i] == METRONOME_FORBIDDEN_END)
+        {
+            gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
+            gBattlescriptCurrInstr = gBattleScriptsForMoveEffects[gBattleMoves[gCurrentMove].effect];
+            gBattlerTarget = GetMoveTarget(gCurrentMove, 0);
+            return;
+        }
     }
-
-    gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
-    gBattlescriptCurrInstr = gBattleScriptsForMoveEffects[gBattleMoves[gCurrentMove].effect];
-    gBankTarget = GetMoveTarget(gCurrentMove, 0);
-}
-
-#else
-__attribute__((naked))
-static void atk9E_metronome(void)
-{
-    asm(
-    "\n\
-    .syntax unified\n\
-	push {r4-r7,lr}\n\
-	mov r7, r8\n\
-	push {r7}\n\
-	ldr r7, =gCurrentMove\n\
-	movs r6, 0xB1\n\
-	lsls r6, 1\n\
-	ldr r5, =sMovesForbiddenToCopy\n\
-	ldr r0, =gBattlescriptCurrInstr\n\
-	mov r8, r0\n\
-_080524EE:\n\
-	bl Random\n\
-	ldr r2, =0x000001ff\n\
-	adds r1, r2, 0\n\
-	ands r0, r1\n\
-	adds r0, 0x1\n\
-	strh r0, [r7]\n\
-	cmp r0, r6\n\
-	bhi _080524EE\n\
-	movs r0, 0x3\n\
-_08052502:\n\
-	subs r0, 0x1\n\
-	cmp r0, 0\n\
-	bge _08052502\n\
-	ldr r4, =gCurrentMove\n\
-	ldrh r2, [r4]\n\
-	ldr r3, =0x0000ffff\n\
-	subs r0, r5, 0x2\n\
-_08052510:\n\
-	adds r0, 0x2\n\
-	ldrh r1, [r0]\n\
-	cmp r1, r2\n\
-	beq _0805251C\n\
-	cmp r1, r3\n\
-	bne _08052510\n\
-_0805251C:\n\
-	ldr r0, =0x0000ffff\n\
-	cmp r1, r0\n\
-	bne _080524EE\n\
-	ldr r2, =gHitMarker\n\
-	ldr r0, [r2]\n\
-	ldr r1, =0xfffffbff\n\
-	ands r0, r1\n\
-	str r0, [r2]\n\
-	ldr r3, =gBattleScriptsForMoveEffects\n\
-	ldr r2, =gBattleMoves\n\
-	ldrh r1, [r4]\n\
-	lsls r0, r1, 1\n\
-	adds r0, r1\n\
-	lsls r0, 2\n\
-	adds r0, r2\n\
-	ldrb r0, [r0]\n\
-	lsls r0, 2\n\
-	adds r0, r3\n\
-	ldr r0, [r0]\n\
-	mov r1, r8\n\
-	str r0, [r1]\n\
-	ldrh r0, [r4]\n\
-	movs r1, 0\n\
-	bl GetMoveTarget\n\
-	ldr r1, =gBankTarget\n\
-	strb r0, [r1]\n\
-	pop {r3}\n\
-	mov r8, r3\n\
-	pop {r4-r7}\n\
-	pop {r0}\n\
-	bx r0\n\
-    .pool\n\
-    .syntax divided");
 }
 
-#endif // NONMATCHING
-
 static void atk9F_dmgtolevel(void)
 {
-    gBattleMoveDamage = gBattleMons[gBankAttacker].level;
+    gBattleMoveDamage = gBattleMons[gBattlerAttacker].level;
     gBattlescriptCurrInstr++;
 }
 
@@ -8670,54 +8455,54 @@ static void atkA0_psywavedamageeffect(void)
     while ((randDamage = (Random() & 0xF)) > 10);
 
     randDamage *= 10;
-    gBattleMoveDamage = gBattleMons[gBankAttacker].level * (randDamage + 50) / 100;
+    gBattleMoveDamage = gBattleMons[gBattlerAttacker].level * (randDamage + 50) / 100;
     gBattlescriptCurrInstr++;
 }
 
 static void atkA1_counterdamagecalculator(void)
 {
-    u8 sideAttacker = GetBankSide(gBankAttacker);
-    u8 sideTarget = GetBankSide(gProtectStructs[gBankAttacker].physicalBank);
+    u8 sideAttacker = GetBattlerSide(gBattlerAttacker);
+    u8 sideTarget = GetBattlerSide(gProtectStructs[gBattlerAttacker].physicalBattlerId);
 
-    if (gProtectStructs[gBankAttacker].physicalDmg
+    if (gProtectStructs[gBattlerAttacker].physicalDmg
         && sideAttacker != sideTarget
-        && gBattleMons[gProtectStructs[gBankAttacker].physicalBank].hp)
+        && gBattleMons[gProtectStructs[gBattlerAttacker].physicalBattlerId].hp)
     {
-        gBattleMoveDamage = gProtectStructs[gBankAttacker].physicalDmg * 2;
+        gBattleMoveDamage = gProtectStructs[gBattlerAttacker].physicalDmg * 2;
 
         if (gSideTimers[sideTarget].followmeTimer && gBattleMons[gSideTimers[sideTarget].followmeTarget].hp)
-            gBankTarget = gSideTimers[sideTarget].followmeTarget;
+            gBattlerTarget = gSideTimers[sideTarget].followmeTarget;
         else
-            gBankTarget = gProtectStructs[gBankAttacker].physicalBank;
+            gBattlerTarget = gProtectStructs[gBattlerAttacker].physicalBattlerId;
 
         gBattlescriptCurrInstr += 5;
     }
     else
     {
-        gSpecialStatuses[gBankAttacker].flag20 = 1;
+        gSpecialStatuses[gBattlerAttacker].flag20 = 1;
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
 }
 
 static void atkA2_mirrorcoatdamagecalculator(void) // a copy of atkA1 with the physical -> special field changes
 {
-    u8 sideAttacker = GetBankSide(gBankAttacker);
-    u8 sideTarget = GetBankSide(gProtectStructs[gBankAttacker].specialBank);
+    u8 sideAttacker = GetBattlerSide(gBattlerAttacker);
+    u8 sideTarget = GetBattlerSide(gProtectStructs[gBattlerAttacker].specialBattlerId);
 
-    if (gProtectStructs[gBankAttacker].specialDmg && sideAttacker != sideTarget && gBattleMons[gProtectStructs[gBankAttacker].specialBank].hp)
+    if (gProtectStructs[gBattlerAttacker].specialDmg && sideAttacker != sideTarget && gBattleMons[gProtectStructs[gBattlerAttacker].specialBattlerId].hp)
     {
-        gBattleMoveDamage = gProtectStructs[gBankAttacker].specialDmg * 2;
+        gBattleMoveDamage = gProtectStructs[gBattlerAttacker].specialDmg * 2;
 
         if (gSideTimers[sideTarget].followmeTimer && gBattleMons[gSideTimers[sideTarget].followmeTarget].hp)
-            gBankTarget = gSideTimers[sideTarget].followmeTarget;
+            gBattlerTarget = gSideTimers[sideTarget].followmeTarget;
         else
-            gBankTarget = gProtectStructs[gBankAttacker].specialBank;
+            gBattlerTarget = gProtectStructs[gBattlerAttacker].specialBattlerId;
 
         gBattlescriptCurrInstr += 5;
     }
     else
     {
-        gSpecialStatuses[gBankAttacker].flag20 = 1;
+        gSpecialStatuses[gBattlerAttacker].flag20 = 1;
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
 }
@@ -8728,17 +8513,17 @@ static void atkA3_disablelastusedattack(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (gBattleMons[gBankTarget].moves[i] == gLastUsedMovesByBanks[gBankTarget])
+        if (gBattleMons[gBattlerTarget].moves[i] == gLastMoves[gBattlerTarget])
             break;
     }
-    if (gDisableStructs[gBankTarget].disabledMove == 0
-        && i != 4 && gBattleMons[gBankTarget].pp[i] != 0)
+    if (gDisableStructs[gBattlerTarget].disabledMove == 0
+        && i != 4 && gBattleMons[gBattlerTarget].pp[i] != 0)
     {
-        PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleMons[gBankTarget].moves[i])
+        PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerTarget].moves[i])
 
-        gDisableStructs[gBankTarget].disabledMove = gBattleMons[gBankTarget].moves[i];
-        gDisableStructs[gBankTarget].disableTimer1 = (Random() & 3) + 2;
-        gDisableStructs[gBankTarget].disableTimer2 = gDisableStructs[gBankTarget].disableTimer1; // used to save the random amount of turns?
+        gDisableStructs[gBattlerTarget].disabledMove = gBattleMons[gBattlerTarget].moves[i];
+        gDisableStructs[gBattlerTarget].disableTimer1 = (Random() & 3) + 2;
+        gDisableStructs[gBattlerTarget].disableTimer2 = gDisableStructs[gBattlerTarget].disableTimer1; // used to save the random amount of turns?
         gBattlescriptCurrInstr += 5;
     }
     else
@@ -8747,30 +8532,30 @@ static void atkA3_disablelastusedattack(void)
     }
 }
 
-static void atkA4_setencore(void)
+static void atkA4_trysetencore(void)
 {
     s32 i;
 
     for (i = 0; i < 4; i++)
     {
-        if (gBattleMons[gBankTarget].moves[i] == gLastUsedMovesByBanks[gBankTarget])
+        if (gBattleMons[gBattlerTarget].moves[i] == gLastMoves[gBattlerTarget])
             break;
     }
 
-    if (gLastUsedMovesByBanks[gBankTarget] == MOVE_STRUGGLE
-        || gLastUsedMovesByBanks[gBankTarget] == MOVE_ENCORE
-        || gLastUsedMovesByBanks[gBankTarget] == MOVE_MIRROR_MOVE)
+    if (gLastMoves[gBattlerTarget] == MOVE_STRUGGLE
+        || gLastMoves[gBattlerTarget] == MOVE_ENCORE
+        || gLastMoves[gBattlerTarget] == MOVE_MIRROR_MOVE)
     {
         i = 4;
     }
 
-    if (gDisableStructs[gBankTarget].encoredMove == 0
-        && i != 4 && gBattleMons[gBankTarget].pp[i] != 0)
+    if (gDisableStructs[gBattlerTarget].encoredMove == 0
+        && i != 4 && gBattleMons[gBattlerTarget].pp[i] != 0)
     {
-        gDisableStructs[gBankTarget].encoredMove = gBattleMons[gBankTarget].moves[i];
-        gDisableStructs[gBankTarget].encoredMovePos = i;
-        gDisableStructs[gBankTarget].encoreTimer1 = (Random() & 3) + 3;
-        gDisableStructs[gBankTarget].encoreTimer2 = gDisableStructs[gBankTarget].encoreTimer1;
+        gDisableStructs[gBattlerTarget].encoredMove = gBattleMons[gBattlerTarget].moves[i];
+        gDisableStructs[gBattlerTarget].encoredMovePos = i;
+        gDisableStructs[gBattlerTarget].encoreTimer1 = (Random() & 3) + 3;
+        gDisableStructs[gBattlerTarget].encoreTimer2 = gDisableStructs[gBattlerTarget].encoreTimer1;
         gBattlescriptCurrInstr += 5;
     }
     else
@@ -8781,10 +8566,10 @@ static void atkA4_setencore(void)
 
 static void atkA5_painsplitdmgcalc(void)
 {
-    if (!(gBattleMons[gBankTarget].status2 & STATUS2_SUBSTITUTE))
+    if (!(gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE))
     {
-        s32 hpDiff = (gBattleMons[gBankAttacker].hp + gBattleMons[gBankTarget].hp) / 2;
-        s32 painSplitHp = gBattleMoveDamage = gBattleMons[gBankTarget].hp - hpDiff;
+        s32 hpDiff = (gBattleMons[gBattlerAttacker].hp + gBattleMons[gBattlerTarget].hp) / 2;
+        s32 painSplitHp = gBattleMoveDamage = gBattleMons[gBattlerTarget].hp - hpDiff;
         u8* storeLoc = (void*)(&gBattleScripting.painSplitHp);
 
         storeLoc[0] = (painSplitHp);
@@ -8792,8 +8577,8 @@ static void atkA5_painsplitdmgcalc(void)
         storeLoc[2] = (painSplitHp & 0x00FF0000) >> 16;
         storeLoc[3] = (painSplitHp & 0xFF000000) >> 24;
 
-        gBattleMoveDamage = gBattleMons[gBankAttacker].hp - hpDiff;
-        gSpecialStatuses[gBankTarget].moveturnLostHP = 0xFFFF;
+        gBattleMoveDamage = gBattleMons[gBattlerAttacker].hp - hpDiff;
+        gSpecialStatuses[gBattlerTarget].dmg = 0xFFFF;
 
         gBattlescriptCurrInstr += 5;
     }
@@ -8803,338 +8588,97 @@ static void atkA5_painsplitdmgcalc(void)
     }
 }
 
-#ifdef NONMATCHING
 static void atkA6_settypetorandomresistance(void) // conversion 2
 {
-    if (gUnknown_02024250[gBankAttacker] == 0
-        || gUnknown_02024250[gBankAttacker] == 0xFFFF)
+    if (gLastLandedMoves[gBattlerAttacker] == 0
+        || gLastLandedMoves[gBattlerAttacker] == 0xFFFF)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
-    else if (IsTwoTurnsMove(gUnknown_02024250[gBankAttacker])
-            && gBattleMons[gUnknown_02024270[gBankAttacker]].status2 & STATUS2_MULTIPLETURNS)
+    else if (IsTwoTurnsMove(gLastLandedMoves[gBattlerAttacker])
+            && gBattleMons[gLastHitBy[gBattlerAttacker]].status2 & STATUS2_MULTIPLETURNS)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        s32 type = 0, rands = 0;
-        do
+        s32 i, j, rands;
+
+        for (rands = 0; rands < 1000; rands++)
         {
-            while (((type = (Random() & 0x7F)) > 0x70));
+            while (((i = (Random() & 0x7F)) > sizeof(gTypeEffectiveness) / 3));
 
-            type *= 3;
+            i *= 3;
 
-            if (gTypeEffectiveness[type] == gUnknown_02024258[gBankAttacker]
-                && gTypeEffectiveness[type + 2] <= 5
-                && gBattleMons[gBankAttacker].type1 != gTypeEffectiveness[type + 1]
-                && gBattleMons[gBankAttacker].type2 != gTypeEffectiveness[type + 1])
+            if (TYPE_EFFECT_ATK_TYPE(i) == gLastHitByType[gBattlerAttacker]
+                && TYPE_EFFECT_MULTIPLIER(i) <= TYPE_MUL_NOT_EFFECTIVE
+                && gBattleMons[gBattlerAttacker].type1 != TYPE_EFFECT_DEF_TYPE(i)
+                && gBattleMons[gBattlerAttacker].type2 != TYPE_EFFECT_DEF_TYPE(i))
             {
-                gBattleMons[gBankAttacker].type1 = type;
-                gBattleMons[gBankAttacker].type2 = type;
+                gBattleMons[gBattlerAttacker].type1 = TYPE_EFFECT_DEF_TYPE(i);
+                gBattleMons[gBattlerAttacker].type2 = TYPE_EFFECT_DEF_TYPE(i);
 
-                PREPARE_TYPE_BUFFER(gBattleTextBuff1, type)
+                PREPARE_TYPE_BUFFER(gBattleTextBuff1, TYPE_EFFECT_DEF_TYPE(i))
 
                 gBattlescriptCurrInstr += 5;
                 return;
             }
+        }
 
-            rands++;
-        } while (rands <= 999);
-
-        type = 0, rands = 0;
-        do
+        for (j = 0, rands = 0; rands < sizeof(gTypeEffectiveness); j += 3, rands += 3)
         {
-            s8 var = (s8)(gTypeEffectiveness[type]);
-            if (var > -1 || var < -2)
+            switch (TYPE_EFFECT_ATK_TYPE(j))
             {
-                if (gTypeEffectiveness[type] == gUnknown_02024258[gBankAttacker]
-                    && gTypeEffectiveness[type + 2] <= 5
-                    && gBattleMons[gBankAttacker].type1 != gTypeEffectiveness[type + 1]
-                    && gBattleMons[gBankAttacker].type2 != gTypeEffectiveness[type + 1])
+            case TYPE_ENDTABLE:
+            case TYPE_FORESIGHT:
+                break;
+            default:
+                if (TYPE_EFFECT_ATK_TYPE(j) == gLastHitByType[gBattlerAttacker]
+                 && TYPE_EFFECT_MULTIPLIER(j) <= 5
+                 && gBattleMons[gBattlerAttacker].type1 != TYPE_EFFECT_DEF_TYPE(i)
+                 && gBattleMons[gBattlerAttacker].type2 != TYPE_EFFECT_DEF_TYPE(i))
                 {
-                    gBattleMons[gBankAttacker].type1 = gTypeEffectiveness[rands + 1];
-                    gBattleMons[gBankAttacker].type2 = gTypeEffectiveness[rands + 1];
+                    gBattleMons[gBattlerAttacker].type1 = TYPE_EFFECT_DEF_TYPE(rands);
+                    gBattleMons[gBattlerAttacker].type2 = TYPE_EFFECT_DEF_TYPE(rands);
 
-                    PREPARE_TYPE_BUFFER(gBattleTextBuff1, gTypeEffectiveness[rands + 1])
+                    PREPARE_TYPE_BUFFER(gBattleTextBuff1, TYPE_EFFECT_DEF_TYPE(rands))
 
                     gBattlescriptCurrInstr += 5;
                     return;
                 }
+                break;
             }
-            type += 3, rands += 3;
-        } while (rands < 336);
+        }
 
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
 }
 
-#else
-__attribute__((naked))
-static void atkA6_settypetorandomresistance(void) // conversion 2
-{
-    asm(".syntax unified\n\
-	push {r4-r7,lr}\n\
-	mov r7, r10\n\
-	mov r6, r9\n\
-	mov r5, r8\n\
-	push {r5-r7}\n\
-	ldr r1, =gUnknown_02024250\n\
-	ldr r4, =gBankAttacker\n\
-	ldrb r0, [r4]\n\
-	lsls r0, 1\n\
-	adds r2, r0, r1\n\
-	ldrh r1, [r2]\n\
-	cmp r1, 0\n\
-	beq _08052B7E\n\
-	ldr r0, =0x0000ffff\n\
-	cmp r1, r0\n\
-	beq _08052B7E\n\
-	ldrh r0, [r2]\n\
-	bl IsTwoTurnsMove\n\
-	lsls r0, 24\n\
-	cmp r0, 0\n\
-	beq _08052C1C\n\
-	ldr r1, =gBattleMons\n\
-	ldr r2, =gUnknown_02024270\n\
-	ldrb r0, [r4]\n\
-	adds r0, r2\n\
-	ldrb r2, [r0]\n\
-	movs r0, 0x58\n\
-	muls r0, r2\n\
-	adds r1, 0x50\n\
-	adds r0, r1\n\
-	ldr r0, [r0]\n\
-	movs r1, 0x80\n\
-	lsls r1, 5\n\
-	ands r0, r1\n\
-	cmp r0, 0\n\
-	beq _08052C1C\n\
-_08052B7E:\n\
-	ldr r3, =gBattlescriptCurrInstr\n\
-	ldr r2, [r3]\n\
-	ldrb r1, [r2, 0x1]\n\
-	ldrb r0, [r2, 0x2]\n\
-	lsls r0, 8\n\
-	orrs r1, r0\n\
-	ldrb r0, [r2, 0x3]\n\
-	lsls r0, 16\n\
-	orrs r1, r0\n\
-	ldrb r0, [r2, 0x4]\n\
-	lsls r0, 24\n\
-	orrs r1, r0\n\
-	str r1, [r3]\n\
-	b _08052D08\n\
-	.pool\n\
-_08052BB4:\n\
-	mov r0, r12\n\
-	strb r5, [r0]\n\
-	mov r1, r10\n\
-	ldrb r0, [r1]\n\
-	muls r0, r2\n\
-	adds r0, r7\n\
-	adds r0, 0x22\n\
-	strb r5, [r0]\n\
-	ldr r1, =gBattleTextBuff1\n\
-	movs r0, 0xFD\n\
-	strb r0, [r1]\n\
-	movs r0, 0x3\n\
-	strb r0, [r1, 0x1]\n\
-	strb r5, [r1, 0x2]\n\
-	movs r0, 0xFF\n\
-	strb r0, [r1, 0x3]\n\
-	ldr r1, =gBattlescriptCurrInstr\n\
-	b _08052C0A\n\
-	.pool\n\
-_08052BE0:\n\
-	mov r0, r8\n\
-	adds r0, 0x1\n\
-	adds r0, r3\n\
-	ldrb r2, [r0]\n\
-	strb r2, [r4]\n\
-	mov r4, r10\n\
-	ldrb r0, [r4]\n\
-	muls r0, r6\n\
-	ldr r7, =gBattleMons\n\
-	adds r0, r7\n\
-	adds r0, 0x22\n\
-	strb r2, [r0]\n\
-	ldr r1, =gBattleTextBuff1\n\
-	movs r0, 0xFD\n\
-	strb r0, [r1]\n\
-	movs r0, 0x3\n\
-	strb r0, [r1, 0x1]\n\
-	strb r2, [r1, 0x2]\n\
-	movs r0, 0xFF\n\
-	strb r0, [r1, 0x3]\n\
-	mov r1, r12\n\
-_08052C0A:\n\
-	ldr r0, [r1]\n\
-	adds r0, 0x5\n\
-	str r0, [r1]\n\
-	b _08052D08\n\
-	.pool\n\
-_08052C1C:\n\
-	movs r4, 0\n\
-	mov r8, r4\n\
-	movs r7, 0x7F\n\
-	mov r9, r7\n\
-_08052C24:\n\
-	bl Random\n\
-	mov r4, r9\n\
-	ands r4, r0\n\
-	cmp r4, 0x70\n\
-	bhi _08052C24\n\
-	lsls r0, r4, 1\n\
-	adds r4, r0, r4\n\
-	ldr r6, =gTypeEffectiveness\n\
-	adds r3, r4, r6\n\
-	ldr r1, =gUnknown_02024258\n\
-	ldr r2, =gBankAttacker\n\
-	ldrb r5, [r2]\n\
-	lsls r0, r5, 1\n\
-	adds r0, r1\n\
-	ldrb r1, [r3]\n\
-	mov r10, r2\n\
-	ldrh r0, [r0]\n\
-	cmp r1, r0\n\
-	bne _08052C80\n\
-	adds r0, r4, 0x2\n\
-	adds r0, r6\n\
-	ldrb r0, [r0]\n\
-	cmp r0, 0x5\n\
-	bhi _08052C80\n\
-	ldr r7, =gBattleMons\n\
-	movs r2, 0x58\n\
-	adds r0, r5, 0\n\
-	muls r0, r2\n\
-	adds r3, r0, r7\n\
-	movs r0, 0x21\n\
-	adds r0, r3\n\
-	mov r12, r0\n\
-	adds r0, r4, 0x1\n\
-	adds r0, r6\n\
-	ldrb r5, [r0]\n\
-	mov r1, r12\n\
-	ldrb r0, [r1]\n\
-	adds r1, r5, 0\n\
-	cmp r0, r1\n\
-	beq _08052C80\n\
-	adds r0, r3, 0\n\
-	adds r0, 0x22\n\
-	ldrb r0, [r0]\n\
-	cmp r0, r1\n\
-	bne _08052BB4\n\
-_08052C80:\n\
-	movs r7, 0x1\n\
-	add r8, r7\n\
-	ldr r0, =0x000003e7\n\
-	cmp r8, r0\n\
-	ble _08052C24\n\
-	movs r0, 0\n\
-	mov r8, r0\n\
-	ldr r1, =gBattlescriptCurrInstr\n\
-	mov r12, r1\n\
-	ldr r3, =gTypeEffectiveness\n\
-	adds r0, r4, 0x1\n\
-	adds r0, r3\n\
-	mov r9, r0\n\
-	adds r5, r3, 0\n\
-_08052C9C:\n\
-	ldrb r1, [r5]\n\
-	cmp r1, 0xFF\n\
-	bgt _08052CA6\n\
-	cmp r1, 0xFE\n\
-	bge _08052CE0\n\
-_08052CA6:\n\
-	mov r4, r10\n\
-	ldrb r2, [r4]\n\
-	lsls r0, r2, 1\n\
-	ldr r7, =gUnknown_02024258\n\
-	adds r0, r7\n\
-	ldrh r0, [r0]\n\
-	cmp r1, r0\n\
-	bne _08052CE0\n\
-	ldrb r0, [r5, 0x2]\n\
-	cmp r0, 0x5\n\
-	bhi _08052CE0\n\
-	movs r6, 0x58\n\
-	adds r0, r2, 0\n\
-	muls r0, r6\n\
-	ldr r1, =gBattleMons\n\
-	adds r2, r0, r1\n\
-	adds r4, r2, 0\n\
-	adds r4, 0x21\n\
-	ldrb r0, [r4]\n\
-	mov r7, r9\n\
-	ldrb r1, [r7]\n\
-	cmp r0, r1\n\
-	beq _08052CE0\n\
-	adds r0, r2, 0\n\
-	adds r0, 0x22\n\
-	ldrb r0, [r0]\n\
-	cmp r0, r1\n\
-	beq _08052CE0\n\
-	b _08052BE0\n\
-_08052CE0:\n\
-	adds r5, 0x3\n\
-	movs r0, 0x3\n\
-	add r8, r0\n\
-	ldr r0, =0x0000014f\n\
-	cmp r8, r0\n\
-	bls _08052C9C\n\
-	mov r1, r12\n\
-	ldr r2, [r1]\n\
-	ldrb r1, [r2, 0x1]\n\
-	ldrb r0, [r2, 0x2]\n\
-	lsls r0, 8\n\
-	orrs r1, r0\n\
-	ldrb r0, [r2, 0x3]\n\
-	lsls r0, 16\n\
-	orrs r1, r0\n\
-	ldrb r0, [r2, 0x4]\n\
-	lsls r0, 24\n\
-	orrs r1, r0\n\
-	mov r4, r12\n\
-	str r1, [r4]\n\
-_08052D08:\n\
-	pop {r3-r5}\n\
-	mov r8, r3\n\
-	mov r9, r4\n\
-	mov r10, r5\n\
-	pop {r4-r7}\n\
-	pop {r0}\n\
-	bx r0\n\
-	.pool\n\
-        .syntax divided");
-}
-#endif // NONMATCHING
-
 static void atkA7_setalwayshitflag(void)
 {
-    gStatuses3[gBankTarget] &= ~(STATUS3_ALWAYS_HITS);
-    gStatuses3[gBankTarget] |= 0x10;
-    gDisableStructs[gBankTarget].bankWithSureHit = gBankAttacker;
+    gStatuses3[gBattlerTarget] &= ~(STATUS3_ALWAYS_HITS);
+    gStatuses3[gBattlerTarget] |= 0x10;
+    gDisableStructs[gBattlerTarget].battlerWithSureHit = gBattlerAttacker;
     gBattlescriptCurrInstr++;
 }
 
 static void atkA8_copymovepermanently(void) // sketch
 {
-    gLastUsedMove = 0xFFFF;
+    gChosenMove = 0xFFFF;
 
-    if (!(gBattleMons[gBankAttacker].status2 & STATUS2_TRANSFORMED)
-        && gUnknownMovesUsedByBanks[gBankTarget] != MOVE_STRUGGLE
-        && gUnknownMovesUsedByBanks[gBankTarget] != 0
-        && gUnknownMovesUsedByBanks[gBankTarget] != 0xFFFF
-        && gUnknownMovesUsedByBanks[gBankTarget] != MOVE_SKETCH)
+    if (!(gBattleMons[gBattlerAttacker].status2 & STATUS2_TRANSFORMED)
+        && gLastPrintedMoves[gBattlerTarget] != MOVE_STRUGGLE
+        && gLastPrintedMoves[gBattlerTarget] != 0
+        && gLastPrintedMoves[gBattlerTarget] != 0xFFFF
+        && gLastPrintedMoves[gBattlerTarget] != MOVE_SKETCH)
     {
         s32 i;
 
         for (i = 0; i < 4; i++)
         {
-            if (gBattleMons[gBankAttacker].moves[i] == MOVE_SKETCH)
+            if (gBattleMons[gBattlerAttacker].moves[i] == MOVE_SKETCH)
                 continue;
-            if (gBattleMons[gBankAttacker].moves[i] == gUnknownMovesUsedByBanks[gBankTarget])
+            if (gBattleMons[gBattlerAttacker].moves[i] == gLastPrintedMoves[gBattlerTarget])
                 break;
         }
 
@@ -9146,21 +8690,21 @@ static void atkA8_copymovepermanently(void) // sketch
         {
             struct MovePpInfo movePpData;
 
-            gBattleMons[gBankAttacker].moves[gCurrMovePos] = gUnknownMovesUsedByBanks[gBankTarget];
-            gBattleMons[gBankAttacker].pp[gCurrMovePos] = gBattleMoves[gUnknownMovesUsedByBanks[gBankTarget]].pp;
-            gActiveBank = gBankAttacker;
+            gBattleMons[gBattlerAttacker].moves[gCurrMovePos] = gLastPrintedMoves[gBattlerTarget];
+            gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = gBattleMoves[gLastPrintedMoves[gBattlerTarget]].pp;
+            gActiveBattler = gBattlerAttacker;
 
             for (i = 0; i < 4; i++)
             {
-                movePpData.moves[i] = gBattleMons[gBankAttacker].moves[i];
-                movePpData.pp[i] = gBattleMons[gBankAttacker].pp[i];
+                movePpData.moves[i] = gBattleMons[gBattlerAttacker].moves[i];
+                movePpData.pp[i] = gBattleMons[gBattlerAttacker].pp[i];
             }
-            movePpData.ppBonuses = gBattleMons[gBankAttacker].ppBonuses;
+            movePpData.ppBonuses = gBattleMons[gBattlerAttacker].ppBonuses;
 
-            EmitSetMonData(0, REQUEST_MOVES_PP_BATTLE, 0, sizeof(struct MovePpInfo), &movePpData);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitSetMonData(0, REQUEST_MOVES_PP_BATTLE, 0, sizeof(struct MovePpInfo), &movePpData);
+            MarkBattlerForControllerExec(gActiveBattler);
 
-            PREPARE_MOVE_BUFFER(gBattleTextBuff1, gUnknownMovesUsedByBanks[gBankTarget])
+            PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastPrintedMoves[gBattlerTarget])
 
             gBattlescriptCurrInstr += 5;
         }
@@ -9177,7 +8721,7 @@ static bool8 IsTwoTurnsMove(u16 move)
         || gBattleMoves[move].effect == EFFECT_RAZOR_WIND
         || gBattleMoves[move].effect == EFFECT_SKY_ATTACK
         || gBattleMoves[move].effect == EFFECT_SOLARBEAM
-        || gBattleMoves[move].effect == EFFECT_FLY
+        || gBattleMoves[move].effect == EFFECT_SEMI_INVULNERABLE
         || gBattleMoves[move].effect == EFFECT_BIDE)
         return TRUE;
     else
@@ -9193,7 +8737,7 @@ static bool8 IsInvalidForSleepTalkOrAssist(u16 move)
         return FALSE;
 }
 
-static u8 AttacksThisTurn(u8 bank, u16 move) // Note: returns 1 if it's a charging turn, otherwise 2
+static u8 AttacksThisTurn(u8 battlerId, u16 move) // Note: returns 1 if it's a charging turn, otherwise 2
 {
     // first argument is unused
     if (gBattleMoves[move].effect == EFFECT_SOLARBEAM
@@ -9204,7 +8748,7 @@ static u8 AttacksThisTurn(u8 bank, u16 move) // Note: returns 1 if it's a chargi
         || gBattleMoves[move].effect == EFFECT_RAZOR_WIND
         || gBattleMoves[move].effect == EFFECT_SKY_ATTACK
         || gBattleMoves[move].effect == EFFECT_SOLARBEAM
-        || gBattleMoves[move].effect == EFFECT_FLY
+        || gBattleMoves[move].effect == EFFECT_SEMI_INVULNERABLE
         || gBattleMoves[move].effect == EFFECT_BIDE)
     {
         if ((gHitMarker & HITMARKER_x8000000))
@@ -9213,24 +8757,24 @@ static u8 AttacksThisTurn(u8 bank, u16 move) // Note: returns 1 if it's a chargi
     return 2;
 }
 
-static void atkA9_sleeptalk_choose_move(void)
+static void atkA9_trychoosesleeptalkmove(void)
 {
     s32 i;
     u8 unusableMovesBits = 0;
 
     for (i = 0; i < 4; i++)
     {
-        if (IsInvalidForSleepTalkOrAssist(gBattleMons[gBankAttacker].moves[i])
-            || gBattleMons[gBankAttacker].moves[i] == MOVE_FOCUS_PUNCH
-            || gBattleMons[gBankAttacker].moves[i] == MOVE_UPROAR
-            || IsTwoTurnsMove(gBattleMons[gBankAttacker].moves[i]))
+        if (IsInvalidForSleepTalkOrAssist(gBattleMons[gBattlerAttacker].moves[i])
+            || gBattleMons[gBattlerAttacker].moves[i] == MOVE_FOCUS_PUNCH
+            || gBattleMons[gBattlerAttacker].moves[i] == MOVE_UPROAR
+            || IsTwoTurnsMove(gBattleMons[gBattlerAttacker].moves[i]))
         {
             unusableMovesBits |= gBitTable[i];
         }
 
     }
 
-    unusableMovesBits = CheckMoveLimitations(gBankAttacker, unusableMovesBits, ~(MOVE_LIMITATION_PP));
+    unusableMovesBits = CheckMoveLimitations(gBattlerAttacker, unusableMovesBits, ~(MOVE_LIMITATION_PP));
     if (unusableMovesBits == 0xF) // all 4 moves cannot be chosen
     {
         gBattlescriptCurrInstr += 5;
@@ -9244,25 +8788,25 @@ static void atkA9_sleeptalk_choose_move(void)
             movePosition = Random() & 3;
         } while ((gBitTable[movePosition] & unusableMovesBits));
 
-        gRandomMove = gBattleMons[gBankAttacker].moves[movePosition];
+        gRandomMove = gBattleMons[gBattlerAttacker].moves[movePosition];
         gCurrMovePos = movePosition;
         gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
-        gBankTarget = GetMoveTarget(gRandomMove, 0);
+        gBattlerTarget = GetMoveTarget(gRandomMove, 0);
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
 }
 
-static void atkAA_set_destinybond(void)
+static void atkAA_setdestinybond(void)
 {
-    gBattleMons[gBankAttacker].status2 |= STATUS2_DESTINY_BOND;
+    gBattleMons[gBattlerAttacker].status2 |= STATUS2_DESTINY_BOND;
     gBattlescriptCurrInstr++;
 }
 
-static void DestinyBondFlagUpdate(void)
+static void TrySetDestinyBondToHappen(void)
 {
-    u8 sideAttacker = GetBankSide(gBankAttacker);
-    u8 sideTarget = GetBankSide(gBankTarget);
-    if (gBattleMons[gBankTarget].status2 & STATUS2_DESTINY_BOND
+    u8 sideAttacker = GetBattlerSide(gBattlerAttacker);
+    u8 sideTarget = GetBattlerSide(gBattlerTarget);
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_DESTINY_BOND
         && sideAttacker != sideTarget
         && !(gHitMarker & HITMARKER_GRUDGE))
     {
@@ -9270,16 +8814,16 @@ static void DestinyBondFlagUpdate(void)
     }
 }
 
-static void atkAB_DestinyBondFlagUpdate(void)
+static void atkAB_trysetdestinybondtohappen(void)
 {
-    DestinyBondFlagUpdate();
+    TrySetDestinyBondToHappen();
     gBattlescriptCurrInstr++;
 }
 
 static void atkAC_remaininghptopower(void)
 {
     s32 i;
-    s32 hpFraction = GetScaledHPFraction(gBattleMons[gBankAttacker].hp, gBattleMons[gBankAttacker].maxHP, 48);
+    s32 hpFraction = GetScaledHPFraction(gBattleMons[gBattlerAttacker].hp, gBattleMons[gBattlerAttacker].maxHP, 48);
 
     for (i = 0; i < (s32) sizeof(sFlailHpScaleToPowerTable); i += 2)
     {
@@ -9291,45 +8835,45 @@ static void atkAC_remaininghptopower(void)
     gBattlescriptCurrInstr++;
 }
 
-static void atkAD_spite_ppreduce(void)
+static void atkAD_tryspiteppreduce(void)
 {
-    if (gLastUsedMovesByBanks[gBankTarget] != 0
-        && gLastUsedMovesByBanks[gBankTarget] != 0xFFFF)
+    if (gLastMoves[gBattlerTarget] != 0
+        && gLastMoves[gBattlerTarget] != 0xFFFF)
     {
         s32 i;
 
         for (i = 0; i < 4; i++)
         {
-            if (gLastUsedMovesByBanks[gBankTarget] == gBattleMons[gBankTarget].moves[i])
+            if (gLastMoves[gBattlerTarget] == gBattleMons[gBattlerTarget].moves[i])
                 break;
         }
 
-        if (i != 4 && gBattleMons[gBankTarget].pp[i] > 1)
+        if (i != 4 && gBattleMons[gBattlerTarget].pp[i] > 1)
         {
             s32 ppToDeduct = (Random() & 3) + 2;
-            if (gBattleMons[gBankTarget].pp[i] < ppToDeduct)
-                ppToDeduct = gBattleMons[gBankTarget].pp[i];
+            if (gBattleMons[gBattlerTarget].pp[i] < ppToDeduct)
+                ppToDeduct = gBattleMons[gBattlerTarget].pp[i];
 
-            PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastUsedMovesByBanks[gBankTarget])
+            PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastMoves[gBattlerTarget])
 
             ConvertIntToDecimalStringN(gBattleTextBuff2, ppToDeduct, 0, 1);
 
             PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff2, 1, ppToDeduct)
 
-            gBattleMons[gBankTarget].pp[i] -= ppToDeduct;
-            gActiveBank = gBankTarget;
+            gBattleMons[gBattlerTarget].pp[i] -= ppToDeduct;
+            gActiveBattler = gBattlerTarget;
 
-            if (!(gDisableStructs[gActiveBank].unk18_b & gBitTable[i])
-                && !(gBattleMons[gActiveBank].status2 & STATUS2_TRANSFORMED))
+            if (!(gDisableStructs[gActiveBattler].unk18_b & gBitTable[i])
+                && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
             {
-                EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + i, 0, 1, &gBattleMons[gActiveBank].pp[i]);
-                MarkBufferBankForExecution(gActiveBank);
+                BtlController_EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + i, 0, 1, &gBattleMons[gActiveBattler].pp[i]);
+                MarkBattlerForControllerExec(gActiveBattler);
             }
 
             gBattlescriptCurrInstr += 5;
 
-            if (gBattleMons[gBankTarget].pp[i] == 0)
-                CancelMultiTurnMoves(gBankTarget);
+            if (gBattleMons[gBattlerTarget].pp[i] == 0)
+                CancelMultiTurnMoves(gBattlerTarget);
         }
         else
         {
@@ -9342,7 +8886,7 @@ static void atkAD_spite_ppreduce(void)
     }
 }
 
-static void atkAE_heal_party_status(void)
+static void atkAE_healpartystatus(void)
 {
     u32 zero = 0;
     u8 toHeal = 0;
@@ -9354,35 +8898,35 @@ static void atkAE_heal_party_status(void)
 
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
 
-        if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
+        if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
             party = gPlayerParty;
         else
             party = gEnemyParty;
 
-        if (gBattleMons[gBankAttacker].ability != ABILITY_SOUNDPROOF)
+        if (gBattleMons[gBattlerAttacker].ability != ABILITY_SOUNDPROOF)
         {
-            gBattleMons[gBankAttacker].status1 = 0;
-            gBattleMons[gBankAttacker].status2 &= ~(STATUS2_NIGHTMARE);
+            gBattleMons[gBattlerAttacker].status1 = 0;
+            gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_NIGHTMARE);
         }
         else
         {
-            RecordAbilityBattle(gBankAttacker, gBattleMons[gBankAttacker].ability);
+            RecordAbilityBattle(gBattlerAttacker, gBattleMons[gBattlerAttacker].ability);
             gBattleCommunication[MULTISTRING_CHOOSER] |= 1;
         }
 
-        gActiveBank = gBattleScripting.bank = GetBankByIdentity(GetBankIdentity(gBankAttacker) ^ BIT_MON);
+        gActiveBattler = gBattleScripting.battler = GetBattlerAtPosition(GetBattlerPosition(gBattlerAttacker) ^ BIT_FLANK);
 
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE
-            && !(gAbsentBankFlags & gBitTable[gActiveBank]))
+            && !(gAbsentBattlerFlags & gBitTable[gActiveBattler]))
         {
-            if (gBattleMons[gActiveBank].ability != ABILITY_SOUNDPROOF)
+            if (gBattleMons[gActiveBattler].ability != ABILITY_SOUNDPROOF)
             {
-                gBattleMons[gActiveBank].status1 = 0;
-                gBattleMons[gActiveBank].status2 &= ~(STATUS2_NIGHTMARE);
+                gBattleMons[gActiveBattler].status1 = 0;
+                gBattleMons[gActiveBattler].status2 &= ~(STATUS2_NIGHTMARE);
             }
             else
             {
-                RecordAbilityBattle(gActiveBank, gBattleMons[gActiveBank].ability);
+                RecordAbilityBattle(gActiveBattler, gBattleMons[gActiveBattler].ability);
                 gBattleCommunication[MULTISTRING_CHOOSER] |= 2;
             }
         }
@@ -9396,12 +8940,12 @@ static void atkAE_heal_party_status(void)
             {
                 u8 ability;
 
-                if (gBattlePartyID[gBankAttacker] == i)
-                    ability = gBattleMons[gBankAttacker].ability;
+                if (gBattlerPartyIndexes[gBattlerAttacker] == i)
+                    ability = gBattleMons[gBattlerAttacker].ability;
                 else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE
-                         && gBattlePartyID[gActiveBank] == i
-                         && !(gAbsentBankFlags & gBitTable[gActiveBank]))
-                    ability = gBattleMons[gActiveBank].ability;
+                         && gBattlerPartyIndexes[gActiveBattler] == i
+                         && !(gAbsentBattlerFlags & gBitTable[gActiveBattler]))
+                    ability = gBattleMons[gActiveBattler].ability;
                 else
                     ability = GetAbilityBySpecies(species, abilityBit);
 
@@ -9415,24 +8959,24 @@ static void atkAE_heal_party_status(void)
         gBattleCommunication[MULTISTRING_CHOOSER] = 4;
         toHeal = 0x3F;
 
-        gBattleMons[gBankAttacker].status1 = 0;
-        gBattleMons[gBankAttacker].status2 &= ~(STATUS2_NIGHTMARE);
+        gBattleMons[gBattlerAttacker].status1 = 0;
+        gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_NIGHTMARE);
 
-        gActiveBank = GetBankByIdentity(GetBankIdentity(gBankAttacker) ^ 2);
+        gActiveBattler = GetBattlerAtPosition(GetBattlerPosition(gBattlerAttacker) ^ BIT_FLANK);
         if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE
-            && !(gAbsentBankFlags & gBitTable[gActiveBank]))
+            && !(gAbsentBattlerFlags & gBitTable[gActiveBattler]))
         {
-            gBattleMons[gActiveBank].status1 = 0;
-            gBattleMons[gActiveBank].status2 &= ~(STATUS2_NIGHTMARE);
+            gBattleMons[gActiveBattler].status1 = 0;
+            gBattleMons[gActiveBattler].status2 &= ~(STATUS2_NIGHTMARE);
         }
 
     }
 
     if (toHeal)
     {
-        gActiveBank = gBankAttacker;
-        EmitSetMonData(0, REQUEST_STATUS_BATTLE, toHeal, 4, &zero);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = gBattlerAttacker;
+        BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, toHeal, 4, &zero);
+        MarkBattlerForControllerExec(gActiveBattler);
     }
 
     gBattlescriptCurrInstr++;
@@ -9440,14 +8984,14 @@ static void atkAE_heal_party_status(void)
 
 static void atkAF_cursetarget(void)
 {
-    if (gBattleMons[gBankTarget].status2 & STATUS2_CURSED)
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_CURSED)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gBattleMons[gBankTarget].status2 |= STATUS2_CURSED;
-        gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / 2;
+        gBattleMons[gBattlerTarget].status2 |= STATUS2_CURSED;
+        gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 2;
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
 
@@ -9455,35 +8999,35 @@ static void atkAF_cursetarget(void)
     }
 }
 
-static void atkB0_set_spikes(void)
+static void atkB0_trysetspikes(void)
 {
-    u8 targetSide = GetBankSide(gBankAttacker) ^ BIT_SIDE;
+    u8 targetSide = GetBattlerSide(gBattlerAttacker) ^ BIT_SIDE;
 
     if (gSideTimers[targetSide].spikesAmount == 3)
     {
-        gSpecialStatuses[gBankAttacker].flag20 = 1;
+        gSpecialStatuses[gBattlerAttacker].flag20 = 1;
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gSideAffecting[targetSide] |= SIDE_STATUS_SPIKES;
+        gSideStatuses[targetSide] |= SIDE_STATUS_SPIKES;
         gSideTimers[targetSide].spikesAmount++;
         gBattlescriptCurrInstr += 5;
     }
 }
 
-static void atkB1_set_foresight(void)
+static void atkB1_setforesight(void)
 {
-    gBattleMons[gBankTarget].status2 |= STATUS2_FORESIGHT;
+    gBattleMons[gBattlerTarget].status2 |= STATUS2_FORESIGHT;
     gBattlescriptCurrInstr++;
 }
 
-static void atkB2_setperishsong(void)
+static void atkB2_trysetperishsong(void)
 {
     s32 i;
     s32 notAffectedCount = 0;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
         if (gStatuses3[i] & STATUS3_PERISH_SONG
             || gBattleMons[i].ability == ABILITY_SOUNDPROOF)
@@ -9493,14 +9037,14 @@ static void atkB2_setperishsong(void)
         else
         {
             gStatuses3[i] |= STATUS3_PERISH_SONG;
-            gDisableStructs[i].perishSong1 = 3;
-            gDisableStructs[i].perishSong2 = 3;
+            gDisableStructs[i].perishSongTimer1 = 3;
+            gDisableStructs[i].perishSongTimer2 = 3;
         }
     }
 
-    PressurePPLoseOnUsingPerishSong(gBankAttacker);
+    PressurePPLoseOnUsingPerishSong(gBattlerAttacker);
 
-    if (notAffectedCount == gNoOfAllBanks)
+    if (notAffectedCount == gBattlersCount)
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     else
         gBattlescriptCurrInstr += 5;
@@ -9508,33 +9052,33 @@ static void atkB2_setperishsong(void)
 
 static void atkB3_rolloutdamagecalculation(void)
 {
-    if (gBattleMoveFlags & MOVESTATUS_NOEFFECT)
+    if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT)
     {
-        CancelMultiTurnMoves(gBankAttacker);
-        gBattlescriptCurrInstr = BattleScript_PauseEffectivenessSoundResultMsgEndMove;
+        CancelMultiTurnMoves(gBattlerAttacker);
+        gBattlescriptCurrInstr = BattleScript_MoveMissedPause;
     }
     else
     {
         s32 i;
 
-        if (!(gBattleMons[gBankAttacker].status2 & STATUS2_MULTIPLETURNS)) // first hit
+        if (!(gBattleMons[gBattlerAttacker].status2 & STATUS2_MULTIPLETURNS)) // first hit
         {
-            gDisableStructs[gBankAttacker].rolloutCounter1 = 5;
-            gDisableStructs[gBankAttacker].rolloutCounter2 = 5;
-            gBattleMons[gBankAttacker].status2 |= STATUS2_MULTIPLETURNS;
-            gLockedMoves[gBankAttacker] = gCurrentMove;
+            gDisableStructs[gBattlerAttacker].rolloutCounter1 = 5;
+            gDisableStructs[gBattlerAttacker].rolloutCounter2 = 5;
+            gBattleMons[gBattlerAttacker].status2 |= STATUS2_MULTIPLETURNS;
+            gLockedMoves[gBattlerAttacker] = gCurrentMove;
         }
-        if (--gDisableStructs[gBankAttacker].rolloutCounter1 == 0) // last hit
+        if (--gDisableStructs[gBattlerAttacker].rolloutCounter1 == 0) // last hit
         {
-            gBattleMons[gBankAttacker].status2 &= ~(STATUS2_MULTIPLETURNS);
+            gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_MULTIPLETURNS);
         }
 
         gDynamicBasePower = gBattleMoves[gCurrentMove].power;
 
-        for (i = 1; i < (5 - gDisableStructs[gBankAttacker].rolloutCounter1); i++)
+        for (i = 1; i < (5 - gDisableStructs[gBattlerAttacker].rolloutCounter1); i++)
             gDynamicBasePower *= 2;
 
-        if (gBattleMons[gBankAttacker].status2 & STATUS2_DEFENSE_CURL)
+        if (gBattleMons[gBattlerAttacker].status2 & STATUS2_DEFENSE_CURL)
             gDynamicBasePower *= 2;
 
         gBattlescriptCurrInstr++;
@@ -9543,8 +9087,8 @@ static void atkB3_rolloutdamagecalculation(void)
 
 static void atkB4_jumpifconfusedandstatmaxed(void)
 {
-    if (gBattleMons[gBankTarget].status2 & STATUS2_CONFUSION
-        && gBattleMons[gBankTarget].statStages[gBattlescriptCurrInstr[1]] == 0xC)
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_CONFUSION
+        && gBattleMons[gBattlerTarget].statStages[gBattlescriptCurrInstr[1]] == 0xC)
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 2);
     else
         gBattlescriptCurrInstr += 6;
@@ -9552,21 +9096,21 @@ static void atkB4_jumpifconfusedandstatmaxed(void)
 
 static void atkB5_furycuttercalc(void)
 {
-    if (gBattleMoveFlags & MOVESTATUS_NOEFFECT)
+    if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT)
     {
-        gDisableStructs[gBankAttacker].furyCutterCounter = 0;
-        gBattlescriptCurrInstr = BattleScript_PauseEffectivenessSoundResultMsgEndMove;
+        gDisableStructs[gBattlerAttacker].furyCutterCounter = 0;
+        gBattlescriptCurrInstr = BattleScript_MoveMissedPause;
     }
     else
     {
         s32 i;
 
-        if (gDisableStructs[gBankAttacker].furyCutterCounter != 5)
-            gDisableStructs[gBankAttacker].furyCutterCounter++;
+        if (gDisableStructs[gBattlerAttacker].furyCutterCounter != 5)
+            gDisableStructs[gBattlerAttacker].furyCutterCounter++;
 
         gDynamicBasePower = gBattleMoves[gCurrentMove].power;
 
-        for (i = 1; i < gDisableStructs[gBankAttacker].furyCutterCounter; i++)
+        for (i = 1; i < gDisableStructs[gBattlerAttacker].furyCutterCounter; i++)
             gDynamicBasePower *= 2;
 
         gBattlescriptCurrInstr++;
@@ -9576,9 +9120,9 @@ static void atkB5_furycuttercalc(void)
 static void atkB6_happinesstodamagecalculation(void)
 {
     if (gBattleMoves[gCurrentMove].effect == EFFECT_RETURN)
-        gDynamicBasePower = 10 * (gBattleMons[gBankAttacker].friendship) / 25;
+        gDynamicBasePower = 10 * (gBattleMons[gBattlerAttacker].friendship) / 25;
     else // EFFECT_FRUSTRATION
-        gDynamicBasePower = 10 * (255 - gBattleMons[gBankAttacker].friendship) / 25;
+        gDynamicBasePower = 10 * (255 - gBattleMons[gBattlerAttacker].friendship) / 25;
 
     gBattlescriptCurrInstr++;
 }
@@ -9595,34 +9139,34 @@ static void atkB7_presentdamagecalculation(void)
         gDynamicBasePower = 120;
     else
     {
-        gBattleMoveDamage = gBattleMons[gBankTarget].maxHP / 4;
+        gBattleMoveDamage = gBattleMons[gBattlerTarget].maxHP / 4;
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
         gBattleMoveDamage *= -1;
     }
     if (rand < 204)
-        gBattlescriptCurrInstr = BattleScript_PresentDamageTarget;
-    else if (gBattleMons[gBankTarget].maxHP == gBattleMons[gBankTarget].hp)
+        gBattlescriptCurrInstr = BattleScript_HitFromCritCalc;
+    else if (gBattleMons[gBattlerTarget].maxHP == gBattleMons[gBattlerTarget].hp)
         gBattlescriptCurrInstr = BattleScript_AlreadyAtFullHp;
     else
     {
-        gBattleMoveFlags &= ~(MOVESTATUS_NOTAFFECTED);
+        gMoveResultFlags &= ~(MOVE_RESULT_DOESNT_AFFECT_FOE);
         gBattlescriptCurrInstr = BattleScript_PresentHealTarget;
     }
 }
 
-static void atkB8_set_safeguard(void)
+static void atkB8_setsafeguard(void)
 {
-    if (gSideAffecting[GET_BANK_SIDE(gBankAttacker)] & SIDE_STATUS_SAFEGUARD)
+    if (gSideStatuses[GET_BATTLER_SIDE(gBattlerAttacker)] & SIDE_STATUS_SAFEGUARD)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 0;
     }
     else
     {
-        gSideAffecting[GET_BANK_SIDE(gBankAttacker)] |= SIDE_STATUS_SAFEGUARD;
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].safeguardTimer = 5;
-        gSideTimers[GET_BANK_SIDE(gBankAttacker)].safeguardBank = gBankAttacker;
+        gSideStatuses[GET_BATTLER_SIDE(gBattlerAttacker)] |= SIDE_STATUS_SAFEGUARD;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].safeguardTimer = 5;
+        gSideTimers[GET_BATTLER_SIDE(gBattlerAttacker)].safeguardBattlerId = gBattlerAttacker;
         gBattleCommunication[MULTISTRING_CHOOSER] = 5;
     }
 
@@ -9672,11 +9216,11 @@ static void atkB9_magnitudedamagecalculation(void)
 
     PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff1, 2, magnitude)
 
-    for (gBankTarget = 0; gBankTarget < gNoOfAllBanks; gBankTarget++)
+    for (gBattlerTarget = 0; gBattlerTarget < gBattlersCount; gBattlerTarget++)
     {
-        if (gBankTarget == gBankAttacker)
+        if (gBattlerTarget == gBattlerAttacker)
             continue;
-        if (!(gAbsentBankFlags & gBitTable[gBankTarget])) // a valid target was found
+        if (!(gAbsentBattlerFlags & gBitTable[gBattlerTarget])) // a valid target was found
             break;
     }
 
@@ -9687,36 +9231,36 @@ static void atkBA_jumpifnopursuitswitchdmg(void)
 {
     if (gMultiHitCounter == 1)
     {
-        if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
-            gBankTarget = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
+        if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
+            gBattlerTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
         else
-            gBankTarget = GetBankByIdentity(IDENTITY_PLAYER_MON1);
+            gBattlerTarget = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
     }
     else
     {
-        if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
-            gBankTarget = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
+        if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
+            gBattlerTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
         else
-            gBankTarget = GetBankByIdentity(IDENTITY_PLAYER_MON2);
+            gBattlerTarget = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
     }
 
-    if (gActionForBanks[gBankTarget] == 0
-        && gBankAttacker == *(gBattleStruct->moveTarget + gBankTarget)
-        && !(gBattleMons[gBankTarget].status1 & (STATUS_SLEEP | STATUS_FREEZE))
-        && gBattleMons[gBankAttacker].hp
-        && !gDisableStructs[gBankTarget].truantCounter
-        && gChosenMovesByBanks[gBankTarget] == MOVE_PURSUIT)
+    if (gChosenActionByBattler[gBattlerTarget] == B_ACTION_USE_MOVE
+        && gBattlerAttacker == *(gBattleStruct->moveTarget + gBattlerTarget)
+        && !(gBattleMons[gBattlerTarget].status1 & (STATUS1_SLEEP | STATUS1_FREEZE))
+        && gBattleMons[gBattlerAttacker].hp
+        && !gDisableStructs[gBattlerTarget].truantCounter
+        && gChosenMoveByBattler[gBattlerTarget] == MOVE_PURSUIT)
     {
         s32 i;
 
-        for (i = 0; i < gNoOfAllBanks; i++)
+        for (i = 0; i < gBattlersCount; i++)
         {
-            if (gBanksByTurnOrder[i] == gBankTarget)
+            if (gBattleTurnOrder[i] == gBattlerTarget)
                 gActionsByTurnOrder[i] = 11;
         }
 
         gCurrentMove = MOVE_PURSUIT;
-        gCurrMovePos = gUnknown_020241E9 = *(gBattleStruct->chosenMovePositions + gBankTarget);
+        gCurrMovePos = gChosenMovePos = *(gBattleStruct->chosenMovePositions + gBattlerTarget);
         gBattlescriptCurrInstr += 5;
         gBattleScripting.animTurn = 1;
         gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
@@ -9731,7 +9275,7 @@ static void atkBB_setsunny(void)
 {
     if (gBattleWeather & WEATHER_SUN_ANY)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 2;
     }
     else
@@ -9746,16 +9290,16 @@ static void atkBB_setsunny(void)
 
 static void atkBC_maxattackhalvehp(void) // belly drum
 {
-    u32 halfHp = gBattleMons[gBankAttacker].maxHP / 2;
+    u32 halfHp = gBattleMons[gBattlerAttacker].maxHP / 2;
 
-    if (!(gBattleMons[gBankAttacker].maxHP / 2))
+    if (!(gBattleMons[gBattlerAttacker].maxHP / 2))
         halfHp = 1;
 
-    if (gBattleMons[gBankAttacker].statStages[STAT_STAGE_ATK] < 12
-        && gBattleMons[gBankAttacker].hp > halfHp)
+    if (gBattleMons[gBattlerAttacker].statStages[STAT_ATK] < 12
+        && gBattleMons[gBattlerAttacker].hp > halfHp)
     {
-        gBattleMons[gBankAttacker].statStages[STAT_STAGE_ATK] = 12;
-        gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / 2;
+        gBattleMons[gBattlerAttacker].statStages[STAT_ATK] = 12;
+        gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 2;
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
 
@@ -9773,7 +9317,7 @@ static void atkBD_copyfoestats(void) // psych up
 
     for (i = 0; i < BATTLE_STATS_NO; i++)
     {
-        gBattleMons[gBankAttacker].statStages[i] = gBattleMons[gBankTarget].statStages[i];
+        gBattleMons[gBattlerAttacker].statStages[i] = gBattleMons[gBattlerTarget].statStages[i];
     }
 
     gBattlescriptCurrInstr += 5; // Has an unused jump ptr(possibly for a failed attempt) parameter.
@@ -9781,32 +9325,32 @@ static void atkBD_copyfoestats(void) // psych up
 
 static void atkBE_rapidspinfree(void)
 {
-    if (gBattleMons[gBankAttacker].status2 & STATUS2_WRAPPED)
+    if (gBattleMons[gBattlerAttacker].status2 & STATUS2_WRAPPED)
     {
-        gBattleScripting.bank = gBankTarget;
-        gBattleMons[gBankAttacker].status2 &= ~(STATUS2_WRAPPED);
-        gBankTarget = *(gBattleStruct->wrappedBy + gBankAttacker);
+        gBattleScripting.battler = gBattlerTarget;
+        gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_WRAPPED);
+        gBattlerTarget = *(gBattleStruct->wrappedBy + gBattlerAttacker);
 
         gBattleTextBuff1[0] = B_BUFF_PLACEHOLDER_BEGIN;
         gBattleTextBuff1[1] = B_BUFF_MOVE;
-        gBattleTextBuff1[2] = *(gBattleStruct->wrappedMove + gBankAttacker * 2 + 0);
-        gBattleTextBuff1[3] = *(gBattleStruct->wrappedMove + gBankAttacker * 2 + 1);
+        gBattleTextBuff1[2] = *(gBattleStruct->wrappedMove + gBattlerAttacker * 2 + 0);
+        gBattleTextBuff1[3] = *(gBattleStruct->wrappedMove + gBattlerAttacker * 2 + 1);
         gBattleTextBuff1[4] = B_BUFF_EOS;
 
         BattleScriptPushCursor();
         gBattlescriptCurrInstr = BattleScript_WrapFree;
     }
-    else if (gStatuses3[gBankAttacker] & STATUS3_LEECHSEED)
+    else if (gStatuses3[gBattlerAttacker] & STATUS3_LEECHSEED)
     {
-        gStatuses3[gBankAttacker] &= ~(STATUS3_LEECHSEED);
-        gStatuses3[gBankAttacker] &= ~(STATUS3_LEECHSEED_BANK);
+        gStatuses3[gBattlerAttacker] &= ~(STATUS3_LEECHSEED);
+        gStatuses3[gBattlerAttacker] &= ~(STATUS3_LEECHSEED_BANK);
         BattleScriptPushCursor();
         gBattlescriptCurrInstr = BattleScript_LeechSeedFree;
     }
-    else if (gSideAffecting[GetBankSide(gBankAttacker)] & SIDE_STATUS_SPIKES)
+    else if (gSideStatuses[GetBattlerSide(gBattlerAttacker)] & SIDE_STATUS_SPIKES)
     {
-        gSideAffecting[GetBankSide(gBankAttacker)] &= ~(SIDE_STATUS_SPIKES);
-        gSideTimers[GetBankSide(gBankAttacker)].spikesAmount = 0;
+        gSideStatuses[GetBattlerSide(gBattlerAttacker)] &= ~(SIDE_STATUS_SPIKES);
+        gSideTimers[GetBattlerSide(gBattlerAttacker)].spikesAmount = 0;
         BattleScriptPushCursor();
         gBattlescriptCurrInstr = BattleScript_SpikesFree;
     }
@@ -9816,24 +9360,24 @@ static void atkBE_rapidspinfree(void)
     }
 }
 
-static void atkBF_set_defense_curl(void)
+static void atkBF_setdefensecurlbit(void)
 {
-    gBattleMons[gBankAttacker].status2 |= STATUS2_DEFENSE_CURL;
+    gBattleMons[gBattlerAttacker].status2 |= STATUS2_DEFENSE_CURL;
     gBattlescriptCurrInstr++;
 }
 
 static void atkC0_recoverbasedonsunlight(void)
 {
-    gBankTarget = gBankAttacker;
+    gBattlerTarget = gBattlerAttacker;
 
-    if (gBattleMons[gBankAttacker].hp != gBattleMons[gBankAttacker].maxHP)
+    if (gBattleMons[gBattlerAttacker].hp != gBattleMons[gBattlerAttacker].maxHP)
     {
         if (gBattleWeather == 0 || !WEATHER_HAS_EFFECT)
-            gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / 2;
+            gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 2;
         else if (gBattleWeather & WEATHER_SUN_ANY)
-            gBattleMoveDamage = 20 * gBattleMons[gBankAttacker].maxHP / 30;
+            gBattleMoveDamage = 20 * gBattleMons[gBattlerAttacker].maxHP / 30;
         else // not sunny weather
-            gBattleMoveDamage = gBattleMons[gBankAttacker].maxHP / 4;
+            gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 4;
 
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
@@ -9848,24 +9392,24 @@ static void atkC0_recoverbasedonsunlight(void)
 }
 
 #ifdef NONMATCHING
-static void atkC1_hidden_power(void)
+static void atkC1_hiddenpowercalc(void)
 {
-    s32 powerBits;
-    s32 typeBits;
+    u32 powerBits = 0;
+    u32 typeBits = 0;
 
-    powerBits = ((gBattleMons[gBankAttacker].hpIV & 2) >> 1)
-                  | ((gBattleMons[gBankAttacker].attackIV & 2) << 0)
-                  | ((gBattleMons[gBankAttacker].defenseIV & 2) << 1)
-                  | ((gBattleMons[gBankAttacker].speedIV & 2) << 2)
-                  | ((gBattleMons[gBankAttacker].spAttackIV & 2) << 3)
-                  | ((gBattleMons[gBankAttacker].spDefenseIV & 2) << 4);
+    powerBits |= ((gBattleMons[gBattlerAttacker].hpIV & 2) >> 1);
+    powerBits |= ((gBattleMons[gBattlerAttacker].attackIV & 2) << 0);
+    powerBits |= ((gBattleMons[gBattlerAttacker].defenseIV & 2) << 1);
+    powerBits |= ((gBattleMons[gBattlerAttacker].speedIV & 2) << 2);
+    powerBits |= ((gBattleMons[gBattlerAttacker].spAttackIV & 2) << 3);
+    powerBits |= ((gBattleMons[gBattlerAttacker].spDefenseIV & 2) << 4);
 
-    typeBits = ((gBattleMons[gBankAttacker].hpIV & 1) << 0)
-                  | ((gBattleMons[gBankAttacker].attackIV & 1) << 1)
-                  | ((gBattleMons[gBankAttacker].defenseIV & 1) << 2)
-                  | ((gBattleMons[gBankAttacker].speedIV & 1) << 3)
-                  | ((gBattleMons[gBankAttacker].spAttackIV & 1) << 4)
-                  | ((gBattleMons[gBankAttacker].spDefenseIV & 1) << 5);
+    typeBits |= ((gBattleMons[gBattlerAttacker].hpIV & 1) << 0);
+    typeBits |= ((gBattleMons[gBattlerAttacker].attackIV & 1) << 1);
+    typeBits |= ((gBattleMons[gBattlerAttacker].defenseIV & 1) << 2);
+    typeBits |= ((gBattleMons[gBattlerAttacker].speedIV & 1) << 3);
+    typeBits |= ((gBattleMons[gBattlerAttacker].spAttackIV & 1) << 4);
+    typeBits |= ((gBattleMons[gBattlerAttacker].spDefenseIV & 1) << 5);
 
     gDynamicBasePower = (40 * powerBits) / 63 + 30;
 
@@ -9879,7 +9423,7 @@ static void atkC1_hidden_power(void)
 
 #else
 __attribute__((naked))
-static void atkC1_hidden_power(void)
+static void atkC1_hiddenpowercalc(void)
 {
     asm(".syntax unified\n\
         	push {r4-r7,lr}\n\
@@ -9888,7 +9432,7 @@ static void atkC1_hidden_power(void)
 	mov r5, r8\n\
 	push {r5-r7}\n\
 	ldr r2, =gBattleMons\n\
-	ldr r0, =gBankAttacker\n\
+	ldr r0, =gBattlerAttacker\n\
 	ldrb r1, [r0]\n\
 	movs r0, 0x58\n\
 	adds r4, r1, 0\n\
@@ -10022,36 +9566,36 @@ _080544F0:\n\
 }
 #endif // NONMATCHING
 
-static void atkC2_selectnexttarget(void)
+static void atkC2_selectfirstvalidtarget(void)
 {
-    for (gBankTarget = 0; gBankTarget < gNoOfAllBanks; gBankTarget++)
+    for (gBattlerTarget = 0; gBattlerTarget < gBattlersCount; gBattlerTarget++)
     {
-        if (gBankTarget == gBankAttacker)
+        if (gBattlerTarget == gBattlerAttacker)
             continue;
-        if (!(gAbsentBankFlags & gBitTable[gBankTarget]))
+        if (!(gAbsentBattlerFlags & gBitTable[gBattlerTarget]))
             break;
     }
     gBattlescriptCurrInstr++;
 }
 
-static void atkC3_setfutureattack(void)
+static void atkC3_trysetfutureattack(void)
 {
-    if (gWishFutureKnock.futureSightCounter[gBankTarget] != 0)
+    if (gWishFutureKnock.futureSightCounter[gBattlerTarget] != 0)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gSideAffecting[GET_BANK_SIDE(gBankTarget)] |= SIDE_STATUS_FUTUREATTACK;
-        gWishFutureKnock.futureSightMove[gBankTarget] = gCurrentMove;
-        gWishFutureKnock.futureSightAttacker[gBankTarget] = gBankAttacker;
-        gWishFutureKnock.futureSightCounter[gBankTarget] = 3;
-        gWishFutureKnock.futureSightDmg[gBankTarget] = CalculateBaseDamage(&gBattleMons[gBankAttacker], &gBattleMons[gBankTarget], gCurrentMove,
-                                                    gSideAffecting[GET_BANK_SIDE(gBankTarget)], 0,
-                                                    0, gBankAttacker, gBankTarget);
+        gSideStatuses[GET_BATTLER_SIDE(gBattlerTarget)] |= SIDE_STATUS_FUTUREATTACK;
+        gWishFutureKnock.futureSightMove[gBattlerTarget] = gCurrentMove;
+        gWishFutureKnock.futureSightAttacker[gBattlerTarget] = gBattlerAttacker;
+        gWishFutureKnock.futureSightCounter[gBattlerTarget] = 3;
+        gWishFutureKnock.futureSightDmg[gBattlerTarget] = CalculateBaseDamage(&gBattleMons[gBattlerAttacker], &gBattleMons[gBattlerTarget], gCurrentMove,
+                                                    gSideStatuses[GET_BATTLER_SIDE(gBattlerTarget)], 0,
+                                                    0, gBattlerAttacker, gBattlerTarget);
 
-        if (gProtectStructs[gBankAttacker].helpingHand)
-            gWishFutureKnock.futureSightDmg[gBankTarget] = gWishFutureKnock.futureSightDmg[gBankTarget] * 15 / 10;
+        if (gProtectStructs[gBattlerAttacker].helpingHand)
+            gWishFutureKnock.futureSightDmg[gBattlerTarget] = gWishFutureKnock.futureSightDmg[gBattlerTarget] * 15 / 10;
 
         if (gCurrentMove == MOVE_DOOM_DESIRE)
             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
@@ -10062,16 +9606,16 @@ static void atkC3_setfutureattack(void)
     }
 }
 
-static void atkC4_beat_up(void)
+static void atkC4_trydobeatup(void)
 {
-    struct Pokemon* party;
+    struct Pokemon *party;
 
-    if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
+    if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
 
-    if (gBattleMons[gBankTarget].hp == 0)
+    if (gBattleMons[gBattlerTarget].hp == 0)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
@@ -10088,16 +9632,16 @@ static void atkC4_beat_up(void)
         }
         if (gBattleCommunication[0] < 6)
         {
-            PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gBankAttacker, gBattleCommunication[0])
+            PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gBattlerAttacker, gBattleCommunication[0])
 
             gBattlescriptCurrInstr += 9;
 
             gBattleMoveDamage = gBaseStats[GetMonData(&party[gBattleCommunication[0]], MON_DATA_SPECIES)].baseAttack;
             gBattleMoveDamage *= gBattleMoves[gCurrentMove].power;
             gBattleMoveDamage *= (GetMonData(&party[gBattleCommunication[0]], MON_DATA_LEVEL) * 2 / 5 + 2);
-            gBattleMoveDamage /= gBaseStats[gBattleMons[gBankTarget].species].baseDefense;
+            gBattleMoveDamage /= gBaseStats[gBattleMons[gBattlerTarget].species].baseDefense;
             gBattleMoveDamage = (gBattleMoveDamage / 50) + 2;
-            if (gProtectStructs[gBankAttacker].helpingHand)
+            if (gProtectStructs[gBattlerAttacker].helpingHand)
                 gBattleMoveDamage = gBattleMoveDamage * 15 / 10;
 
             gBattleCommunication[0]++;
@@ -10115,13 +9659,13 @@ static void atkC5_setsemiinvulnerablebit(void)
     {
     case MOVE_FLY:
     case MOVE_BOUNCE:
-        gStatuses3[gBankAttacker] |= STATUS3_ON_AIR;
+        gStatuses3[gBattlerAttacker] |= STATUS3_ON_AIR;
         break;
     case MOVE_DIG:
-        gStatuses3[gBankAttacker] |= STATUS3_UNDERGROUND;
+        gStatuses3[gBattlerAttacker] |= STATUS3_UNDERGROUND;
         break;
     case MOVE_DIVE:
-        gStatuses3[gBankAttacker] |= STATUS3_UNDERWATER;
+        gStatuses3[gBattlerAttacker] |= STATUS3_UNDERWATER;
         break;
     }
 
@@ -10134,13 +9678,13 @@ static void atkC6_clearsemiinvulnerablebit(void)
     {
     case MOVE_FLY:
     case MOVE_BOUNCE:
-        gStatuses3[gBankAttacker] &= ~STATUS3_ON_AIR;
+        gStatuses3[gBattlerAttacker] &= ~STATUS3_ON_AIR;
         break;
     case MOVE_DIG:
-        gStatuses3[gBankAttacker] &= ~STATUS3_UNDERGROUND;
+        gStatuses3[gBattlerAttacker] &= ~STATUS3_UNDERGROUND;
         break;
     case MOVE_DIVE:
-        gStatuses3[gBankAttacker] &= ~STATUS3_UNDERWATER;
+        gStatuses3[gBattlerAttacker] &= ~STATUS3_UNDERWATER;
         break;
     }
 
@@ -10150,7 +9694,7 @@ static void atkC6_clearsemiinvulnerablebit(void)
 static void atkC7_setminimize(void)
 {
     if (gHitMarker & HITMARKER_OBEYS)
-        gStatuses3[gBankAttacker] |= STATUS3_MINIMIZED;
+        gStatuses3[gBattlerAttacker] |= STATUS3_MINIMIZED;
 
     gBattlescriptCurrInstr++;
 }
@@ -10159,7 +9703,7 @@ static void atkC8_sethail(void)
 {
     if (gBattleWeather & WEATHER_HAIL_ANY)
     {
-        gBattleMoveFlags |= MOVESTATUS_MISSED;
+        gMoveResultFlags |= MOVE_RESULT_MISSED;
         gBattleCommunication[MULTISTRING_CHOOSER] = 2;
     }
     else
@@ -10174,34 +9718,34 @@ static void atkC8_sethail(void)
 
 static void atkC9_jumpifattackandspecialattackcannotfall(void) // memento
 {
-    if (gBattleMons[gBankTarget].statStages[STAT_STAGE_ATK] == 0
-        && gBattleMons[gBankTarget].statStages[STAT_STAGE_SPATK] == 0
+    if (gBattleMons[gBattlerTarget].statStages[STAT_ATK] == 0
+        && gBattleMons[gBattlerTarget].statStages[STAT_SPATK] == 0
         && gBattleCommunication[6] != 1)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gActiveBank = gBankAttacker;
-        gBattleMoveDamage = gBattleMons[gActiveBank].hp;
-        EmitHealthBarUpdate(0, INSTANT_HP_BAR_DROP);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = gBattlerAttacker;
+        gBattleMoveDamage = gBattleMons[gActiveBattler].hp;
+        BtlController_EmitHealthBarUpdate(0, INSTANT_HP_BAR_DROP);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr += 5;
     }
 }
 
 static void atkCA_setforcedtarget(void) // follow me
 {
-    gSideTimers[GetBankSide(gBankAttacker)].followmeTimer = 1;
-    gSideTimers[GetBankSide(gBankAttacker)].followmeTarget = gBankAttacker;
+    gSideTimers[GetBattlerSide(gBattlerAttacker)].followmeTimer = 1;
+    gSideTimers[GetBattlerSide(gBattlerAttacker)].followmeTarget = gBattlerAttacker;
     gBattlescriptCurrInstr++;
 }
 
 static void atkCB_setcharge(void)
 {
-    gStatuses3[gBankAttacker] |= STATUS3_CHARGED_UP;
-    gDisableStructs[gBankAttacker].chargeTimer1 = 2;
-    gDisableStructs[gBankAttacker].chargeTimer2 = 2;
+    gStatuses3[gBattlerAttacker] |= STATUS3_CHARGED_UP;
+    gDisableStructs[gBattlerAttacker].chargeTimer1 = 2;
+    gDisableStructs[gBattlerAttacker].chargeTimer2 = 2;
     gBattlescriptCurrInstr++;
 }
 
@@ -10209,20 +9753,20 @@ static void atkCC_callterrainattack(void) // nature power
 {
     gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
     gCurrentMove = sNaturePowerMoves[gBattleTerrain];
-    gBankTarget = GetMoveTarget(gCurrentMove, 0);
+    gBattlerTarget = GetMoveTarget(gCurrentMove, 0);
     BattleScriptPush(gBattleScriptsForMoveEffects[gBattleMoves[gCurrentMove].effect]);
     gBattlescriptCurrInstr++;
 }
 
 static void atkCD_cureifburnedparalysedorpoisoned(void) // refresh
 {
-    if (gBattleMons[gBankAttacker].status1 & (STATUS_POISON | STATUS_BURN | STATUS_PARALYSIS | STATUS_TOXIC_POISON))
+    if (gBattleMons[gBattlerAttacker].status1 & (STATUS1_POISON | STATUS1_BURN | STATUS1_PARALYSIS | STATUS1_TOXIC_POISON))
     {
-        gBattleMons[gBankAttacker].status1 = 0;
+        gBattleMons[gBattlerAttacker].status1 = 0;
         gBattlescriptCurrInstr += 5;
-        gActiveBank = gBankAttacker;
-        EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBank].status1);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = gBattlerAttacker;
+        BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1);
+        MarkBattlerForControllerExec(gActiveBattler);
     }
     else
     {
@@ -10232,20 +9776,20 @@ static void atkCD_cureifburnedparalysedorpoisoned(void) // refresh
 
 static void atkCE_settorment(void)
 {
-    if (gBattleMons[gBankTarget].status2 & STATUS2_TORMENT)
+    if (gBattleMons[gBattlerTarget].status2 & STATUS2_TORMENT)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gBattleMons[gBankTarget].status2 |= STATUS2_TORMENT;
+        gBattleMons[gBattlerTarget].status2 |= STATUS2_TORMENT;
         gBattlescriptCurrInstr += 5;
     }
 }
 
 static void atkCF_jumpifnodamage(void)
 {
-    if (gProtectStructs[gBankAttacker].physicalDmg || gProtectStructs[gBankAttacker].specialDmg)
+    if (gProtectStructs[gBattlerAttacker].physicalDmg || gProtectStructs[gBattlerAttacker].specialDmg)
         gBattlescriptCurrInstr += 5;
     else
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
@@ -10253,10 +9797,10 @@ static void atkCF_jumpifnodamage(void)
 
 static void atkD0_settaunt(void)
 {
-    if (gDisableStructs[gBankTarget].tauntTimer1 == 0)
+    if (gDisableStructs[gBattlerTarget].tauntTimer1 == 0)
     {
-        gDisableStructs[gBankTarget].tauntTimer1 = 2;
-        gDisableStructs[gBankTarget].tauntTimer2 = 2;
+        gDisableStructs[gBattlerTarget].tauntTimer1 = 2;
+        gDisableStructs[gBattlerTarget].tauntTimer2 = 2;
         gBattlescriptCurrInstr += 5;
     }
     else
@@ -10265,16 +9809,16 @@ static void atkD0_settaunt(void)
     }
 }
 
-static void atkD1_set_helpinghand(void)
+static void atkD1_trysethelpinghand(void)
 {
-    gBankTarget = GetBankByIdentity(GetBankIdentity(gBankAttacker) ^ BIT_MON);
+    gBattlerTarget = GetBattlerAtPosition(GetBattlerPosition(gBattlerAttacker) ^ BIT_FLANK);
 
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE
-        && !(gAbsentBankFlags & gBitTable[gBankTarget])
-        && !gProtectStructs[gBankAttacker].helpingHand
-        && !gProtectStructs[gBankTarget].helpingHand)
+        && !(gAbsentBattlerFlags & gBitTable[gBattlerTarget])
+        && !gProtectStructs[gBattlerAttacker].helpingHand
+        && !gProtectStructs[gBattlerTarget].helpingHand)
     {
-        gProtectStructs[gBankTarget].helpingHand = 1;
+        gProtectStructs[gBattlerTarget].helpingHand = 1;
         gBattlescriptCurrInstr += 5;
     }
     else
@@ -10283,11 +9827,11 @@ static void atkD1_set_helpinghand(void)
     }
 }
 
-static void atkD2_swap_items(void) // trick
+static void atkD2_tryswapitems(void) // trick
 {
     // opponent can't swap items with player in regular battles
     if (gBattleTypeFlags & BATTLE_TYPE_x4000000
-        || (GetBankSide(gBankAttacker) == SIDE_OPPONENT
+        || (GetBattlerSide(gBattlerAttacker) == B_SIDE_OPPONENT
             && !(gBattleTypeFlags & (BATTLE_TYPE_LINK
                                   | BATTLE_TYPE_EREADER_TRAINER
                                   | BATTLE_TYPE_FRONTIER
@@ -10298,8 +9842,8 @@ static void atkD2_swap_items(void) // trick
     }
     else
     {
-        u8 sideAttacker = GetBankSide(gBankAttacker);
-        u8 sideTarget = GetBankSide(gBankTarget);
+        u8 sideAttacker = GetBattlerSide(gBattlerAttacker);
+        u8 sideTarget = GetBattlerSide(gBattlerTarget);
 
         // you can't swap items if they were knocked off in regular battles
         if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK
@@ -10307,53 +9851,53 @@ static void atkD2_swap_items(void) // trick
                              | BATTLE_TYPE_FRONTIER
                              | BATTLE_TYPE_SECRET_BASE
                              | BATTLE_TYPE_x2000000))
-            && (gWishFutureKnock.knockedOffPokes[sideAttacker] & gBitTable[gBattlePartyID[gBankAttacker]]
-                || gWishFutureKnock.knockedOffPokes[sideTarget] & gBitTable[gBattlePartyID[gBankTarget]]))
+            && (gWishFutureKnock.knockedOffPokes[sideAttacker] & gBitTable[gBattlerPartyIndexes[gBattlerAttacker]]
+                || gWishFutureKnock.knockedOffPokes[sideTarget] & gBitTable[gBattlerPartyIndexes[gBattlerTarget]]))
         {
             gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
         }
         // can't swap if two pokemon don't have an item
         // or if either of them is an enigma berry or a mail
-        else if ((gBattleMons[gBankAttacker].item == 0 && gBattleMons[gBankTarget].item == 0)
-                 || gBattleMons[gBankAttacker].item == ITEM_ENIGMA_BERRY
-                 || gBattleMons[gBankTarget].item == ITEM_ENIGMA_BERRY
-                 || IS_ITEM_MAIL(gBattleMons[gBankAttacker].item)
-                 || IS_ITEM_MAIL(gBattleMons[gBankTarget].item))
+        else if ((gBattleMons[gBattlerAttacker].item == 0 && gBattleMons[gBattlerTarget].item == 0)
+                 || gBattleMons[gBattlerAttacker].item == ITEM_ENIGMA_BERRY
+                 || gBattleMons[gBattlerTarget].item == ITEM_ENIGMA_BERRY
+                 || IS_ITEM_MAIL(gBattleMons[gBattlerAttacker].item)
+                 || IS_ITEM_MAIL(gBattleMons[gBattlerTarget].item))
         {
             gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
         }
         // check if ability prevents swapping
-        else if (gBattleMons[gBankTarget].ability == ABILITY_STICKY_HOLD)
+        else if (gBattleMons[gBattlerTarget].ability == ABILITY_STICKY_HOLD)
         {
             gBattlescriptCurrInstr = BattleScript_StickyHoldActivates;
-            gLastUsedAbility = gBattleMons[gBankTarget].ability;
-            RecordAbilityBattle(gBankTarget, gLastUsedAbility);
+            gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
+            RecordAbilityBattle(gBattlerTarget, gLastUsedAbility);
         }
         // took a while, but all checks passed and items can be safely swapped
         else
         {
             u16 oldItemAtk, *newItemAtk;
 
-            newItemAtk = &gBattleStruct->changedItems[gBankAttacker];
-            oldItemAtk = gBattleMons[gBankAttacker].item;
-            *newItemAtk = gBattleMons[gBankTarget].item;
+            newItemAtk = &gBattleStruct->changedItems[gBattlerAttacker];
+            oldItemAtk = gBattleMons[gBattlerAttacker].item;
+            *newItemAtk = gBattleMons[gBattlerTarget].item;
 
-            gBattleMons[gBankAttacker].item = 0;
-            gBattleMons[gBankTarget].item = oldItemAtk;
+            gBattleMons[gBattlerAttacker].item = 0;
+            gBattleMons[gBattlerTarget].item = oldItemAtk;
 
-            gActiveBank = gBankAttacker;
-            EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, newItemAtk);
-            MarkBufferBankForExecution(gBankAttacker);
+            gActiveBattler = gBattlerAttacker;
+            BtlController_EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, newItemAtk);
+            MarkBattlerForControllerExec(gBattlerAttacker);
 
-            gActiveBank = gBankTarget;
-            EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gBankTarget].item);
-            MarkBufferBankForExecution(gBankTarget);
+            gActiveBattler = gBattlerTarget;
+            BtlController_EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gBattlerTarget].item);
+            MarkBattlerForControllerExec(gBattlerTarget);
 
-            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBankTarget]) + 0) = 0;
-            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBankTarget]) + 1) = 0;
+            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBattlerTarget]) + 0) = 0;
+            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBattlerTarget]) + 1) = 0;
 
-            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBankAttacker]) + 0) = 0;
-            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBankAttacker]) + 1) = 0;
+            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBattlerAttacker]) + 0) = 0;
+            *(u8*)((u8*)(&gBattleStruct->choicedMove[gBattlerAttacker]) + 1) = 0;
 
             gBattlescriptCurrInstr += 5;
 
@@ -10370,13 +9914,13 @@ static void atkD2_swap_items(void) // trick
     }
 }
 
-static void atkD3_copy_ability(void) // role play
+static void atkD3_trycopyability(void) // role play
 {
-    if (gBattleMons[gBankTarget].ability != 0
-        && gBattleMons[gBankTarget].ability != ABILITY_WONDER_GUARD)
+    if (gBattleMons[gBattlerTarget].ability != 0
+        && gBattleMons[gBattlerTarget].ability != ABILITY_WONDER_GUARD)
     {
-        gBattleMons[gBankAttacker].ability = gBattleMons[gBankTarget].ability;
-        gLastUsedAbility = gBattleMons[gBankTarget].ability;
+        gBattleMons[gBattlerAttacker].ability = gBattleMons[gBattlerTarget].ability;
+        gLastUsedAbility = gBattleMons[gBattlerTarget].ability;
         gBattlescriptCurrInstr += 5;
     }
     else
@@ -10385,15 +9929,15 @@ static void atkD3_copy_ability(void) // role play
     }
 }
 
-static void atkD4_wish_effect(void)
+static void atkD4_trywish(void)
 {
     switch (gBattlescriptCurrInstr[1])
     {
     case 0: // use wish
-        if (gWishFutureKnock.wishCounter[gBankAttacker] == 0)
+        if (gWishFutureKnock.wishCounter[gBattlerAttacker] == 0)
         {
-            gWishFutureKnock.wishCounter[gBankAttacker] = 2;
-            gWishFutureKnock.wishUserID[gBankAttacker] = gBattlePartyID[gBankAttacker];
+            gWishFutureKnock.wishCounter[gBattlerAttacker] = 2;
+            gWishFutureKnock.wishMonId[gBattlerAttacker] = gBattlerPartyIndexes[gBattlerAttacker];
             gBattlescriptCurrInstr += 6;
         }
         else
@@ -10402,14 +9946,14 @@ static void atkD4_wish_effect(void)
         }
         break;
     case 1: // heal effect
-        PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gBankTarget, gWishFutureKnock.wishUserID[gBankTarget])
+        PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gBattlerTarget, gWishFutureKnock.wishMonId[gBattlerTarget])
 
-        gBattleMoveDamage = gBattleMons[gBankTarget].maxHP / 2;
+        gBattleMoveDamage = gBattleMons[gBattlerTarget].maxHP / 2;
         if (gBattleMoveDamage == 0)
             gBattleMoveDamage = 1;
         gBattleMoveDamage *= -1;
 
-        if (gBattleMons[gBankTarget].hp == gBattleMons[gBankTarget].maxHP)
+        if (gBattleMons[gBattlerTarget].hp == gBattleMons[gBattlerTarget].maxHP)
             gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 2);
         else
             gBattlescriptCurrInstr += 6;
@@ -10418,25 +9962,25 @@ static void atkD4_wish_effect(void)
     }
 }
 
-static void atkD5_setroots(void) // ingrain
+static void atkD5_trysetroots(void) // ingrain
 {
-    if (gStatuses3[gBankAttacker] & STATUS3_ROOTED)
+    if (gStatuses3[gBattlerAttacker] & STATUS3_ROOTED)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gStatuses3[gBankAttacker] |= STATUS3_ROOTED;
+        gStatuses3[gBattlerAttacker] |= STATUS3_ROOTED;
         gBattlescriptCurrInstr += 5;
     }
 }
 
 static void atkD6_doubledamagedealtifdamaged(void)
 {
-    if ((gProtectStructs[gBankAttacker].physicalDmg
-         && gProtectStructs[gBankAttacker].physicalBank == gBankTarget)
-        || (gProtectStructs[gBankAttacker].specialDmg
-            && gProtectStructs[gBankAttacker].specialBank == gBankTarget))
+    if ((gProtectStructs[gBattlerAttacker].physicalDmg
+         && gProtectStructs[gBattlerAttacker].physicalBattlerId == gBattlerTarget)
+        || (gProtectStructs[gBattlerAttacker].specialDmg
+            && gProtectStructs[gBattlerAttacker].specialBattlerId == gBattlerTarget))
     {
         gBattleScripting.dmgMultiplier = 2;
     }
@@ -10446,27 +9990,27 @@ static void atkD6_doubledamagedealtifdamaged(void)
 
 static void atkD7_setyawn(void)
 {
-    if (gStatuses3[gBankTarget] & STATUS3_YAWN
-        || gBattleMons[gBankTarget].status1 & STATUS_ANY)
+    if (gStatuses3[gBattlerTarget] & STATUS3_YAWN
+        || gBattleMons[gBattlerTarget].status1 & STATUS1_ANY)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gStatuses3[gBankTarget] |= 0x1000;
+        gStatuses3[gBattlerTarget] |= 0x1000;
         gBattlescriptCurrInstr += 5;
     }
 }
 
 static void atkD8_setdamagetohealthdifference(void)
 {
-    if (gBattleMons[gBankTarget].hp <= gBattleMons[gBankAttacker].hp)
+    if (gBattleMons[gBattlerTarget].hp <= gBattleMons[gBattlerAttacker].hp)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gBattleMoveDamage = gBattleMons[gBankTarget].hp - gBattleMons[gBankAttacker].hp;
+        gBattleMoveDamage = gBattleMons[gBattlerTarget].hp - gBattleMons[gBattlerAttacker].hp;
         gBattlescriptCurrInstr += 5;
     }
 }
@@ -10476,48 +10020,48 @@ static void atkD9_scaledamagebyhealthratio(void)
     if (gDynamicBasePower == 0)
     {
         u8 power = gBattleMoves[gCurrentMove].power;
-        gDynamicBasePower = gBattleMons[gBankAttacker].hp * power / gBattleMons[gBankAttacker].maxHP;
+        gDynamicBasePower = gBattleMons[gBattlerAttacker].hp * power / gBattleMons[gBattlerAttacker].maxHP;
         if (gDynamicBasePower == 0)
             gDynamicBasePower = 1;
     }
     gBattlescriptCurrInstr++;
 }
 
-static void atkDA_abilityswap(void) // skill swap
+static void atkDA_tryswapabilities(void) // skill swap
 {
-    if ((gBattleMons[gBankAttacker].ability == 0
-         && gBattleMons[gBankTarget].ability == 0)
-     || gBattleMons[gBankAttacker].ability == ABILITY_WONDER_GUARD
-     || gBattleMons[gBankTarget].ability == ABILITY_WONDER_GUARD
-     || gBattleMoveFlags & MOVESTATUS_NOEFFECT)
+    if ((gBattleMons[gBattlerAttacker].ability == 0
+         && gBattleMons[gBattlerTarget].ability == 0)
+     || gBattleMons[gBattlerAttacker].ability == ABILITY_WONDER_GUARD
+     || gBattleMons[gBattlerTarget].ability == ABILITY_WONDER_GUARD
+     || gMoveResultFlags & MOVE_RESULT_NO_EFFECT)
      {
          gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
      }
     else
     {
-        u8 abilityAtk = gBattleMons[gBankAttacker].ability;
-        gBattleMons[gBankAttacker].ability = gBattleMons[gBankTarget].ability;
-        gBattleMons[gBankTarget].ability = abilityAtk;
+        u8 abilityAtk = gBattleMons[gBattlerAttacker].ability;
+        gBattleMons[gBattlerAttacker].ability = gBattleMons[gBattlerTarget].ability;
+        gBattleMons[gBattlerTarget].ability = abilityAtk;
 
             gBattlescriptCurrInstr += 5;
     }
 }
 
-static void atkDB_imprisoneffect(void)
+static void atkDB_tryimprision(void)
 {
-    if ((gStatuses3[gBankAttacker] & STATUS3_IMPRISONED_OTHERS))
+    if ((gStatuses3[gBattlerAttacker] & STATUS3_IMPRISONED_OTHERS))
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        u8 bank, sideAttacker;
+        u8 battlerId, sideAttacker;
 
-        sideAttacker = GetBankSide(gBankAttacker);
-        PressurePPLoseOnUsingImprision(gBankAttacker);
-        for (bank = 0; bank < gNoOfAllBanks; bank++)
+        sideAttacker = GetBattlerSide(gBattlerAttacker);
+        PressurePPLoseOnUsingImprision(gBattlerAttacker);
+        for (battlerId = 0; battlerId < gBattlersCount; battlerId++)
         {
-            if (sideAttacker != GetBankSide(bank))
+            if (sideAttacker != GetBattlerSide(battlerId))
             {
                 s32 attackerMoveId;
                 for (attackerMoveId = 0; attackerMoveId < 4; attackerMoveId++)
@@ -10525,8 +10069,8 @@ static void atkDB_imprisoneffect(void)
                     s32 i;
                     for (i = 0; i < 4; i++)
                     {
-                        if (gBattleMons[gBankAttacker].moves[attackerMoveId] == gBattleMons[bank].moves[i]
-                            && gBattleMons[gBankAttacker].moves[attackerMoveId] != MOVE_NONE)
+                        if (gBattleMons[gBattlerAttacker].moves[attackerMoveId] == gBattleMons[battlerId].moves[i]
+                            && gBattleMons[gBattlerAttacker].moves[attackerMoveId] != MOVE_NONE)
                             break;
                     }
                     if (i != 4)
@@ -10534,26 +10078,26 @@ static void atkDB_imprisoneffect(void)
                 }
                 if (attackerMoveId != 4)
                 {
-                    gStatuses3[gBankAttacker] |= STATUS3_IMPRISONED_OTHERS;
+                    gStatuses3[gBattlerAttacker] |= STATUS3_IMPRISONED_OTHERS;
                     gBattlescriptCurrInstr += 5;
                     break;
                 }
             }
         }
-        if (bank == gNoOfAllBanks) // In Generation 3 games, Imprison fails if the user doesn't share any moves with any of the foes
+        if (battlerId == gBattlersCount) // In Generation 3 games, Imprison fails if the user doesn't share any moves with any of the foes
             gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
 }
 
-static void atkDC_setgrudge(void)
+static void atkDC_trysetgrudge(void)
 {
-    if (gStatuses3[gBankAttacker] & STATUS3_GRUDGE)
+    if (gStatuses3[gBattlerAttacker] & STATUS3_GRUDGE)
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gStatuses3[gBankAttacker] |= STATUS3_GRUDGE;
+        gStatuses3[gBattlerAttacker] |= STATUS3_GRUDGE;
         gBattlescriptCurrInstr += 5;
     }
 }
@@ -10563,7 +10107,7 @@ static void atkDD_weightdamagecalculation(void)
     s32 i;
     for (i = 0; sWeightToDamageTable[i] != 0xFFFF; i += 2)
     {
-        if (sWeightToDamageTable[i] > GetPokedexHeightWeight(SpeciesToNationalPokedexNum(gBattleMons[gBankTarget].species), 1))
+        if (sWeightToDamageTable[i] > GetPokedexHeightWeight(SpeciesToNationalPokedexNum(gBattleMons[gBattlerTarget].species), 1))
             break;
     }
 
@@ -10582,14 +10126,14 @@ static void atkDE_asistattackselect(void)
     s32 monId, moveId;
     u16* movesArray = gBattleStruct->assistPossibleMoves;
 
-    if (GET_BANK_SIDE(gBankAttacker) != SIDE_PLAYER)
+    if (GET_BATTLER_SIDE(gBattlerAttacker) != B_SIDE_PLAYER)
         party = gEnemyParty;
     else
         party = gPlayerParty;
 
     for (monId = 0; monId < 6; monId++)
     {
-        if (monId == gBattlePartyID[gBankAttacker])
+        if (monId == gBattlerPartyIndexes[gBattlerAttacker])
             continue;
         if (GetMonData(&party[monId], MON_DATA_SPECIES2) == SPECIES_NONE)
             continue;
@@ -10619,7 +10163,7 @@ static void atkDE_asistattackselect(void)
     {
         gHitMarker &= ~(HITMARKER_ATTACKSTRING_PRINTED);
         gRandomMove = movesArray[((Random() & 0xFF) * chooseableMovesNo) >> 8];
-        gBankTarget = GetMoveTarget(gRandomMove, 0);
+        gBattlerTarget = GetMoveTarget(gRandomMove, 0);
         gBattlescriptCurrInstr += 5;
     }
     else
@@ -10628,68 +10172,68 @@ static void atkDE_asistattackselect(void)
     }
 }
 
-static void atkDF_setmagiccoat(void)
+static void atkDF_trysetmagiccoat(void)
 {
-    gBankTarget = gBankAttacker;
-    gSpecialStatuses[gBankAttacker].flag20 = 1;
-    if (gCurrentTurnActionNumber == gNoOfAllBanks - 1) // moves last turn
+    gBattlerTarget = gBattlerAttacker;
+    gSpecialStatuses[gBattlerAttacker].flag20 = 1;
+    if (gCurrentTurnActionNumber == gBattlersCount - 1) // moves last turn
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gProtectStructs[gBankAttacker].bounceMove = 1;
+        gProtectStructs[gBattlerAttacker].bounceMove = 1;
         gBattlescriptCurrInstr += 5;
     }
 }
 
-static void atkE0_setstealstatchange(void) // snatch
+static void atkE0_trysetsnatch(void) // snatch
 {
-    gSpecialStatuses[gBankAttacker].flag20 = 1;
-    if (gCurrentTurnActionNumber == gNoOfAllBanks - 1) // moves last turn
+    gSpecialStatuses[gBattlerAttacker].flag20 = 1;
+    if (gCurrentTurnActionNumber == gBattlersCount - 1) // moves last turn
     {
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     }
     else
     {
-        gProtectStructs[gBankAttacker].stealMove = 1;
+        gProtectStructs[gBattlerAttacker].stealMove = 1;
         gBattlescriptCurrInstr += 5;
     }
 }
 
-static void atkE1_intimidate_string_loader(void)
+static void atkE1_trygetintimidatetarget(void)
 {
     u8 side;
 
-    gBattleScripting.bank = gBattleStruct->intimidateBank;
-    side = GetBankSide(gBattleScripting.bank);
+    gBattleScripting.battler = gBattleStruct->intimidateBank;
+    side = GetBattlerSide(gBattleScripting.battler);
 
-    PREPARE_ABILITY_BUFFER(gBattleTextBuff1, gBattleMons[gBattleScripting.bank].ability)
+    PREPARE_ABILITY_BUFFER(gBattleTextBuff1, gBattleMons[gBattleScripting.battler].ability)
 
-    for (;gBankTarget < gNoOfAllBanks; gBankTarget++)
+    for (;gBattlerTarget < gBattlersCount; gBattlerTarget++)
     {
-        if (GetBankSide(gBankTarget) == side)
+        if (GetBattlerSide(gBattlerTarget) == side)
             continue;
-        if (!(gAbsentBankFlags & gBitTable[gBankTarget]))
+        if (!(gAbsentBattlerFlags & gBitTable[gBattlerTarget]))
             break;
     }
 
-    if (gBankTarget >= gNoOfAllBanks)
+    if (gBattlerTarget >= gBattlersCount)
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
     else
         gBattlescriptCurrInstr += 5;
 }
 
-static void atkE2_switchout_abilities(void)
+static void atkE2_switchoutabilities(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    switch (gBattleMons[gActiveBank].ability)
+    switch (gBattleMons[gActiveBattler].ability)
     {
     case ABILITY_NATURAL_CURE:
-        gBattleMons[gActiveBank].status1 = 0;
-        EmitSetMonData(0, REQUEST_STATUS_BATTLE, gBitTable[*(gBattleStruct->field_58 + gActiveBank)], 4, &gBattleMons[gActiveBank].status1);
-        MarkBufferBankForExecution(gActiveBank);
+        gBattleMons[gActiveBattler].status1 = 0;
+        BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, gBitTable[*(gBattleStruct->field_58 + gActiveBattler)], 4, &gBattleMons[gActiveBattler].status1);
+        MarkBattlerForControllerExec(gActiveBattler);
         break;
     }
 
@@ -10698,9 +10242,9 @@ static void atkE2_switchout_abilities(void)
 
 static void atkE3_jumpifhasnohp(void)
 {
-    gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
+    gActiveBattler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
 
-    if (gBattleMons[gActiveBank].hp == 0)
+    if (gBattleMons[gActiveBattler].hp == 0)
         gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 2);
     else
         gBattlescriptCurrInstr += 6;
@@ -10728,7 +10272,7 @@ static void atkE4_getsecretpowereffect(void)
     case BATTLE_TERRAIN_POND:
         gBattleCommunication[MOVE_EFFECT_BYTE] = MOVE_EFFECT_SPD_MINUS_1;
         break;
-    case BATTLE_TERRAIN_ROCK:
+    case BATTLE_TERRAIN_MOUNTAIN:
         gBattleCommunication[MOVE_EFFECT_BYTE] = MOVE_EFFECT_CONFUSION;
         break;
     case BATTLE_TERRAIN_CAVE:
@@ -10817,25 +10361,25 @@ static void atkE5_pickup(void)
     gBattlescriptCurrInstr++;
 }
 
-static void atkE6_castform_change_animation(void)
+static void atkE6_docastformchangeanimation(void)
 {
-    gActiveBank = gBattleScripting.bank;
+    gActiveBattler = gBattleScripting.battler;
 
-    if (gBattleMons[gActiveBank].status2 & STATUS2_SUBSTITUTE)
+    if (gBattleMons[gActiveBattler].status2 & STATUS2_SUBSTITUTE)
         *(&gBattleStruct->formToChangeInto) |= 0x80;
 
-    EmitBattleAnimation(0, B_ANIM_CASTFORM_CHANGE, gBattleStruct->formToChangeInto);
-    MarkBufferBankForExecution(gActiveBank);
+    BtlController_EmitBattleAnimation(0, B_ANIM_CASTFORM_CHANGE, gBattleStruct->formToChangeInto);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr++;
 }
 
-static void atkE7_castform_data_change(void)
+static void atkE7_trycastformdatachange(void)
 {
     u8 form;
 
     gBattlescriptCurrInstr++;
-    form = CastformDataTypeChange(gBattleScripting.bank);
+    form = CastformDataTypeChange(gBattleScripting.battler);
     if (form)
     {
         BattleScriptPushCursorAndCallback(BattleScript_CastformChange);
@@ -10849,18 +10393,18 @@ static void atkE8_settypebasedhalvers(void) // water and mud sport
 
     if (gBattleMoves[gCurrentMove].effect == EFFECT_MUD_SPORT)
     {
-        if (!(gStatuses3[gBankAttacker] & STATUS3_MUDSPORT))
+        if (!(gStatuses3[gBattlerAttacker] & STATUS3_MUDSPORT))
         {
-            gStatuses3[gBankAttacker] |= STATUS3_MUDSPORT;
+            gStatuses3[gBattlerAttacker] |= STATUS3_MUDSPORT;
             gBattleCommunication[MULTISTRING_CHOOSER] = 0;
             worked = TRUE;
         }
     }
     else // water sport
     {
-        if (!(gStatuses3[gBankAttacker] & STATUS3_WATERSPORT))
+        if (!(gStatuses3[gBattlerAttacker] & STATUS3_WATERSPORT))
         {
-            gStatuses3[gBankAttacker] |= STATUS3_WATERSPORT;
+            gStatuses3[gBattlerAttacker] |= STATUS3_WATERSPORT;
             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
             worked = TRUE;
         }
@@ -10893,20 +10437,20 @@ static void atkE9_setweatherballtype(void)
     gBattlescriptCurrInstr++;
 }
 
-static void atkEA_recycleitem(void)
+static void atkEA_tryrecycleitem(void)
 {
     u16 *usedHeldItem;
 
-    gActiveBank = gBankAttacker;
-    usedHeldItem = &gBattleStruct->usedHeldItems[gActiveBank];
-    if (*usedHeldItem != 0 && gBattleMons[gActiveBank].item == 0)
+    gActiveBattler = gBattlerAttacker;
+    usedHeldItem = &gBattleStruct->usedHeldItems[gActiveBattler];
+    if (*usedHeldItem != 0 && gBattleMons[gActiveBattler].item == 0)
     {
         gLastUsedItem = *usedHeldItem;
         *usedHeldItem = 0;
-        gBattleMons[gActiveBank].item = gLastUsedItem;
+        gBattleMons[gActiveBattler].item = gLastUsedItem;
 
-        EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gActiveBank].item);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitSetMonData(0, REQUEST_HELDITEM_BATTLE, 0, 2, &gBattleMons[gActiveBattler].item);
+        MarkBattlerForControllerExec(gActiveBattler);
 
         gBattlescriptCurrInstr += 5;
     }
@@ -10918,11 +10462,11 @@ static void atkEA_recycleitem(void)
 
 static void atkEB_settypetoterrain(void)
 {
-    if (gBattleMons[gBankAttacker].type1 != sTerrainToType[gBattleTerrain]
-        && gBattleMons[gBankAttacker].type2 != sTerrainToType[gBattleTerrain])
+    if (gBattleMons[gBattlerAttacker].type1 != sTerrainToType[gBattleTerrain]
+        && gBattleMons[gBattlerAttacker].type2 != sTerrainToType[gBattleTerrain])
     {
-        gBattleMons[gBankAttacker].type1 = sTerrainToType[gBattleTerrain];
-        gBattleMons[gBankAttacker].type2 = sTerrainToType[gBattleTerrain];
+        gBattleMons[gBattlerAttacker].type1 = sTerrainToType[gBattleTerrain];
+        gBattleMons[gBattlerAttacker].type2 = sTerrainToType[gBattleTerrain];
 
         PREPARE_TYPE_BUFFER(gBattleTextBuff1, sTerrainToType[gBattleTerrain])
 
@@ -10934,21 +10478,21 @@ static void atkEB_settypetoterrain(void)
     }
 }
 
-static void atkEC_pursuit_sth(void)
+static void atkEC_pursuitrelated(void)
 {
-    gActiveBank = GetBankByIdentity(GetBankIdentity(gBankAttacker) ^ BIT_MON);
+    gActiveBattler = GetBattlerAtPosition(GetBattlerPosition(gBattlerAttacker) ^ BIT_FLANK);
 
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE
-        && !(gAbsentBankFlags & gBitTable[gActiveBank])
-        && gActionForBanks[gActiveBank] == 0
-        && gChosenMovesByBanks[gActiveBank] == MOVE_PURSUIT)
+        && !(gAbsentBattlerFlags & gBitTable[gActiveBattler])
+        && gChosenActionByBattler[gActiveBattler] == 0
+        && gChosenMoveByBattler[gActiveBattler] == MOVE_PURSUIT)
     {
-        gActionsByTurnOrder[gActiveBank] = 11;
+        gActionsByTurnOrder[gActiveBattler] = 11;
         gCurrentMove = MOVE_PURSUIT;
         gBattlescriptCurrInstr += 5;
         gBattleScripting.animTurn = 1;
-        gBattleScripting.field_20 = gBankAttacker;
-        gBankAttacker = gActiveBank;
+        gBattleScripting.field_20 = gBattlerAttacker;
+        gBattlerAttacker = gActiveBattler;
     }
     else
     {
@@ -10956,27 +10500,27 @@ static void atkEC_pursuit_sth(void)
     }
 }
 
-static void atkED_802B4B4(void)
+static void atkEF_snatchsetbanks(void)
 {
-    gEffectBank = gBankAttacker;
+    gEffectBattler = gBattlerAttacker;
 
-    if (gBankAttacker == gBankTarget)
-        gBankAttacker = gBankTarget = gBattleScripting.bank;
+    if (gBattlerAttacker == gBattlerTarget)
+        gBattlerAttacker = gBattlerTarget = gBattleScripting.battler;
     else
-        gBankTarget = gBattleScripting.bank;
+        gBattlerTarget = gBattleScripting.battler;
 
-    gBattleScripting.bank = gEffectBank;
+    gBattleScripting.battler = gEffectBattler;
     gBattlescriptCurrInstr++;
 }
 
 static void atkEE_removelightscreenreflect(void) // brick break
 {
-    u8 opposingSide = GetBankSide(gBankAttacker) ^ BIT_SIDE;
+    u8 opposingSide = GetBattlerSide(gBattlerAttacker) ^ BIT_SIDE;
 
     if (gSideTimers[opposingSide].reflectTimer || gSideTimers[opposingSide].lightscreenTimer)
     {
-        gSideAffecting[opposingSide] &= ~(SIDE_STATUS_REFLECT);
-        gSideAffecting[opposingSide] &= ~(SIDE_STATUS_LIGHTSCREEN);
+        gSideStatuses[opposingSide] &= ~(SIDE_STATUS_REFLECT);
+        gSideStatuses[opposingSide] &= ~(SIDE_STATUS_LIGHTSCREEN);
         gSideTimers[opposingSide].reflectTimer = 0;
         gSideTimers[opposingSide].lightscreenTimer = 0;
         gBattleScripting.animTurn = 1;
@@ -10991,26 +10535,26 @@ static void atkEE_removelightscreenreflect(void) // brick break
     gBattlescriptCurrInstr++;
 }
 
-static void atkEF_pokeball_catch_calculation(void)
+static void atkEF_handleballthrow(void)
 {
     u8 ballMultiplier = 0;
 
-    if (gBattleExecBuffer)
+    if (gBattleControllerExecFlags)
         return;
 
-    gActiveBank = gBankAttacker;
-    gBankTarget = gBankAttacker ^ BIT_SIDE;
+    gActiveBattler = gBattlerAttacker;
+    gBattlerTarget = gBattlerAttacker ^ BIT_SIDE;
 
     if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
     {
-        EmitBallThrowAnim(0, BALL_TRAINER_BLOCK);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBallThrowAnim(0, BALL_TRAINER_BLOCK);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr = BattleScript_TrainerBallBlock;
     }
     else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL)
     {
-        EmitBallThrowAnim(0, BALL_3_SHAKES_SUCCESS);
-        MarkBufferBankForExecution(gActiveBank);
+        BtlController_EmitBallThrowAnim(0, BALL_3_SHAKES_SUCCESS);
+        MarkBattlerForControllerExec(gActiveBattler);
         gBattlescriptCurrInstr = BattleScript_WallyBallThrow;
     }
     else
@@ -11021,17 +10565,17 @@ static void atkEF_pokeball_catch_calculation(void)
         if (gLastUsedItem == ITEM_SAFARI_BALL)
             catchRate = gBattleStruct->field_7C * 1275 / 100;
         else
-            catchRate = gBaseStats[gBattleMons[gBankTarget].species].catchRate;
+            catchRate = gBaseStats[gBattleMons[gBattlerTarget].species].catchRate;
 
         if (gLastUsedItem > ITEM_SAFARI_BALL)
         {
             switch (gLastUsedItem)
             {
             case ITEM_NET_BALL:
-                if (gBattleMons[gBankTarget].type1 == TYPE_WATER
-                    || gBattleMons[gBankTarget].type2 == TYPE_WATER
-                    || gBattleMons[gBankTarget].type1 == TYPE_BUG
-                    || gBattleMons[gBankTarget].type2 == TYPE_BUG)
+                if (gBattleMons[gBattlerTarget].type1 == TYPE_WATER
+                    || gBattleMons[gBattlerTarget].type2 == TYPE_WATER
+                    || gBattleMons[gBattlerTarget].type1 == TYPE_BUG
+                    || gBattleMons[gBattlerTarget].type2 == TYPE_BUG)
                     ballMultiplier = 30;
                 else
                     ballMultiplier = 10;
@@ -11043,9 +10587,9 @@ static void atkEF_pokeball_catch_calculation(void)
                     ballMultiplier = 10;
                 break;
             case ITEM_NEST_BALL:
-                if (gBattleMons[gBankTarget].level < 40)
+                if (gBattleMons[gBattlerTarget].level < 40)
                 {
-                    ballMultiplier = 40 - gBattleMons[gBankTarget].level;
+                    ballMultiplier = 40 - gBattleMons[gBattlerTarget].level;
                     if (ballMultiplier <= 9)
                         ballMultiplier = 10;
                 }
@@ -11055,7 +10599,7 @@ static void atkEF_pokeball_catch_calculation(void)
                 }
                 break;
             case ITEM_REPEAT_BALL:
-                if (GetSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gBankTarget].species), FLAG_GET_CAUGHT))
+                if (GetSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gBattlerTarget].species), FLAG_GET_CAUGHT))
                     ballMultiplier = 30;
                 else
                     ballMultiplier = 10;
@@ -11075,12 +10619,12 @@ static void atkEF_pokeball_catch_calculation(void)
             ballMultiplier = sBallCatchBonuses[gLastUsedItem - 2];
 
         odds = (catchRate * ballMultiplier / 10)
-            * (gBattleMons[gBankTarget].maxHP * 3 - gBattleMons[gBankTarget].hp * 2)
-            / (3 * gBattleMons[gBankTarget].maxHP);
+            * (gBattleMons[gBattlerTarget].maxHP * 3 - gBattleMons[gBattlerTarget].hp * 2)
+            / (3 * gBattleMons[gBattlerTarget].maxHP);
 
-        if (gBattleMons[gBankTarget].status1 & (STATUS_SLEEP | STATUS_FREEZE))
+        if (gBattleMons[gBattlerTarget].status1 & (STATUS1_SLEEP | STATUS1_FREEZE))
             odds *= 2;
-        if (gBattleMons[gBankTarget].status1 & (STATUS_POISON | STATUS_BURN | STATUS_PARALYSIS | STATUS_TOXIC_POISON))
+        if (gBattleMons[gBattlerTarget].status1 & (STATUS1_POISON | STATUS1_BURN | STATUS1_PARALYSIS | STATUS1_TOXIC_POISON))
             odds = (odds * 15) / 10;
 
         if (gLastUsedItem != ITEM_SAFARI_BALL)
@@ -11098,10 +10642,10 @@ static void atkEF_pokeball_catch_calculation(void)
 
         if (odds > 254) // mon caught
         {
-            EmitBallThrowAnim(0, BALL_3_SHAKES_SUCCESS);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitBallThrowAnim(0, BALL_3_SHAKES_SUCCESS);
+            MarkBattlerForControllerExec(gActiveBattler);
             gBattlescriptCurrInstr = BattleScript_SuccessBallThrow;
-            SetMonData(&gEnemyParty[gBattlePartyID[gBankTarget]], MON_DATA_POKEBALL, &gLastUsedItem);
+            SetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerTarget]], MON_DATA_POKEBALL, &gLastUsedItem);
 
             if (CalculatePlayerPartyCount() == 6)
                 gBattleCommunication[MULTISTRING_CHOOSER] = 0;
@@ -11120,13 +10664,13 @@ static void atkEF_pokeball_catch_calculation(void)
             if (gLastUsedItem == ITEM_MASTER_BALL)
                 shakes = BALL_3_SHAKES_SUCCESS; // why calculate the shakes before that check?
 
-            EmitBallThrowAnim(0, shakes);
-            MarkBufferBankForExecution(gActiveBank);
+            BtlController_EmitBallThrowAnim(0, shakes);
+            MarkBattlerForControllerExec(gActiveBattler);
 
             if (shakes == BALL_3_SHAKES_SUCCESS) // mon caught, copy of the code above
             {
                 gBattlescriptCurrInstr = BattleScript_SuccessBallThrow;
-                SetMonData(&gEnemyParty[gBattlePartyID[gBankTarget]], MON_DATA_POKEBALL, &gLastUsedItem);
+                SetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerTarget]], MON_DATA_POKEBALL, &gLastUsedItem);
 
                 if (CalculatePlayerPartyCount() == 6)
                     gBattleCommunication[MULTISTRING_CHOOSER] = 0;
@@ -11142,36 +10686,36 @@ static void atkEF_pokeball_catch_calculation(void)
     }
 }
 
-static void atkF0_give_caught_mon(void)
+static void atkF0_givecaughtmon(void)
 {
-    if (GiveMonToPlayer(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]]) != MON_GIVEN_TO_PARTY)
+    if (GiveMonToPlayer(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]]) != MON_GIVEN_TO_PARTY)
     {
         if (!sub_813B21C())
         {
             gBattleCommunication[MULTISTRING_CHOOSER] = 0;
             StringCopy(gStringVar1, GetBoxNamePtr(VarGet(VAR_STORAGE_UNKNOWN)));
-            GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gStringVar2);
+            GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gStringVar2);
         }
         else
         {
             StringCopy(gStringVar1, GetBoxNamePtr(VarGet(VAR_STORAGE_UNKNOWN)));
-            GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gStringVar2);
+            GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gStringVar2);
             StringCopy(gStringVar3, GetBoxNamePtr(get_unknown_box_id()));
             gBattleCommunication[MULTISTRING_CHOOSER] = 2;
         }
 
-        if (FlagGet(SYS_PC_LANETTE))
+        if (FlagGet(FLAG_SYS_PC_LANETTE))
             gBattleCommunication[MULTISTRING_CHOOSER]++;
     }
 
-    gBattleResults.caughtMonSpecies = GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_SPECIES, NULL);
-    GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gBattleResults.caughtMonNick);
-    gBattleResults.caughtMonBall = GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_POKEBALL, NULL);
+    gBattleResults.caughtMonSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_SPECIES, NULL);
+    GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gBattleResults.caughtMonNick);
+    gBattleResults.caughtMonBall = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_POKEBALL, NULL);
 
     gBattlescriptCurrInstr++;
 }
 
-static void atkF1_set_caught_mon_dex_flags(void)
+static void atkF1_trysetcaughtmondexflags(void)
 {
     u16 species = GetMonData(&gEnemyParty[0], MON_DATA_SPECIES, NULL);
     u32 personality = GetMonData(&gEnemyParty[0], MON_DATA_PERSONALITY, NULL);
@@ -11187,7 +10731,7 @@ static void atkF1_set_caught_mon_dex_flags(void)
     }
 }
 
-static void atkF2_display_dex_info(void)
+static void atkF2_displaydexinfo(void)
 {
     u16 species = GetMonData(&gEnemyParty[0], MON_DATA_SPECIES, NULL);
 
@@ -11202,8 +10746,8 @@ static void atkF2_display_dex_info(void)
         {
             FreeAllWindowBuffers();
             gBattleCommunication[TASK_ID] = CreateDexDisplayMonDataTask(SpeciesToNationalPokedexNum(species),
-                                                                        gBattleMons[gBankTarget].otId,
-                                                                        gBattleMons[gBankTarget].personality);
+                                                                        gBattleMons[gBattlerTarget].otId,
+                                                                        gBattleMons[gBattlerTarget].personality);
             gBattleCommunication[0]++;
         }
         break;
@@ -11306,7 +10850,7 @@ void BattleDestroyYesNoCursorAt(u8 cursorPosition)
     CopyBgTilemapBufferToVram(0);
 }
 
-static void atkF3_nickname_caught_poke(void)
+static void atkF3_trygivecaughtmonnick(void)
 {
     switch (gBattleCommunication[MULTIUSE_STATE])
     {
@@ -11354,13 +10898,13 @@ static void atkF3_nickname_caught_poke(void)
     case 2:
         if (!gPaletteFade.active)
         {
-            GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gBattleStruct->caughtMonNick);
+            GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gBattleStruct->caughtMonNick);
             FreeAllWindowBuffers();
 
             DoNamingScreen(NAMING_SCREEN_CAUGHT_MON, gBattleStruct->caughtMonNick,
-                           GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_SPECIES),
-                           GetMonGender(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]]),
-                           GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_PERSONALITY, NULL),
+                           GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_SPECIES),
+                           GetMonGender(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]]),
+                           GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_PERSONALITY, NULL),
                            BattleMainCB2);
 
             gBattleCommunication[MULTIUSE_STATE]++;
@@ -11369,7 +10913,7 @@ static void atkF3_nickname_caught_poke(void)
     case 3:
         if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active )
         {
-            SetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gBattleStruct->caughtMonNick);
+            SetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker ^ BIT_SIDE]], MON_DATA_NICKNAME, gBattleStruct->caughtMonNick);
             gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1);
         }
         break;
@@ -11384,32 +10928,32 @@ static void atkF3_nickname_caught_poke(void)
 
 static void atkF4_subattackerhpbydmg(void)
 {
-    gBattleMons[gBankAttacker].hp -= gBattleMoveDamage;
+    gBattleMons[gBattlerAttacker].hp -= gBattleMoveDamage;
     gBattlescriptCurrInstr++;
 }
 
 static void atkF5_removeattackerstatus1(void)
 {
-    gBattleMons[gBankAttacker].status1 = 0;
+    gBattleMons[gBattlerAttacker].status1 = 0;
     gBattlescriptCurrInstr++;
 }
 
-static void atkF6_action_finished(void)
+static void atkF6_finishaction(void)
 {
-    gCurrentActionFuncId = ACTION_FINISHED;
+    gCurrentActionFuncId = B_ACTION_FINISHED;
 }
 
-static void atkF7_turn_finished(void)
+static void atkF7_finishturn(void)
 {
-    gCurrentActionFuncId = ACTION_FINISHED;
-    gCurrentTurnActionNumber = gNoOfAllBanks;
+    gCurrentActionFuncId = B_ACTION_FINISHED;
+    gCurrentTurnActionNumber = gBattlersCount;
 }
 
-static void atkF8_trainer_slide_back(void)
+static void atkF8_trainerslideout(void)
 {
-    gActiveBank = GetBankByIdentity(gBattlescriptCurrInstr[1]);
-    EmitTrainerSlideBack(0);
-    MarkBufferBankForExecution(gActiveBank);
+    gActiveBattler = GetBattlerAtPosition(gBattlescriptCurrInstr[1]);
+    BtlController_EmitTrainerSlideBack(0);
+    MarkBattlerForControllerExec(gActiveBattler);
 
     gBattlescriptCurrInstr += 2;
 }