battle 2 is done

3 files changed, 502 insertions, 35 deletions

diff --git a/src/battle_2.c b/src/battle_2.c
index ab1aae747..37ab7ab1f 100644
--- a/src/battle_2.c
+++ b/src/battle_2.c
@@ -40,6 +40,7 @@
 #include "trainer_classes.h"
 #include "evolution_scene.h"
 #include "roamer.h"
+#include "safari_zone.h"
 
 struct UnknownStruct6
 {
@@ -157,6 +158,10 @@ extern const struct BgTemplate gUnknown_0831AA08[];
 extern const struct WindowTemplate * const gUnknown_0831ABA0[];
 extern const u8 gUnknown_0831ACE0[];
 extern const u8 gStatStageRatios[][2];
+extern const u8 gUnknown_0831BCE0[];
+extern const u8 gUnknown_0831BCEF[];
+extern const u8 gUnknown_0831BCF3[];
+extern const u8 * const gBattleScriptsForMoveEffects[];
 
 // strings
 extern const u8 gText_LinkStandby3[];
@@ -190,6 +195,7 @@ extern const u8 BattleScript_GotAwaySafely[];
 extern const u8 BattleScript_WildMonFled[];
 extern const u8 BattleScript_MoveUsedLoafingAround[];
 extern const u8 BattleScript_ActionSwitch[];
+extern const u8 BattleScript_PrintFailedToRunString[];
 
 // functions
 extern void HandleLinkBattleSetup(void); // rom_3
@@ -2942,7 +2948,7 @@ void FaintClearSetData(void)
     gProtectStructs[gActiveBank].flag0Unknown = 0;
     gProtectStructs[gActiveBank].prlzImmobility = 0;
     gProtectStructs[gActiveBank].confusionSelfDmg = 0;
-    gProtectStructs[gActiveBank].notEffective = 0;
+    gProtectStructs[gActiveBank].targetNotAffected = 0;
     gProtectStructs[gActiveBank].chargingTurn = 0;
     gProtectStructs[gActiveBank].fleeFlag = 0;
     gProtectStructs[gActiveBank].usedImprisionedMove = 0;
@@ -3824,15 +3830,18 @@ void sub_803BDA0(u8 bank)
     }
 }
 
-#define STATE_TURN_START_RECORD                     0
-#define STATE_BEFORE_ACTION_CHOSEN                  1
-#define STATE_WAIT_ACTION_CHOSEN                    2
-#define STATE_WAIT_ACTION_CASE_CHOSEN               3
-#define STATE_WAIT_ACTION_CONFIRMED_STANDBY         4
-#define STATE_WAIT_ACTION_CONFIRMED                 5
-#define STATE_SELECTION_SCRIPT                      6
-#define STATE_WAIT_SET_BEFORE_ACTION                7
-#define STATE_SELECTION_SCRIPT_MAY_RUN              8
+enum
+{
+    STATE_TURN_START_RECORD,
+    STATE_BEFORE_ACTION_CHOSEN,
+    STATE_WAIT_ACTION_CHOSEN,
+    STATE_WAIT_ACTION_CASE_CHOSEN,
+    STATE_WAIT_ACTION_CONFIRMED_STANDBY,
+    STATE_WAIT_ACTION_CONFIRMED,
+    STATE_SELECTION_SCRIPT,
+    STATE_WAIT_SET_BEFORE_ACTION,
+    STATE_SELECTION_SCRIPT_MAY_RUN
+};
 
 void HandleTurnActionSelectionState(void)
 {
@@ -4137,7 +4146,7 @@ void HandleTurnActionSelectionState(void)
                     }
                     break;
                 case ACTION_RUN:
-                    gHitMarker |= HITMARKER_x8000;
+                    gHitMarker |= HITMARKER_RUN;
                     gBattleCommunication[gActiveBank]++;
                     break;
                 case ACTION_WATCHES_CAREFULLY:
@@ -4160,7 +4169,7 @@ void HandleTurnActionSelectionState(void)
                     gBattleCommunication[gActiveBank]++;
                     break;
                 case ACTION_SAFARI_ZONE_RUN:
