Move some symbols out of sym_ewram.txt

1 files changed, 254 insertions, 254 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