Merge pull request #230 from PikalaxALT/save_failed_screen

Save failed screen

4 files changed, 489 insertions, 256 deletions

diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c
index f98922c28..d988fd7b4 100644
--- a/src/battle_ai_script_commands.c
+++ b/src/battle_ai_script_commands.c
@@ -34,14 +34,14 @@ enum
 };
 
 /*
-gAIScriptPtr is a pointer to the next battle AI cmd command to read.
-when a command finishes processing, gAIScriptPtr is incremented by
+sAIScriptPtr is a pointer to the next battle AI cmd command to read.
+when a command finishes processing, sAIScriptPtr is incremented by
 the number of bytes that the current command had reserved for arguments
 in order to read the next command correctly. refer to battle_ai_scripts.s for the
 AI scripts.
 */
 
-extern const u8 *gAIScriptPtr;
+static EWRAM_DATA const u8 *sAIScriptPtr = NULL;
 extern u8 *gBattleAI_ScriptsTable[];
 
 static void BattleAICmd_if_random_less_than(void);
@@ -419,7 +419,7 @@ static void BattleAI_DoAIProcessing(void)
         case AIState_DoNotProcess: //Needed to match.
             break;
         case AIState_SettingUp:
-            gAIScriptPtr = gBattleAI_ScriptsTable[AI_THINKING_STRUCT->aiLogicId]; // set the AI ptr.
+            sAIScriptPtr = gBattleAI_ScriptsTable[AI_THINKING_STRUCT->aiLogicId]; // set the AI ptr.
             if (gBattleMons[gBattlerAttacker].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
             {
                 AI_THINKING_STRUCT->moveConsidered = 0; // don't consider a move you have 0 PP for, idiot.
@@ -432,7 +432,7 @@ static void BattleAI_DoAIProcessing(void)
             break;
         case AIState_Processing:
             if (AI_THINKING_STRUCT->moveConsidered != 0)
-                sBattleAICmdTable[*gAIScriptPtr](); // run AI command.
+                sBattleAICmdTable[*sAIScriptPtr](); // run AI command.
             else
             {
                 AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] = 0; // definitely do not consider any move that has 0 PP.
@@ -490,44 +490,44 @@ void RecordItemEffectBattle(u8 battlerId, u8 itemEffect)
 
 static void BattleAICmd_if_random_less_than(void)
 {
-    if (Random() % 256 < gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (Random() % 256 < sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_random_greater_than(void)
 {
-    if (Random() % 256 > gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (Random() % 256 > sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_random_equal(void)
 {
-    if (Random() % 256 == gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (Random() % 256 == sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_random_not_equal(void)
 {
-    if (Random() % 256 != gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (Random() % 256 != sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_score(void)
 {
-    AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] += gAIScriptPtr[1]; // add the result to the array of the move consider's score.
+    AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] += sAIScriptPtr[1]; // add the result to the array of the move consider's score.
 
     if (AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] < 0) // if the score is negative, flatten it to 0.
         AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] = 0;
 
-    gAIScriptPtr += 2; // AI return.
+    sAIScriptPtr += 2; // AI return.
 }
 
 enum {
@@ -539,60 +539,60 @@ static void BattleAICmd_if_hp_less_than(void)
 {
     u16 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) < gAIScriptPtr[2])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) < sAIScriptPtr[2])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
     else
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
 }
 
 static void BattleAICmd_if_hp_more_than(void)
 {
     u16 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) > gAIScriptPtr[2])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) > sAIScriptPtr[2])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
     else
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
 }
 
 static void BattleAICmd_if_hp_equal(void)
 {
     u16 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) == gAIScriptPtr[2])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) == sAIScriptPtr[2])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
     else
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
 }
 
 static void BattleAICmd_if_hp_not_equal(void)
 {
     u16 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) != gAIScriptPtr[2])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) != sAIScriptPtr[2])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
     else
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
 }
 
 static void BattleAICmd_if_status(void)
@@ -600,17 +600,17 @@ static void BattleAICmd_if_status(void)
     u16 index;
     u32 arg;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    arg = T1_READ_32(gAIScriptPtr + 2);
+    arg = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gBattleMons[index].status1 & arg) != 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_not_status(void)
@@ -618,17 +618,17 @@ static void BattleAICmd_if_not_status(void)
     u16 index;
     u32 arg;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    arg = T1_READ_32(gAIScriptPtr + 2);
+    arg = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gBattleMons[index].status1 & arg) == 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_status2(void)
@@ -636,17 +636,17 @@ static void BattleAICmd_if_status2(void)
     u16 index;
     u32 arg;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    arg = T1_READ_32(gAIScriptPtr + 2);
+    arg = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gBattleMons[index].status2 & arg) != 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_not_status2(void)
@@ -654,17 +654,17 @@ static void BattleAICmd_if_not_status2(void)
     u16 index;
     u32 arg;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    arg = T1_READ_32(gAIScriptPtr + 2);