-                    gHitMarker |= HITMARKER_x8000;
+                    gHitMarker |= HITMARKER_RUN;
                     gBattleCommunication[gActiveBank]++;
                     break;
                 case ACTION_9:
@@ -4221,7 +4230,7 @@ void HandleTurnActionSelectionState(void)
             {
                 if (gBattleBufferB[gActiveBank][1] == 13)
                 {
-                    gHitMarker |= HITMARKER_x8000;
+                    gHitMarker |= HITMARKER_RUN;
                     gActionForBanks[gActiveBank] = ACTION_RUN;
                     gBattleCommunication[gActiveBank] = STATE_WAIT_ACTION_CONFIRMED_STANDBY;
                 }
@@ -4613,7 +4622,7 @@ void SpecialStatusesClear(void)
 
 static void CheckFocusPunch_ClearVarsBeforeTurnStarts(void)
 {
-    if (!(gHitMarker & HITMARKER_x8000))
+    if (!(gHitMarker & HITMARKER_RUN))
     {
         while (gBattleStruct->focusPunchBank < gNoOfAllBanks)
         {
@@ -4976,8 +4985,6 @@ void RunBattleScriptCommands(void)
         gBattleScriptingCommandsTable[gBattlescriptCurrInstr[0]]();
 }
 
-extern const u8 * const gBattleScriptsForMoveEffects[];
-
 void HandleAction_UseMove(void)
 {
     u8 side;
@@ -5216,6 +5223,7 @@ void HandleAction_Switch(void)
 extern const u8 * const gBattlescriptsForBallThrow[];
 extern const u8 * const gBattlescriptsForRunningByItem[];
 extern const u8 * const gUnknown_082DBD3C[];
+extern const u8 * const gBattlescriptsForSafariActions[];
 
 void HandleAction_UseItem(void)
 {
@@ -5375,3 +5383,198 @@ bool8 TryRunFromBattle(u8 bank)
 
     return effect;
 }
+
+void HandleAction_Run(void)
+{
+    gBankAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+
+    if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_x2000000))
+    {
+        gCurrentTurnActionNumber = gNoOfAllBanks;
+
+        for (gActiveBank = 0; gActiveBank < gNoOfAllBanks; gActiveBank++)
+        {
+            if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+            {
+                if (gActionForBanks[gActiveBank] == ACTION_RUN)
+                    gBattleOutcome |= BATTLE_LOST;
+            }
+            else
+            {
+                if (gActionForBanks[gActiveBank] == ACTION_RUN)
+                    gBattleOutcome |= BATTLE_WON;
+            }
+        }
+
+        gBattleOutcome |= BATTLE_OUTCOME_BIT_x80;
+        gSaveBlock2Ptr->field_CA9_b = 1;
+    }
+    else
+    {
+        if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
+        {
+            if (!TryRunFromBattle(gBankAttacker)) // failed to run away
+            {
+                ClearFuryCutterDestinyBondGrudge(gBankAttacker);
+                gBattleCommunication[MULTISTRING_CHOOSER] = 3;
+                gBattlescriptCurrInstr = BattleScript_PrintFailedToRunString;
+                gCurrentActionFuncId = ACTION_RUN_BATTLESCRIPT;
+            }
+        }
+        else
+        {
+            if (gBattleMons[gBankAttacker].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION))
+            {
+                gBattleCommunication[MULTISTRING_CHOOSER] = 4;
+                gBattlescriptCurrInstr = BattleScript_PrintFailedToRunString;
+                gCurrentActionFuncId = ACTION_RUN_BATTLESCRIPT;
+            }
+            else
+            {
+                gCurrentTurnActionNumber = gNoOfAllBanks;
+                gBattleOutcome = BATTLE_POKE_FLED;
+            }
+        }
+    }
+}
+
+void HandleAction_WatchesCarefully(void)
+{
+    gBankAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+    gBattlescriptCurrInstr = gBattlescriptsForSafariActions[0];
+    gCurrentActionFuncId = ACTION_RUN_BATTLESCRIPT;
+}
+
+void HandleAction_SafariZoneBallThrow(void)
+{
+    gBankAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+    gNumSafariBalls--;
+    gLastUsedItem = ITEM_SAFARI_BALL;
+    gBattlescriptCurrInstr = gBattlescriptsForBallThrow[ITEM_SAFARI_BALL];
+    gCurrentActionFuncId = ACTION_RUN_BATTLESCRIPT;
+}
+
+void HandleAction_ThrowPokeblock(void)
+{
+    gBankAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+    gBattleCommunication[MULTISTRING_CHOOSER] = gBattleBufferB[gBankAttacker][1] - 1;
+    gLastUsedItem = gBattleBufferB[gBankAttacker][2];
+
+    if (gBattleResults.field_1F < 0xFF)
+        gBattleResults.field_1F++;
+    if (gBattleStruct->field_7A < 3)
+        gBattleStruct->field_7A++;
+    if (gBattleStruct->field_7B > 1)
+    {
+        if (gBattleStruct->field_7B < gUnknown_0831BCE0[3 * gBattleStruct->field_7A + gBattleCommunication[MULTISTRING_CHOOSER]])
+            gBattleStruct->field_7B = 1;
+        else
+            gBattleStruct->field_7B -= gUnknown_0831BCE0[3 * gBattleStruct->field_7A + gBattleCommunication[MULTISTRING_CHOOSER]];
+    }
+
+    gBattlescriptCurrInstr = gBattlescriptsForSafariActions[2];
+    gCurrentActionFuncId = ACTION_RUN_BATTLESCRIPT;
+}
+
+void HandleAction_GoNear(void)
+{
+    gBankAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+
+    gBattleStruct->field_7C += gUnknown_0831BCEF[gBattleStruct->field_79];
+    if (gBattleStruct->field_7C > 20)
+        gBattleStruct->field_7C = 20;
+
+    gBattleStruct->field_7B +=gUnknown_0831BCF3[gBattleStruct->field_79];
+    if (gBattleStruct->field_7B > 20)
+        gBattleStruct->field_7B = 20;
+
+    if (gBattleStruct->field_79 < 3)
+    {
+        gBattleStruct->field_79++;
+        gBattleCommunication[MULTISTRING_CHOOSER] = 0;
+    }
+    else
+    {
+        gBattleCommunication[MULTISTRING_CHOOSER] = 1;
+    }
+    gBattlescriptCurrInstr = gBattlescriptsForSafariActions[1];
+    gCurrentActionFuncId = ACTION_RUN_BATTLESCRIPT;
+}
+
+void HandleAction_SafriZoneRun(void)
+{
+    gBankAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    PlaySE(SE_NIGERU);
+    gCurrentTurnActionNumber = gNoOfAllBanks;
+    gBattleOutcome = BATTLE_RAN;
+}
+
+void HandleAction_Action9(void)
+{
+    gBankAttacker = gBanksByTurnOrder[gCurrentTurnActionNumber];
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+
+    PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, gBankAttacker, gBattlePartyID[gBankAttacker])
+
+    gBattlescriptCurrInstr = gBattlescriptsForSafariActions[3];
+    gCurrentActionFuncId = ACTION_RUN_BATTLESCRIPT;
+    gActionsByTurnOrder[1] = ACTION_FINISHED;
+}
+
+void HandleAction_Action11(void)
+{
+    if (!sub_8041728())
+    {
+        gBattleStruct->field_4D = 0;
+        gCurrentActionFuncId = ACTION_FINISHED;
+    }
+}
+
+void HandleAction_NothingIsFainted(void)
+{
+    gCurrentTurnActionNumber++;
+    gCurrentActionFuncId = gActionsByTurnOrder[gCurrentTurnActionNumber];
+    gHitMarker &= ~(HITMARKER_DESTINYBOND | HITMARKER_IGNORE_SUBSTITUTE | HITMARKER_ATTACKSTRING_PRINTED
+                    | HITMARKER_NO_PPDEDUCT | HITMARKER_IGNORE_SAFEGUARD | HITMARKER_IGNORE_ON_AIR
+                    | HITMARKER_IGNORE_UNDERGROUND | HITMARKER_IGNORE_UNDERWATER | HITMARKER_x100000
+                    | HITMARKER_OBEYS | HITMARKER_x10 | HITMARKER_SYNCHRONISE_EFFECT
+                    | HITMARKER_x8000000 | HITMARKER_x4000000);
+}
+
+void HandleAction_ActionFinished(void)
+{
+    *(gBattleStruct->field_5C + gBanksByTurnOrder[gCurrentTurnActionNumber]) = 6;
+    gCurrentTurnActionNumber++;
+    gCurrentActionFuncId = gActionsByTurnOrder[gCurrentTurnActionNumber];
+    SpecialStatusesClear();
+    gHitMarker &= ~(HITMARKER_DESTINYBOND | HITMARKER_IGNORE_SUBSTITUTE | HITMARKER_ATTACKSTRING_PRINTED
+                    | HITMARKER_NO_PPDEDUCT | HITMARKER_IGNORE_SAFEGUARD | HITMARKER_IGNORE_ON_AIR
+                    | HITMARKER_IGNORE_UNDERGROUND | HITMARKER_IGNORE_UNDERWATER | HITMARKER_x100000
+                    | HITMARKER_OBEYS | HITMARKER_x10 | HITMARKER_SYNCHRONISE_EFFECT
+                    | HITMARKER_x8000000 | HITMARKER_x4000000);
+
+    gCurrentMove = 0;
+    gBattleMoveDamage = 0;
+    gBattleMoveFlags = 0;
+    gBattleScripting.animTurn = 0;
+    gBattleScripting.animTargetsHit = 0;
+    gUnknown_02024250[gBankAttacker] = 0;
+    gUnknown_02024258[gBankAttacker] = 0;
+    gBattleStruct->dynamicMoveType = 0;
+    gDynamicBasePower = 0;
+    gBattleScripting.atk49_state = 0;
+    gBattleCommunication[3] = 0;
+    gBattleCommunication[4] = 0;
+    gBattleScripting.field_16 = 0;
+    gBattleResources->battleScriptsStack->size = 0;
+}
+
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index e68137c47..e53292442 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -1600,7 +1600,7 @@ static void atk06_typecalc(void)
         RecordAbilityBattle(gBankTarget, gLastUsedAbility);
     }
     if (gBattleMoveFlags & MOVESTATUS_NOTAFFECTED)
-        gProtectStructs[gBankAttacker].notEffective = 1;
+        gProtectStructs[gBankAttacker].targetNotAffected = 1;
 
     gBattlescriptCurrInstr++;
 }
@@ -1639,14 +1639,14 @@ static void CheckWonderGuardAndLevitate(void)
             if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type1 && gTypeEffectiveness[i + 2] == 0)
             {
                 gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
-                gProtectStructs[gBankAttacker].notEffective = 1;
+                gProtectStructs[gBankAttacker].targetNotAffected = 1;
             }
             if (gTypeEffectiveness[i + 1] == gBattleMons[gBankTarget].type2 &&
                 gBattleMons[gBankTarget].type1 != gBattleMons[gBankTarget].type2 &&
                 gTypeEffectiveness[i + 2] == TYPE_MUL_NO_EFFECT)
             {
                 gBattleMoveFlags |= MOVESTATUS_NOTAFFECTED;
-                gProtectStructs[gBankAttacker].notEffective = 1;
+                gProtectStructs[gBankAttacker].targetNotAffected = 1;
             }
 
             // check super effective
@@ -5066,7 +5066,7 @@ static void atk49_moveend(void)
         case 9: // make attacker sprite visible
             if (gBattleMoveFlags & MOVESTATUS_NOEFFECT
                 || !(gStatuses3[gBankAttacker] & (STATUS3_SEMI_INVULNERABLE))
-                || HasMoveFailed(gBankAttacker))
+                || WasUnableToUseMove(gBankAttacker))
             {
                 gActiveBank = gBankAttacker;
                 EmitSpriteInvisibility(0, FALSE);
@@ -5297,7 +5297,7 @@ static void atk4A_typecalc2(void)
         RecordAbilityBattle(gBankTarget, gLastUsedAbility);
     }
     if (gBattleMoveFlags & MOVESTATUS_NOTAFFECTED)