+    arg = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gBattleMons[index].status2 & arg) == 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_status3(void)
@@ -672,17 +672,17 @@ static void BattleAICmd_if_status3(void)
     u16 index;
     u32 arg;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    arg = T1_READ_32(gAIScriptPtr + 2);
+    arg = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gStatuses3[index] & arg) != 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_not_status3(void)
@@ -690,17 +690,17 @@ static void BattleAICmd_if_not_status3(void)
     u16 index;
     u32 arg;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    arg = T1_READ_32(gAIScriptPtr + 2);
+    arg = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gStatuses3[index] & arg) == 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_status4(void)
@@ -708,18 +708,18 @@ static void BattleAICmd_if_status4(void)
     u16 index;
     u32 arg1, arg2;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
     arg1 = GetBattlerPosition(index) & 1;
-    arg2 = T1_READ_32(gAIScriptPtr + 2);
+    arg2 = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gSideStatuses[arg1] & arg2) != 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_not_status4(void)
@@ -727,174 +727,174 @@ static void BattleAICmd_if_not_status4(void)
     u16 index;
     u32 arg1, arg2;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
     arg1 = GetBattlerPosition(index) & 1;
-    arg2 = T1_READ_32(gAIScriptPtr + 2);
+    arg2 = T1_READ_32(sAIScriptPtr + 2);
 
     if ((gSideStatuses[arg1] & arg2) == 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
     else
-        gAIScriptPtr += 10;
+        sAIScriptPtr += 10;
 }
 
 static void BattleAICmd_if_less_than(void)
 {
-    if (AI_THINKING_STRUCT->funcResult < gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (AI_THINKING_STRUCT->funcResult < sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_more_than(void)
 {
-    if (AI_THINKING_STRUCT->funcResult > gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (AI_THINKING_STRUCT->funcResult > sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_equal(void)
 {
-    if (AI_THINKING_STRUCT->funcResult == gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (AI_THINKING_STRUCT->funcResult == sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_not_equal(void)
 {
-    if (AI_THINKING_STRUCT->funcResult != gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (AI_THINKING_STRUCT->funcResult != sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_less_than_32(void)
 {
-    u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+    u8 *temp = T1_READ_PTR(sAIScriptPtr + 1);
 
     if (AI_THINKING_STRUCT->funcResult < *temp)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
     else
-        gAIScriptPtr += 9;
+        sAIScriptPtr += 9;
 }
 
 static void BattleAICmd_if_more_than_32(void)
 {
-    u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+    u8 *temp = T1_READ_PTR(sAIScriptPtr + 1);
 
     if (AI_THINKING_STRUCT->funcResult > *temp)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
     else
-        gAIScriptPtr += 9;
+        sAIScriptPtr += 9;
 }
 
 static void BattleAICmd_if_equal_32(void)
 {
-    u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+    u8 *temp = T1_READ_PTR(sAIScriptPtr + 1);
 
     if (AI_THINKING_STRUCT->funcResult == *temp)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
     else
-        gAIScriptPtr += 9;
+        sAIScriptPtr += 9;
 }
 
 static void BattleAICmd_if_not_equal_32(void)
 {
-    u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+    u8 *temp = T1_READ_PTR(sAIScriptPtr + 1);
 
     if (AI_THINKING_STRUCT->funcResult != *temp)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
     else
-        gAIScriptPtr += 9;
+        sAIScriptPtr += 9;
 }
 
 static void BattleAICmd_if_move(void)
 {
-    u16 move = T1_READ_16(gAIScriptPtr + 1);
+    u16 move = T1_READ_16(sAIScriptPtr + 1);
 
     if (AI_THINKING_STRUCT->moveConsidered == move)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
     else
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
 }
 
 static void BattleAICmd_if_not_move(void)
 {
-    u16 move = T1_READ_16(gAIScriptPtr + 1);
+    u16 move = T1_READ_16(sAIScriptPtr + 1);
 
     if (AI_THINKING_STRUCT->moveConsidered != move)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
     else
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
 }
 
 static void BattleAICmd_if_in_bytes(void)
 {
-    u8 *ptr = T1_READ_PTR(gAIScriptPtr + 1);
+    u8 *ptr = T1_READ_PTR(sAIScriptPtr + 1);
 
     while (*ptr != 0xFF)
     {
         if (AI_THINKING_STRUCT->funcResult == *ptr)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
             return;
         }
         ptr++;
     }
-    gAIScriptPtr += 9;
+    sAIScriptPtr += 9;
 }
 
 static void BattleAICmd_if_not_in_bytes(void)
 {
-    u8 *ptr = T1_READ_PTR(gAIScriptPtr + 1);
+    u8 *ptr = T1_READ_PTR(sAIScriptPtr + 1);
 
     while (*ptr != 0xFF)
     {
         if (AI_THINKING_STRUCT->funcResult == *ptr)
         {
-            gAIScriptPtr += 9;
+            sAIScriptPtr += 9;
             return;
         }
         ptr++;
     }
-    gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+    sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
 }
 
 static void BattleAICmd_if_in_words(void)
 {
-    u16 *ptr = (u16 *)T1_READ_PTR(gAIScriptPtr + 1);
+    u16 *ptr = (u16 *)T1_READ_PTR(sAIScriptPtr + 1);
 
     while (*ptr != 0xFFFF)
     {
         if (AI_THINKING_STRUCT->funcResult == *ptr)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
             return;
         }
         ptr++;
     }
-    gAIScriptPtr += 9;
+    sAIScriptPtr += 9;
 }
 
 static void BattleAICmd_if_not_in_words(void)
 {
-    u16 *ptr = (u16 *)T1_READ_PTR(gAIScriptPtr + 1);
+    u16 *ptr = (u16 *)T1_READ_PTR(sAIScriptPtr + 1);
 
     while (*ptr != 0xFFFF)
     {
         if (AI_THINKING_STRUCT->funcResult == *ptr)
         {
-            gAIScriptPtr += 9;
+            sAIScriptPtr += 9;
             return;
         }
         ptr++;
     }
-    gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+    sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 5);
 }
 
 static void BattleAICmd_if_user_can_damage(void)
@@ -908,9 +908,9 @@ static void BattleAICmd_if_user_can_damage(void)
             break;
     }
     if (i == MAX_MON_MOVES)
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
     else
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
 }
 
 static void BattleAICmd_if_user_cant_damage(void)
@@ -924,20 +924,20 @@ static void BattleAICmd_if_user_cant_damage(void)
             break;
     }
     if (i != MAX_MON_MOVES)
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
     else
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
 }
 
 static void BattleAICmd_get_turn_count(void)
 {
     AI_THINKING_STRUCT->funcResult = gBattleResults.battleTurnCounter;
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_get_type(void)
 {
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 1: // player primary type
         AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerAttacker].type1;
@@ -955,13 +955,13 @@ static void BattleAICmd_get_type(void)
         AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].type;
         break;
     }
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_get_move_power(void)
 {
     AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power;
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_is_most_powerful_move(void)
@@ -1025,49 +1025,49 @@ static void BattleAICmd_is_most_powerful_move(void)
         AI_THINKING_STRUCT->funcResult = MOVE_POWER_DISCOURAGED; // Highly discouraged in terms of power.
     }
 
-    gAIScriptPtr++;
+    sAIScriptPtr++;
 }
 
 static void BattleAICmd_get_move(void)
 {
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         AI_THINKING_STRUCT->funcResult = gLastMoves[gBattlerAttacker];
     else
         AI_THINKING_STRUCT->funcResult = gLastMoves[gBattlerTarget];
 
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_if_arg_equal(void)
 {
-    if (gAIScriptPtr[1] == AI_THINKING_STRUCT->funcResult)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (sAIScriptPtr[1] == AI_THINKING_STRUCT->funcResult)
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_arg_not_equal(void)
 {
-    if (gAIScriptPtr[1] != AI_THINKING_STRUCT->funcResult)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (sAIScriptPtr[1] != AI_THINKING_STRUCT->funcResult)
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_would_go_first(void)
 {
-    if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) == gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) == sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_would_not_go_first(void)
 {
-    if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) != gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) != sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_nullsub_2A(void)
@@ -1087,7 +1087,7 @@ static void BattleAICmd_count_alive_pokemon(void)
 
     AI_THINKING_STRUCT->funcResult = 0;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
@@ -1121,26 +1121,26 @@ static void BattleAICmd_count_alive_pokemon(void)
         }
     }
 
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_get_considered_move(void)
 {
     AI_THINKING_STRUCT->funcResult = AI_THINKING_STRUCT->moveConsidered;
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_get_considered_move_effect(void)
 {
     AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect;
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_get_ability(void)
 {
     u8 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
@@ -1152,7 +1152,7 @@ static void BattleAICmd_get_ability(void)
         if (BATTLE_HISTORY->abilities[side] != 0)
         {
             AI_THINKING_STRUCT->funcResult = BATTLE_HISTORY->abilities[side];
-            gAIScriptPtr += 2;
+            sAIScriptPtr += 2;
             return;
         }
 
@@ -1162,7 +1162,7 @@ static void BattleAICmd_get_ability(void)
         || gBattleMons[index].ability == ABILITY_ARENA_TRAP)
         {
             AI_THINKING_STRUCT->funcResult = gBattleMons[index].ability;
-            gAIScriptPtr += 2;
+            sAIScriptPtr += 2;
             return;
         }
 
@@ -1195,7 +1195,7 @@ static void BattleAICmd_get_ability(void)
         // The AI knows its own ability.
         AI_THINKING_STRUCT->funcResult = gBattleMons[index].ability;
     }
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_get_highest_possible_damage(void)
@@ -1237,7 +1237,7 @@ static void BattleAICmd_get_highest_possible_damage(void)
         }
     }
 
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_if_type_effectiveness(void)
@@ -1267,13 +1267,13 @@ static void BattleAICmd_if_type_effectiveness(void)
     if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
         gBattleMoveDamage = AI_EFFECTIVENESS_x0;
 
-    // Store gBattleMoveDamage in a u8 variable because gAIScriptPtr[1] is a u8.
+    // Store gBattleMoveDamage in a u8 variable because sAIScriptPtr[1] is a u8.
     damageVar = gBattleMoveDamage;
 
-    if (damageVar == gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (damageVar == sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_nullsub_32(void)
@@ -1292,7 +1292,7 @@ static void BattleAICmd_if_status_in_party(void)
     u32 statusToCompareTo;
 
     // for whatever reason, game freak put the party pointer into 2 variables instead of 1. it's possible at some point the switch encompassed the whole function and used each respective variable creating largely duplicate code.
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 1:
         party = partyPtr = gEnemyParty;
@@ -1302,7 +1302,7 @@ static void BattleAICmd_if_status_in_party(void)
         break;
     }
 
-    statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
+    statusToCompareTo = T1_READ_32(sAIScriptPtr + 2);
 
     for (i = 0; i < 6; i++)
     {
@@ -1312,12 +1312,12 @@ static void BattleAICmd_if_status_in_party(void)
 
         if (species != SPECIES_NONE && species != SPECIES_EGG && hp != 0 && status == statusToCompareTo)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6); // WHAT. why is this being merged into the above switch
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6); // WHAT. why is this being merged into the above switch
             return;
         }
     }
 