-        gProtectStructs[gBankAttacker].notEffective = 1;
+        gProtectStructs[gBankAttacker].targetNotAffected = 1;
 
     gBattlescriptCurrInstr++;
 }
@@ -9518,19 +9518,19 @@ static void atkB3_rolloutdamagecalculation(void)
 
         if (!(gBattleMons[gBankAttacker].status2 & STATUS2_MULTIPLETURNS)) // first hit
         {
-            gDisableStructs[gBankAttacker].rolloutTimer1 = 5;
-            gDisableStructs[gBankAttacker].rolloutTimer2 = 5;
+            gDisableStructs[gBankAttacker].rolloutCounter1 = 5;
+            gDisableStructs[gBankAttacker].rolloutCounter2 = 5;
             gBattleMons[gBankAttacker].status2 |= STATUS2_MULTIPLETURNS;
             gLockedMoves[gBankAttacker] = gCurrentMove;
         }
-        if (--gDisableStructs[gBankAttacker].rolloutTimer1 == 0) // last hit
+        if (--gDisableStructs[gBankAttacker].rolloutCounter1 == 0) // last hit
         {
             gBattleMons[gBankAttacker].status2 &= ~(STATUS2_MULTIPLETURNS);
         }
 
         gDynamicBasePower = gBattleMoves[gCurrentMove].power;
 