-    gAIScriptPtr += 10;
+    sAIScriptPtr += 10;
 }
 
 // bugged, doesnt return properly. also unused
@@ -1328,7 +1328,7 @@ static void BattleAICmd_if_status_not_in_party(void)
     int i;
     u32 statusToCompareTo;
 
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 1:
         party = partyPtr = gEnemyParty;
@@ -1338,7 +1338,7 @@ static void BattleAICmd_if_status_not_in_party(void)
         break;
     }
 
-    statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
+    statusToCompareTo = T1_READ_32(sAIScriptPtr + 2);
 
     for (i = 0; i < 6; i++)
     {
@@ -1348,9 +1348,9 @@ static void BattleAICmd_if_status_not_in_party(void)
 
         // everytime the status is found, the AI's logic jumps further and further past its intended destination. this results in a broken AI macro and is probably why it is unused.
         if (species != SPECIES_NONE && species != SPECIES_EGG && hp != 0 && status == statusToCompareTo)
-            gAIScriptPtr += 10; // doesnt return?
+            sAIScriptPtr += 10; // doesnt return?
     }
-    gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+    sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 6);
 }
 
 enum
@@ -1374,90 +1374,90 @@ static void BattleAICmd_get_weather(void)
     if (gBattleWeather & WEATHER_HAIL)
         AI_THINKING_STRUCT->funcResult = WEATHER_TYPE_HAIL;
 
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_if_effect(void)
 {
-    if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect == gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect == sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_not_effect(void)
 {
-    if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect != gAIScriptPtr[1])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect != sAIScriptPtr[1])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
     else
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
 }
 
 static void BattleAICmd_if_stat_level_less_than(void)
 {
     u32 party;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
-    if (gBattleMons[party].statStages[gAIScriptPtr[2]] < gAIScriptPtr[3])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    if (gBattleMons[party].statStages[sAIScriptPtr[2]] < sAIScriptPtr[3])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
     else
-        gAIScriptPtr += 8;
+        sAIScriptPtr += 8;
 }
 
 static void BattleAICmd_if_stat_level_more_than(void)
 {
     u32 party;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
-    if (gBattleMons[party].statStages[gAIScriptPtr[2]] > gAIScriptPtr[3])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    if (gBattleMons[party].statStages[sAIScriptPtr[2]] > sAIScriptPtr[3])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
     else
-        gAIScriptPtr += 8;
+        sAIScriptPtr += 8;
 }
 
 static void BattleAICmd_if_stat_level_equal(void)
 {
     u32 party;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
-    if (gBattleMons[party].statStages[gAIScriptPtr[2]] == gAIScriptPtr[3])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    if (gBattleMons[party].statStages[sAIScriptPtr[2]] == sAIScriptPtr[3])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
     else
-        gAIScriptPtr += 8;
+        sAIScriptPtr += 8;
 }
 
 static void BattleAICmd_if_stat_level_not_equal(void)
 {
     u32 party;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
-    if (gBattleMons[party].statStages[gAIScriptPtr[2]] != gAIScriptPtr[3])
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    if (gBattleMons[party].statStages[sAIScriptPtr[2]] != sAIScriptPtr[3])
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
     else
-        gAIScriptPtr += 8;
+        sAIScriptPtr += 8;
 }
 
 static void BattleAICmd_if_can_faint(void)
 {
     if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power < 2)
     {
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
         return;
     }
 
@@ -1477,16 +1477,16 @@ static void BattleAICmd_if_can_faint(void)
         gBattleMoveDamage = 1;
 
     if (gBattleMons[gBattlerTarget].hp <= gBattleMoveDamage)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
     else
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
 }
 
 static void BattleAICmd_if_cant_faint(void)
 {
     if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power < 2)
     {
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
         return;
     }
 
@@ -1504,17 +1504,17 @@ static void BattleAICmd_if_cant_faint(void)
     // This macro is missing the damage 0 = 1 assumption.
 
     if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
     else
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
 }
 
 static void BattleAICmd_if_has_move(void)
 {
     int i;
-    u16 *temp_ptr = (u16 *)(gAIScriptPtr + 2);
+    u16 *temp_ptr = (u16 *)(sAIScriptPtr + 2);
 
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 1:
     case 3:
@@ -1524,9 +1524,9 @@ static void BattleAICmd_if_has_move(void)
                 break;
         }
         if (i == MAX_MON_MOVES)
-            gAIScriptPtr += 8;
+            sAIScriptPtr += 8;
         else
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
         break;
     case 0:
     case 2:
@@ -1536,9 +1536,9 @@ static void BattleAICmd_if_has_move(void)
                 break;
         }
         if (i == 8)
-            gAIScriptPtr += 8;
+            sAIScriptPtr += 8;
          else
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
         break;
     }
 }