-        for (i = 1; i < (5 - gDisableStructs[gBankAttacker].rolloutTimer1); i++)
+        for (i = 1; i < (5 - gDisableStructs[gBankAttacker].rolloutCounter1); i++)
             gDynamicBasePower *= 2;
 
         if (gBattleMons[gBankAttacker].status2 & STATUS2_DEFENSE_CURL)
diff --git a/src/battle_3.c b/src/battle_util.c
index 58e0a05c7..c5a85dd2b 100644
--- a/src/battle_3.c
+++ b/src/battle_util.c
@@ -17,6 +17,7 @@
 #include "battle_controllers.h"
 #include "event_data.h"
 #include "calculate_base_damage.h"
+#include "link.h"
 
 extern const u8* gBattlescriptCurrInstr;
 extern const u8* gBattlescriptPtrsForSelection[BATTLE_BANKS_COUNT];
@@ -33,7 +34,7 @@ extern u8 gBankTarget;
 extern u8 gAbsentBankFlags;
 extern u16 gBattleWeather;
 extern u8 gBanksByTurnOrder[BATTLE_BANKS_COUNT];
-extern u16 gSideAffecting[];
+extern u16 gSideAffecting[2];
 extern u8 gBattleCommunication[];
 extern void (*gBattleMainFunc)(void);
 extern s32 gBattleMoveDamage;
@@ -45,7 +46,7 @@ extern u32 gHitMarker;
 extern u8 gEffectBank;
 extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
 extern u8 gBank1;
-extern u16 gChosenMovesByBanks[];
+extern u16 gChosenMovesByBanks[BATTLE_BANKS_COUNT];
 extern u8 gBattleMoveFlags;
 extern s32 gTakenDmg[BATTLE_BANKS_COUNT];
 extern u8 gTakenDmgBanks[BATTLE_BANKS_COUNT];
@@ -55,8 +56,10 @@ extern u32 gBattleExecBuffer;
 extern u16 gRandomMove;
 extern u8 gCurrMovePos;
 extern u8 gUnknown_020241E9;
+extern u8 gSentPokesToOpponent[2];
 
 extern const struct BattleMove gBattleMoves[];
+extern const u16 gSoundMovesTable[];
 
 // scripts
 extern const u8 gUnknown_082DAE2A[];