@@ -1546,9 +1546,9 @@ static void BattleAICmd_if_has_move(void)
 static void BattleAICmd_if_dont_have_move(void)
 {
     int i;
-    u16 *temp_ptr = (u16 *)(gAIScriptPtr + 2);
+    u16 *temp_ptr = (u16 *)(sAIScriptPtr + 2);
 
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 1:
     case 3:
@@ -1558,9 +1558,9 @@ static void BattleAICmd_if_dont_have_move(void)
                 break;
         }
         if (i != MAX_MON_MOVES)
-            gAIScriptPtr += 8;
+            sAIScriptPtr += 8;
         else
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
         break;
     case 0:
     case 2:
@@ -1570,9 +1570,9 @@ static void BattleAICmd_if_dont_have_move(void)
                 break;
         }
         if (i != 8)
-            gAIScriptPtr += 8;
+            sAIScriptPtr += 8;
         else
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 4);
         break;
     }
 }
@@ -1581,28 +1581,28 @@ static void BattleAICmd_if_move_effect(void)
 {
     int i;
 
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 1:
     case 3:
         for (i = 0; i < MAX_MON_MOVES; i++)
         {
-            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == gAIScriptPtr[2])
+            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == sAIScriptPtr[2])
                 break;
         }
         if (i != MAX_MON_MOVES)
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
         else
-            gAIScriptPtr += 7;
+            sAIScriptPtr += 7;
         break;
     case 0:
     case 2:
         for (i = 0; i < 8; i++)
         {
-            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
+            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == sAIScriptPtr[2])
                 break;
         }
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
     }
 }
 
@@ -1610,28 +1610,28 @@ static void BattleAICmd_if_not_move_effect(void)
 {
     int i;
 
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 1:
     case 3:
         for (i = 0; i < MAX_MON_MOVES; i++)
         {
-            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == gAIScriptPtr[2])
+            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == sAIScriptPtr[2])
                 break;
         }
         if (i != MAX_MON_MOVES)
-            gAIScriptPtr += 7;
+            sAIScriptPtr += 7;
         else
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
         break;
     case 0:
     case 2:
         for (i = 0; i < 8; i++)
         {
-            if (BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
+            if (BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == sAIScriptPtr[2])
                 break;
         }
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
     }
 }
 
@@ -1639,56 +1639,56 @@ static void BattleAICmd_if_last_move_did_damage(void)
 {
     u8 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
-    if (gAIScriptPtr[2] == 0)
+    if (sAIScriptPtr[2] == 0)
     {
         if (gDisableStructs[index].disabledMove == MOVE_NONE)
         {
-            gAIScriptPtr += 7;
+            sAIScriptPtr += 7;
             return;
         }
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
         return;
     }
-    else if (gAIScriptPtr[2] != 1) // ignore the macro if its not 0 or 1.
+    else if (sAIScriptPtr[2] != 1) // ignore the macro if its not 0 or 1.
     {
-        gAIScriptPtr += 7;
+        sAIScriptPtr += 7;
         return;
     }
     else if (gDisableStructs[index].encoredMove != MOVE_NONE)
     {
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 3);
         return;
     }
-    gAIScriptPtr += 7;
+    sAIScriptPtr += 7;
 }
 
 static void BattleAICmd_if_encored(void)
 {
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 0: // _08109348
         if (gDisableStructs[gActiveBattler].disabledMove == AI_THINKING_STRUCT->moveConsidered)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
             return;
         }
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
         return;
     case 1: // _08109370
         if (gDisableStructs[gActiveBattler].encoredMove == AI_THINKING_STRUCT->moveConsidered)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
             return;
         }
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
         return;
     default:
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
         return;
     }
 }
@@ -1719,9 +1719,9 @@ static void BattleAICmd_frlg_safari(void)
         var = gBattleStruct->safariEscapeFactor;
     var *= 5;
     if ((u8)(Random() % 100) < var)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
     else
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
 }
 
 static void BattleAICmd_watch(void)
@@ -1734,7 +1734,7 @@ static void BattleAICmd_get_hold_effect(void)
     u8 index;
     u16 side;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
@@ -1747,104 +1747,104 @@ static void BattleAICmd_get_hold_effect(void)
     else
         AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(gBattleMons[index].item);
 
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_get_gender(void)
 {
     u8 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = GetGenderFromSpeciesAndPersonality(gBattleMons[index].species, gBattleMons[index].personality);
 
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_is_first_turn(void)
 {
     u8 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = gDisableStructs[index].isFirstTurn;
 
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_get_stockpile_count(void)
 {
     u8 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = gDisableStructs[index].stockpileCounter;
 
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_is_double_battle(void)
 {
     AI_THINKING_STRUCT->funcResult = gBattleTypeFlags & BATTLE_TYPE_DOUBLE;
 
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_get_used_held_item(void)
 {
     u8 battlerId;
 
-    if (gAIScriptPtr[1] == AI_USER)
+    if (sAIScriptPtr[1] == AI_USER)
         battlerId = gBattlerAttacker;
     else
         battlerId = gBattlerTarget;
     // This is likely a leftover from Ruby's code and its ugly ewram access.
     AI_THINKING_STRUCT->funcResult = ((u8 *)gBattleStruct->usedHeldItems)[battlerId * 2];
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_get_move_type_from_result(void)
 {
     AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].type;
 
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_get_move_power_from_result(void)
 {
     AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].power;
 
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_get_move_effect_from_result(void)
 {
     AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].effect;
 
-    gAIScriptPtr += 1;
+    sAIScriptPtr += 1;
 }
 
 static void BattleAICmd_get_protect_count(void)
 {
     u8 index;
 
-    if (gAIScriptPtr[1] == USER)
+    if (sAIScriptPtr[1] == USER)
         index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = gDisableStructs[index].protectUses;
 
-    gAIScriptPtr += 2;
+    sAIScriptPtr += 2;
 }
 
 static void BattleAICmd_nullsub_52(void)
@@ -1873,13 +1873,13 @@ static void BattleAICmd_nullsub_57(void)
 
 static void BattleAICmd_call(void)
 {
-    AIStackPushVar(gAIScriptPtr + 5);
-    gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    AIStackPushVar(sAIScriptPtr + 5);
+    sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
 }
 
 static void BattleAICmd_jump(void)
 {
-    gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
 }
 
 static void BattleAICmd_end(void)
@@ -1890,31 +1890,31 @@ static void BattleAICmd_end(void)
 
 static void BattleAICmd_if_level_compare(void)
 {
-    switch (gAIScriptPtr[1])
+    switch (sAIScriptPtr[1])
     {
     case 0: // greater than
         if (gBattleMons[gBattlerAttacker].level > gBattleMons[gBattlerTarget].level)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
             return;
         }
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
         return;
     case 1: // less than
         if (gBattleMons[gBattlerAttacker].level < gBattleMons[gBattlerTarget].level)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
             return;
         }
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
         return;
     case 2: // equal
         if (gBattleMons[gBattlerAttacker].level == gBattleMons[gBattlerTarget].level)
         {
-            gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+            sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 2);
             return;
         }
-        gAIScriptPtr += 6;
+        sAIScriptPtr += 6;
         return;
     }
 }
@@ -1922,17 +1922,17 @@ static void BattleAICmd_if_level_compare(void)
 static void BattleAICmd_if_taunted(void)
 {
     if (gDisableStructs[gBattlerTarget].tauntTimer != 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
     else
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
 }
 
 static void BattleAICmd_if_not_taunted(void)
 {
     if (gDisableStructs[gBattlerTarget].tauntTimer == 0)
-        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+        sAIScriptPtr = T1_READ_PTR(sAIScriptPtr + 1);
     else
-        gAIScriptPtr += 5;
+        sAIScriptPtr += 5;
 }
 
 static void AIStackPushVar(const u8 *var)
@@ -1943,7 +1943,7 @@ static void AIStackPushVar(const u8 *var)
 // unused
 static void AIStackPushVar_cursor(void)
 {
-    gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size++] = gAIScriptPtr;
+    gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size++] = sAIScriptPtr;
 }
 
 static bool8 AIStackPop(void)