@@ -169,6 +172,7 @@ extern const u8 gUnknown_082DB6A5[]; //disobedient, uses a random move
 extern const u8 gUnknown_082DB6D9[]; //disobedient, went to sleep
 extern const u8 gUnknown_082DB6F0[]; //disobedient, hits itself
 
+// strings
 extern const u8 gStatusConditionString_PoisonJpn[];
 extern const u8 gStatusConditionString_SleepJpn[];
 extern const u8 gStatusConditionString_ParalysisJpn[];
@@ -176,12 +180,272 @@ extern const u8 gStatusConditionString_BurnJpn[];
 extern const u8 gStatusConditionString_IceJpn[];
 extern const u8 gStatusConditionString_ConfusionJpn[];
 extern const u8 gStatusConditionString_LoveJpn[];
-extern const u16 gSoundMovesTable[];
 
-extern void sub_803F9EC();
-extern bool8 sub_80423F4(u8 bank, u8, u8);
 extern u8 weather_get_current(void);
-extern s8 GetFlavourRelationByPersonality(u32 personality, u8 flavor);
+
+u8 GetBattleBank(u8 caseId)
+{
+    u8 ret = 0;
+    switch (caseId)
+    {
+    case BS_GET_TARGET:
+        ret = gBankTarget;
+        break;
+    case BS_GET_ATTACKER:
+        ret = gBankAttacker;
+        break;
+    case BS_GET_EFFECT_BANK:
+        ret = gEffectBank;
+        break;
+    case 7:
+        ret = 0;
+        break;
+    case BS_GET_SCRIPTING_BANK:
+        ret = gBattleScripting.bank;
+        break;
+    case 3:
+        ret = gBank1;
+        break;
+    case 5:
+        ret = gBank1;
+        break;
+    case 4:
+    case 6:
+    case 8:
+    case 9:
+    case BS_GET_PLAYER1:
+        ret = GetBankByIdentity(IDENTITY_PLAYER_MON1);
+        break;
+    case BS_GET_OPPONENT1:
+        ret = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
+        break;
+    case BS_GET_PLAYER2:
+        ret = GetBankByIdentity(IDENTITY_PLAYER_MON2);
+        break;
+    case BS_GET_OPPONENT2:
+        ret = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
+        break;
+    }
+    return ret;
+}
+
+void PressurePPLose(u8 bankDef, u8 bankAtk, u16 move)
+{
+    s32 i;
+
+    if (gBattleMons[bankDef].ability != ABILITY_PRESSURE)
+        return;
+
+    for (i = 0; i < 4; i++)
+    {
+        if (gBattleMons[bankAtk].moves[i] == move)
+            break;
+    }
+
+    if (i == 4) // mons don't share any moves
+        return;
+
+    if (gBattleMons[bankAtk].pp[i] != 0)
+        gBattleMons[bankAtk].pp[i]--;
+
+    if (!(gBattleMons[bankAtk].status2 & STATUS2_TRANSFORMED)
+        && !(gDisableStructs[bankAtk].unk18_b & gBitTable[i]))
+    {
+        gActiveBank = bankAtk;
+        EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + i, 0, 1, &gBattleMons[gActiveBank].pp[i]);
+        MarkBufferBankForExecution(gActiveBank);
+    }
+}
+
+void PressurePPLoseOnUsingImprision(u8 bankAtk)
+{
+    s32 i, j;
+    s32 imprisionPos = 4;
+    u8 atkSide = GetBankSide(bankAtk);
+
+    for (i = 0; i < gNoOfAllBanks; i++)
+    {
+        if (atkSide != GetBankSide(i) && gBattleMons[i].ability == ABILITY_PRESSURE)
+        {
+            for (j = 0; j < 4; j++)
+            {
+                if (gBattleMons[bankAtk].moves[j] == MOVE_IMPRISON)
+                    break;
+            }
+            if (j != 4)
+            {
+                imprisionPos = j;
+                if (gBattleMons[bankAtk].pp[j] != 0)
+                    gBattleMons[bankAtk].pp[j]--;
+            }
+        }
+    }
+
+    if (imprisionPos != 4
+        && !(gBattleMons[bankAtk].status2 & STATUS2_TRANSFORMED)
+        && !(gDisableStructs[bankAtk].unk18_b & gBitTable[imprisionPos]))
+    {
+        gActiveBank = bankAtk;
+        EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + imprisionPos, 0, 1, &gBattleMons[gActiveBank].pp[imprisionPos]);
+        MarkBufferBankForExecution(gActiveBank);
+    }
+}
+
+void PressurePPLoseOnUsingPerishSong(u8 bankAtk)
+{
+    s32 i, j;
+    s32 perishSongPos = 4;
+
+    for (i = 0; i < gNoOfAllBanks; i++)
+    {
+        if (gBattleMons[i].ability == ABILITY_PRESSURE && i != bankAtk)
+        {
+            for (j = 0; j < 4; j++)
+            {
+                if (gBattleMons[bankAtk].moves[j] == MOVE_PERISH_SONG)
+                    break;
+            }
+            if (j != 4)
+            {
+                perishSongPos = j;
+                if (gBattleMons[bankAtk].pp[j] != 0)
+                    gBattleMons[bankAtk].pp[j]--;
+            }
+        }
+    }
+
+    if (perishSongPos != 4
+        && !(gBattleMons[bankAtk].status2 & STATUS2_TRANSFORMED)
+        && !(gDisableStructs[bankAtk].unk18_b & gBitTable[perishSongPos]))
+    {
+        gActiveBank = bankAtk;
+        EmitSetMonData(0, REQUEST_PPMOVE1_BATTLE + perishSongPos, 0, 1, &gBattleMons[gActiveBank].pp[perishSongPos]);
+        MarkBufferBankForExecution(gActiveBank);
+    }
+}
+
+void MarkAllBufferBanksForExecution(void) // unused
+{
+    s32 i;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        for (i = 0; i < gNoOfAllBanks; i++)
+            gBattleExecBuffer |= gBitTable[i] << 0x1C;
+    }
+    else
+    {
+        for (i = 0; i < gNoOfAllBanks; i++)
+            gBattleExecBuffer |= gBitTable[i];
+    }
+}
+
+void MarkBufferBankForExecution(u8 bank)
+{
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        gBattleExecBuffer |= gBitTable[bank] << 0x1C;
+    }
+    else
+    {
+        gBattleExecBuffer |= gBitTable[bank];
+    }
+}
+
+void sub_803F850(u8 arg0)
+{
+    s32 i;
+
+    for (i = 0; i < sub_8009FCC(); i++)
+        gBattleExecBuffer |= gBitTable[arg0] << (i << 2);
+
+    gBattleExecBuffer &= ~(0x10000000 << arg0);
+}
+
+void CancelMultiTurnMoves(u8 bank)
+{
+    gBattleMons[bank].status2 &= ~(STATUS2_MULTIPLETURNS);
+    gBattleMons[bank].status2 &= ~(STATUS2_LOCK_CONFUSE);
+    gBattleMons[bank].status2 &= ~(STATUS2_UPROAR);
+    gBattleMons[bank].status2 &= ~(STATUS2_BIDE);
+
+    gStatuses3[bank] &= ~(STATUS3_SEMI_INVULNERABLE);
+
+    gDisableStructs[bank].rolloutCounter1 = 0;
+    gDisableStructs[bank].furyCutterCounter = 0;
+}
+
+bool8 WasUnableToUseMove(u8 bank)
+{
+    if (gProtectStructs[bank].prlzImmobility
+        || gProtectStructs[bank].targetNotAffected
+        || gProtectStructs[bank].usedImprisionedMove
+        || gProtectStructs[bank].loveImmobility
+        || gProtectStructs[bank].usedDisabledMove
+        || gProtectStructs[bank].usedTauntedMove
+        || gProtectStructs[bank].flag2Unknown
+        || gProtectStructs[bank].flinchImmobility
+        || gProtectStructs[bank].confusionSelfDmg)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void PrepareStringBattle(u16 stringId, u8 bank)
+{
+    gActiveBank = bank;
+    EmitPrintString(0, stringId);
+    MarkBufferBankForExecution(gActiveBank);
+}
+
+void ResetSentPokesToOpponentValue(void)
+{
+    s32 i;
+    u32 bits = 0;
+
+    gSentPokesToOpponent[0] = 0;
+    gSentPokesToOpponent[1] = 0;
+
+    for (i = 0; i < gNoOfAllBanks; i += 2)
+        bits |= gBitTable[gBattlePartyID[i]];
+
+    for (i = 1; i < gNoOfAllBanks; i += 2)
+        gSentPokesToOpponent[(i & BIT_MON) >> 1] = bits;
+}
+
+void sub_803F9EC(u8 bank)
+{
+    s32 i = 0;
+    u32 bits = 0;
+
+    if (GetBankSide(bank) == SIDE_OPPONENT)
+    {
+        u8 id = ((bank & BIT_MON) >> 1);
+        gSentPokesToOpponent[id] = 0;
+
+        for (i = 0; i < gNoOfAllBanks; i += 2)
+        {
+            if (!(gAbsentBankFlags & gBitTable[i]))
+                bits |= gBitTable[gBattlePartyID[i]];
+        }
+
+        gSentPokesToOpponent[id] = bits;
+    }
+}
+
+void sub_803FA70(u8 bank)
+{
+    if (GetBankSide(bank) == SIDE_OPPONENT)
+    {
+        sub_803F9EC(bank);
+    }
+    else
+    {
+        s32 i;
+        for (i = 1; i < gNoOfAllBanks; i++)
+            gSentPokesToOpponent[(i & BIT_MON) >> 1] |= gBitTable[gBattlePartyID[bank]];
+    }
+}
 
 void BattleScriptPush(const u8* bsPtr)
 {
@@ -828,7 +1092,7 @@ u8 TurnBasedEffects(void)
                     {
                         gBankAttacker = gActiveBank;
                         gBattleMons[gActiveBank].status2 -= 0x10;  // uproar timer goes down
-                        if (HasMoveFailed(gActiveBank))
+                        if (WasUnableToUseMove(gActiveBank))
                         {
                             CancelMultiTurnMoves(gActiveBank);
                             gBattleCommunication[MULTISTRING_CHOOSER] = 1;
@@ -854,7 +1118,7 @@ u8 TurnBasedEffects(void)
                 if (gBattleMons[gActiveBank].status2 & STATUS2_LOCK_CONFUSE)
                 {
                     gBattleMons[gActiveBank].status2 -= 0x400;
-                    if (HasMoveFailed(gActiveBank))
+                    if (WasUnableToUseMove(gActiveBank))
                         CancelMultiTurnMoves(gActiveBank);
                     else if (!(gBattleMons[gActiveBank].status2 & STATUS2_LOCK_CONFUSE)
                      && (gBattleMons[gActiveBank].status2 & STATUS2_MULTIPLETURNS))
@@ -1125,7 +1389,7 @@ bool8 sub_8041728(void)
         case 4:
             do
             {
-                gBank1 = gBankTarget = gBattleStruct->field_4E; //or should banks be switched?
+                gBank1 = gBankTarget = gBattleStruct->field_4E;
                 if (gBattleMons[gBattleStruct->field_4E].hp == 0
                  && !(gAbsentBankFlags & gBitTable[gBattleStruct->field_4E]))
                 {
@@ -6190,7 +6454,7 @@ void ClearFuryCutterDestinyBondGrudge(u8 bank)
     gStatuses3[bank] &= ~(STATUS3_GRUDGE);
 }
 
-void sub_80458B4(void)
+void HandleAction_RunBattleScript(void) // identical to RunBattleScriptCommands
 {
     if (gBattleExecBuffer == 0)
         gBattleScriptingCommandsTable[*gBattlescriptCurrInstr]();