@@ -1951,7 +1951,7 @@ static bool8 AIStackPop(void)
     if (gBattleResources->AI_ScriptsStack->size != 0)
     {
         --gBattleResources->AI_ScriptsStack->size;
-        gAIScriptPtr = gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size];
+        sAIScriptPtr = gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size];
         return TRUE;
     }
     else
diff --git a/src/fldeff_rocksmash.c b/src/fldeff_rocksmash.c
index 980b72d4f..2cca37f7a 100644
--- a/src/fldeff_rocksmash.c
+++ b/src/fldeff_rocksmash.c
@@ -25,6 +25,8 @@ static void sub_80C99A0(u8 taskId);
 static void sub_80C9A10(void);
 static void sub_80C9A60(void);
 
+EWRAM_DATA struct MapPosition gPlayerFacingPosition = {};
+
 bool8 CheckObjectGraphicsInFrontOfPlayer(u8 graphicsId)
 {
     u8 mapObjId;
diff --git a/src/main.c b/src/main.c
index 336584ab3..b88326cda 100644
--- a/src/main.c
+++ b/src/main.c
@@ -115,7 +115,7 @@ void AgbMain()
     gSoftResetDisabled = FALSE;
     gHelpSystemEnabled = FALSE;
 
-    sub_80F50F4();
+    SetNotInSaveFailedScreen();
 
     AGBPrintInit();
 
@@ -186,7 +186,7 @@ static void InitMainCallbacks(void)
 
 static void CallCallbacks(void)
 {
-    if (!sub_80F5118() && !RunHelpSystemCallback())
+    if (!RunSaveFailedScreen() && !RunHelpSystemCallback())
     {
         if (gMain.callback1)
             gMain.callback1();
diff --git a/src/save_failed_screen.c b/src/save_failed_screen.c
new file mode 100644
index 000000000..b6cce890a
--- /dev/null
+++ b/src/save_failed_screen.c
@@ -0,0 +1,231 @@
+#include "global.h"
+#include "decompress.h"
+#include "dma3.h"
+#include "gba/flash_internal.h"
+#include "gpu_regs.h"
+#include "help_system.h"
+#include "m4a.h"
+#include "save.h"
+#include "save_failed_screen.h"
+#include "strings.h"
+#include "text.h"
+
+bool32 sIsInSaveFailedScreen;
+
+static EWRAM_DATA u16 sSaveType = SAVE_NORMAL;
+static EWRAM_DATA u16 unused_203AB4E = 0;
+static EWRAM_DATA u8 sSaveFailedScreenState = 0;
+
+static void BlankPalettes(void);
+static void UpdateMapBufferWithText(void);
+static void ClearMapBuffer(void);
+static void PrintTextOnSaveFailedScreen(const u8 *a0);
+static bool32 TryWipeDamagedSectors(void);
+static bool32 WipeDamagedSectors(u32 damagedSectors);
+
+static const u16 sSaveFailedScreenPals[] = INCBIN_U16("graphics/interface/save_failed_screen.gbapal");
+
+void SetNotInSaveFailedScreen(void)
+{
+    sIsInSaveFailedScreen = FALSE;
+}
+
+void DoSaveFailedScreen(u8 saveType)
+{
+    sSaveType = saveType;
+    sIsInSaveFailedScreen = TRUE;
+}
+
+bool32 RunSaveFailedScreen(void)
+{
+    switch (sSaveFailedScreenState)
+    {
+    case 0:
+        if (!sIsInSaveFailedScreen)
+            return FALSE;
+        m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 128);
+        SaveCallbacks();
+        sSaveFailedScreenState = 1;
+        break;
+    case 1:
+        SaveMapTiles();
+        SaveMapGPURegs();
+        SaveMapTextColors();
+        BlankPalettes();
+        SetGpuReg(REG_OFFSET_DISPCNT, 0);
+        sSaveFailedScreenState = 2;
+        break;
+    case 2:
+        RequestDma3Fill(0, (void *)BG_CHAR_ADDR(3), BG_CHAR_SIZE, 0);
+        RequestDma3Copy(sSaveFailedScreenPals, (void *)PLTT, 0x20, 0);
+        sSaveFailedScreenState = 3;
+        break;
+    case 3:
+        ClearMapBuffer();
+        PrintTextOnSaveFailedScreen(gText_SaveFailedScreen_CheckingBackupMemory);
+        UpdateMapBufferWithText();
+        sSaveFailedScreenState = 4;
+        break;
+    case 4:
+        SetGpuReg(REG_OFFSET_BLDCNT, 0);
+        SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+        SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG0CNT, BGCNT_PRIORITY(0) | BGCNT_CHARBASE(3) | BGCNT_SCREENBASE(31));
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON);
+        sSaveFailedScreenState = 5;
+        break;
+    case 5:
+        if (TryWipeDamagedSectors() == TRUE)
+        {
+            gSaveSucceeded = SAVE_STATUS_OK;
+            PrintTextOnSaveFailedScreen(gText_SaveFailedScreen_SaveCompleted);
+        }
+        else
+        {
+            gSaveSucceeded = SAVE_STATUS_ERROR;
+            PrintTextOnSaveFailedScreen(gText_SaveFailedScreen_BackupMemoryDamaged);
+        }
+        sSaveFailedScreenState = 6;
+        break;
+    case 6:
+        if (JOY_NEW(A_BUTTON))
+            sSaveFailedScreenState = 7;
+        break;
+    case 7:
+        SetGpuReg(REG_OFFSET_DISPCNT, 0);
+        RestoreMapTiles();
+        BlankPalettes();
+        sSaveFailedScreenState = 8;
+        break;
+    case 8:
+        m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256);
+        RestoreMapTextColors();
+        RestoreGPURegs();
+        RestoreCallbacks();
+        sIsInSaveFailedScreen = FALSE;
+        sSaveFailedScreenState = 0;
+        break;
+    }
+    return TRUE;
+}
+
+static void BlankPalettes(void)
+{
+    int i;
+    for (i = 0; i < BG_PLTT_SIZE; i += sizeof(u16))
+    {
+        *((u16 *)(BG_PLTT + i)) = RGB_BLACK;
+        *((u16 *)(OBJ_PLTT + i)) = RGB_BLACK;
+    }
+}
+
+static void RequestDmaCopyFromScreenBuffer(void)
+{
+    RequestDma3Copy(gDecompressionBuffer + 0x3800, (void *)BG_SCREEN_ADDR(31), 0x500, 0);
+}
+
+static void RequestDmaCopyFromCharBuffer(void)
+{
+    RequestDma3Copy(gDecompressionBuffer + 0x020, (void *)BG_CHAR_ADDR(3) + 0x20, 0x2300, 0);
+}
+
+static void FillBgMapBufferRect(u16 baseBlock, u8 left, u8 top, u8 width, u8 height, u16 blockOffset)
+{
+    u16 i, j;
+
+    for (i = top; i < top + height; i++)
+    {
+        for (j = left; j < left + width; j++)
+        {
+            *((u16 *)(gDecompressionBuffer + 0x3800 + 64 * i + 2 * j)) = baseBlock;
+            baseBlock += blockOffset;
+        }
+    }
+    RequestDmaCopyFromScreenBuffer();
+}
+
+static void UpdateMapBufferWithText(void)
+{
+    FillBgMapBufferRect(0x001, 1, 5, 28, 10, 0x001);
+}
+
+static void ClearMapBuffer(void)
+{
+    FillBgMapBufferRect(0x000, 0, 0, 30, 20, 0x000);
+}
+
+static void PrintTextOnSaveFailedScreen(const u8 *str)
+{
+    GenerateFontHalfRowLookupTable(TEXT_COLOR_DARK_GREY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GREY);
+    CpuFill16(PIXEL_FILL(1) | (PIXEL_FILL(1) << 8), gDecompressionBuffer + 0x20, 0x2300);
+    HelpSystemRenderText(2, gDecompressionBuffer + 0x20, str, 2, 2, 28, 10);
+    RequestDmaCopyFromCharBuffer();
+}
+
+static bool32 TryWipeDamagedSectors(void)
+{
+    int i = 0;
+    for (i = 0; gDamagedSaveSectors != 0 && i < 3; i++)
+    {
+        if (WipeDamagedSectors(gDamagedSaveSectors))
+            return FALSE;
+        HandleSavingData(sSaveType);
+    }
+    if (gDamagedSaveSectors != 0)
+        return FALSE;
+    return TRUE;
+}
+
+static bool16 VerifySectorWipe(u32 sector)
+{
+    u16 sector0 = sector;
+    u16 i;
+    u32 *saveDataBuffer = (void *)&gSaveDataBuffer;
+    ReadFlash(sector0, 0, saveDataBuffer, 0x1000);
+    for (i = 0; i < 0x1000 / sizeof(u32); i++, saveDataBuffer++)
+    {
+        if (*saveDataBuffer != 0)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+static bool32 WipeSector(u32 sector)
+{
+    bool32 result;
+    u16 i, j;
+
+    i = 0;
+    while (i < 130)
+    {
+        for (j = 0; j < 0x1000; j++)
+        {
+            ProgramFlashByte(sector, j, 0);
+        }
+        result = VerifySectorWipe(sector);
+        i++;
+        if (!result)
+            break;
+    }
+
+    return result;
+}
+
+static bool32 WipeDamagedSectors(u32 damagedSectors)
+{
+    int i;
+    for (i = 0; i < 32; i++)
+    {
+        if (damagedSectors & (1 << i))
+        {
+            if (!WipeSector(i))
+            {
+                damagedSectors &= ~(1 << i);
+            }
+        }
+    }
+    if (damagedSectors == 0)
+        return FALSE;
+    else
+        return TRUE;
+}