Cleanup some of gContestResources

1 files changed, 253 insertions, 253 deletions

diff --git a/src/contest_effect.c b/src/contest_effect.c
index 760d74d69..369850bb4 100644
--- a/src/contest_effect.c
+++ b/src/contest_effect.c
@@ -82,101 +82,101 @@ static void ContestEffect_HighlyAppealing(void)
 // After this move, the user is more easily startled.
 static void ContestEffect_UserMoreEasilyStartled(void)
 {
-    sContestantStatus[shared192D0.contestant].moreEasilyStartled = TRUE;
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_MORE_CONSCIOUS);
+    eContestantStatus[eContestResources8.contestant].moreEasilyStartled = TRUE;
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_MORE_CONSCIOUS);
 }
 
 // Makes a great appeal, but allows no more to the end.
 static void ContestEffect_GreatAppealButNoMoreMoves(void)
 {
-    sContestantStatus[shared192D0.contestant].exploded = TRUE;
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_NO_APPEAL);
+    eContestantStatus[eContestResources8.contestant].exploded = TRUE;
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_NO_APPEAL);
 }
 
 // Can be used repeatedly without boring the JUDGE.
 static void ContestEffect_RepetitionNotBoring(void)
 {
-    sContestantStatus[shared192D0.contestant].usedRepeatableMove = TRUE;
-    sContestantStatus[shared192D0.contestant].disappointedRepeat = FALSE;
-    sContestantStatus[shared192D0.contestant].moveRepeatCount = 0;
+    eContestantStatus[eContestResources8.contestant].usedRepeatableMove = TRUE;
+    eContestantStatus[eContestResources8.contestant].disappointedRepeat = FALSE;
+    eContestantStatus[eContestResources8.contestant].moveRepeatCount = 0;
 }
 
 // Can avoid being startled by others once.
 static void ContestEffect_AvoidStartleOnce(void)
 {
-    sContestantStatus[shared192D0.contestant].jamSafetyCount = 1;
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_SETTLE_DOWN);
+    eContestantStatus[eContestResources8.contestant].jamSafetyCount = 1;
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_SETTLE_DOWN);
 }
 
 // Can avoid being startled by others.
 static void ContestEffect_AvoidStartle(void)
 {
-    sContestantStatus[shared192D0.contestant].immune = TRUE;
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_OBLIVIOUS_TO_OTHERS);
+    eContestantStatus[eContestResources8.contestant].immune = TRUE;
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_OBLIVIOUS_TO_OTHERS);
 }
 
 // Can avoid being startled by others a little.
 static void ContestEffect_AvoidStartleSlightly(void)
 {
-    sContestantStatus[shared192D0.contestant].jamReduction = 20;
-    SetContestantEffectStringID(shared192D0.contestant,CONTEST_STRING_LESS_AWARE);
+    eContestantStatus[eContestResources8.contestant].jamReduction = 20;
+    SetContestantEffectStringID(eContestResources8.contestant,CONTEST_STRING_LESS_AWARE);
 }
 
 // After this move, the user is less likely to be startled.
 static void ContestEffect_UserLessEasilyStartled(void)
 {
-    sContestantStatus[shared192D0.contestant].resistant = TRUE;
-    SetContestantEffectStringID(shared192D0.contestant,CONTEST_STRING_STOPPED_CARING);
+    eContestantStatus[eContestResources8.contestant].resistant = TRUE;
+    SetContestantEffectStringID(eContestResources8.contestant,CONTEST_STRING_STOPPED_CARING);
 }
 
-// Slightly startles the POKéMON in front.
+// Slightly startles the POK�MON in front.
 static void ContestEffect_StartleFrontMon(void)
 {
     u8 idx = 0;
-    u8 a = shared192D0.contestant;
+    u8 a = eContestResources8.contestant;
 
-    if (shared192D0.turnOrder[a] != 0) {
+    if (eContestResources8.turnOrder[a] != 0) {
         int i;
 
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[a] - 1 == shared192D0.turnOrder[i])
+            if (eContestResources8.turnOrder[a] - 1 == eContestResources8.turnOrder[i])
                 break;
         }
-        shared192D0.jamQueue[0] = i;
-        shared192D0.jamQueue[1] = 0xFF;
+        eContestResources8.jamQueue[0] = i;
+        eContestResources8.jamQueue[1] = 0xFF;
         idx = WasAtLeastOneOpponentJammed();
     }
     if (idx == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
 // Slightly startles those that have made appeals.
 static void ContestEffect_StartlePrevMons(void)
 {
     u8 idx = 0;
-    u8 a = shared192D0.contestant;
+    u8 a = eContestResources8.contestant;
 
-    if (shared192D0.turnOrder[a] != 0)
+    if (eContestResources8.turnOrder[a] != 0)
     {
         int i, j;
 
         for (i = 0, j = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[a] > shared192D0.turnOrder[i])
-                shared192D0.jamQueue[j++] = i;
+            if (eContestResources8.turnOrder[a] > eContestResources8.turnOrder[i])
+                eContestResources8.jamQueue[j++] = i;
         }
 
-        shared192D0.jamQueue[j] = 0xFF;
+        eContestResources8.jamQueue[j] = 0xFF;
         idx = WasAtLeastOneOpponentJammed();
     }
     if (idx == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Startles the POKéMON that appealed before the user.
+// Startles the POK�MON that appealed before the user.
 static void ContestEffect_StartlePrevMon2(void)
 {
     u8 rval = Random() % 10;
@@ -189,16 +189,16 @@ static void ContestEffect_StartlePrevMon2(void)
     else
         jam = 60;
 
-    shared192D0.jam = jam;
+    eContestResources8.jam = jam;
     ContestEffect_StartleFrontMon();
 }
 
-// Startles all POKéMON that appealed before the user.
+// Startles all POK�MON that appealed before the user.
 static void ContestEffect_StartlePrevMons2(void)
 {
     u8 numStartled = 0;
-    u8 contestant = shared192D0.contestant;
-    u8 turnOrder = shared192D0.turnOrder[contestant];
+    u8 contestant = eContestResources8.contestant;
+    u8 turnOrder = eContestResources8.turnOrder[contestant];
 
     if (turnOrder != 0)
     {
@@ -206,12 +206,12 @@ static void ContestEffect_StartlePrevMons2(void)
 
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[contestant] > shared192D0.turnOrder[i])
+            if (eContestResources8.turnOrder[contestant] > eContestResources8.turnOrder[i])
             {
                 u8 rval, jam;
 
-                shared192D0.jamQueue[0] = i;
-                shared192D0.jamQueue[1] = 0xFF;
+                eContestResources8.jamQueue[0] = i;
+                eContestResources8.jamQueue[1] = 0xFF;
                 rval = Random() % 10;
 
                 if (rval == 0)
@@ -227,141 +227,141 @@ static void ContestEffect_StartlePrevMons2(void)
                 else
                     jam = 60;
 
-                shared192D0.jam = jam;
+                eContestResources8.jam = jam;
 
                 if (WasAtLeastOneOpponentJammed())
                     numStartled++;
             }
         }
     }
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
     if (numStartled == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
 }
 
-// Shifts the JUDGE’s attention from others.
+// Shifts the JUDGE�s attention from others.
 static void ContestEffect_ShiftJudgeAttention(void)
 {
     bool32 hitAny = FALSE;
-    u8 contestant = shared192D0.contestant;
+    u8 contestant = eContestResources8.contestant;
 
-    if (shared192D0.turnOrder[shared192D0.contestant] != 0)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] != 0)
     {
         int i;
 
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[contestant] > shared192D0.turnOrder[i] &&
-                sContestantStatus[i].hasJudgesAttention &&
+            if (eContestResources8.turnOrder[contestant] > eContestResources8.turnOrder[i] &&
+                eContestantStatus[i].hasJudgesAttention &&
                 CanUnnerveContestant(i))
             {
-                sContestantStatus[i].hasJudgesAttention = FALSE;
-                sContestantStatus[i].judgesAttentionWasRemoved = TRUE;
+                eContestantStatus[i].hasJudgesAttention = FALSE;
+                eContestantStatus[i].judgesAttentionWasRemoved = TRUE;
                 SetContestantEffectStringID(i, CONTEST_STRING_JUDGE_LOOK_AWAY2);
                 hitAny = TRUE;
             }
         }
     }
-    SetContestantEffectStringID(shared192D0.contestant,CONTEST_STRING_DAZZLE_ATTEMPT);
+    SetContestantEffectStringID(eContestResources8.contestant,CONTEST_STRING_DAZZLE_ATTEMPT);
     if (!hitAny)
     {
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
     }
 }
 
-// Startles the POKéMON that has the JUDGE’s attention.
+// Startles the POK�MON that has the JUDGE�s attention.
 static void ContestEffect_StartleMonWithJudgesAttention(void)
 {
     u8 numStartled = 0;
-    u8 contestant = shared192D0.contestant;
+    u8 contestant = eContestResources8.contestant;
 
-    if (shared192D0.turnOrder[shared192D0.contestant] != 0)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] != 0)
     {
         int i;
 
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[contestant] > shared192D0.turnOrder[i])
+            if (eContestResources8.turnOrder[contestant] > eContestResources8.turnOrder[i])
             {
-                if (sContestantStatus[i].hasJudgesAttention)
-                    shared192D0.jam = 50;
+                if (eContestantStatus[i].hasJudgesAttention)
+                    eContestResources8.jam = 50;
                 else
-                    shared192D0.jam = 10;
-                shared192D0.jamQueue[0] = i;
-                shared192D0.jamQueue[1] = 0xFF;
+                    eContestResources8.jam = 10;
+                eContestResources8.jamQueue[0] = i;
+                eContestResources8.jamQueue[1] = 0xFF;
                 if (WasAtLeastOneOpponentJammed())
                     numStartled++;
             }
         }
     }
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
     if (numStartled == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
 }
 
 // Jams the others, and misses one turn of appeals.
 static void ContestEffect_JamsOthersButMissOneTurn(void)
 {
-    sContestantStatus[shared192D0.contestant].turnSkipped = TRUE;
+    eContestantStatus[eContestResources8.contestant].turnSkipped = TRUE;
     ContestEffect_StartlePrevMons();
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Startles POKéMON that made a same-type appeal.
+// Startles POK�MON that made a same-type appeal.
 static void ContestEffect_StartleMonsSameTypeAppeal(void)
 {
-    u16 move = sContestantStatus[shared192D0.contestant].currMove;
+    u16 move = eContestantStatus[eContestResources8.contestant].currMove;
     JamByMoveCategory(gContestMoves[move].contestCategory);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Badly startles POKéMON that made COOL appeals.
+// Badly startles POK�MON that made COOL appeals.
 static void ContestEffect_StartleMonsCoolAppeal(void)
 {
     JamByMoveCategory(CONTEST_CATEGORY_COOL);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Badly startles POKéMON that made BEAUTY appeals.
+// Badly startles POK�MON that made BEAUTY appeals.
 static void ContestEffect_StartleMonsBeautyAppeal(void)
 {
     JamByMoveCategory(CONTEST_CATEGORY_BEAUTY);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Badly startles POKéMON that made CUTE appeals.
+// Badly startles POK�MON that made CUTE appeals.
 static void ContestEffect_StartleMonsCuteAppeal(void)
 {
     JamByMoveCategory(CONTEST_CATEGORY_CUTE);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Badly startles POKéMON that made SMART appeals.
+// Badly startles POK�MON that made SMART appeals.
 static void ContestEffect_StartleMonsSmartAppeal(void)
 {
     JamByMoveCategory(CONTEST_CATEGORY_SMART);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Badly startles POKéMON that made TOUGH appeals.
+// Badly startles POK�MON that made TOUGH appeals.
 static void ContestEffect_StartleMonsToughAppeal(void)
 {
     JamByMoveCategory(CONTEST_CATEGORY_TOUGH);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
-// Makes one POKéMON after the user nervous.
+// Makes one POK�MON after the user nervous.
 static void ContestEffect_MakeFollowingMonNervous(void)
 {
     bool32 hitAny = FALSE;
 
-    if (shared192D0.turnOrder[shared192D0.contestant] != 3)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] != 3)
     {
         int i;
 
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[shared192D0.contestant] + 1 == shared192D0.turnOrder[i])
+            if (eContestResources8.turnOrder[eContestResources8.contestant] + 1 == eContestResources8.turnOrder[i])
             {
                 if (CanUnnerveContestant(i))
                 {
@@ -377,12 +377,12 @@ static void ContestEffect_MakeFollowingMonNervous(void)
             }
         }
     }
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_UNNERVE_ATTEMPT);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_UNNERVE_ATTEMPT);
     if (!hitAny)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
 }
 
-// Makes all POKéMON after the user nervous.
+// Makes all POK�MON after the user nervous.
 static void ContestEffect_MakeFollowingMonsNervous(void)
 {
     u8 numUnnerved = 0;
@@ -396,8 +396,8 @@ static void ContestEffect_MakeFollowingMonsNervous(void)
     memset(contestantIds, 0xFF, ARRAY_COUNT(contestantIds));
     for (i = 0, numAfter = 0; i < 4; i++)
     {
-        if (shared192D0.turnOrder[shared192D0.contestant] < shared192D0.turnOrder[i] &&
-            !sContestantStatus[i].nervous && !Contest_IsMonsTurnDisabled(i))
+        if (eContestResources8.turnOrder[eContestResources8.contestant] < eContestResources8.turnOrder[i] &&
+            !eContestantStatus[i].nervous && !Contest_IsMonsTurnDisabled(i))
             contestantIds[numAfter++] = i;
     }
 
@@ -423,11 +423,11 @@ static void ContestEffect_MakeFollowingMonsNervous(void)
     }
     for (i = 0; i < 4; i++)
     {
-        if (sContestantStatus[i].hasJudgesAttention && sub_80DE1E8(i))
-            oddsMod[i] = gComboStarterLookupTable[gContestMoves[sContestantStatus[i].prevMove].comboStarterId] * 10;
+        if (eContestantStatus[i].hasJudgesAttention && sub_80DE1E8(i))
+            oddsMod[i] = gComboStarterLookupTable[gContestMoves[eContestantStatus[i].prevMove].comboStarterId] * 10;
         else
             oddsMod[i] = 0;
-        oddsMod[i] -= (sContestantStatus[i].condition / 10) * 10;
+        oddsMod[i] -= (eContestantStatus[i].condition / 10) * 10;
     }
     if (odds[0] != 0)
     {
@@ -457,12 +457,12 @@ static void ContestEffect_MakeFollowingMonsNervous(void)
                 SetContestantEffectStringID(contestantIds[i], CONTEST_STRING_UNAFFECTED);
                 numUnnerved++;
             }
-            shared192D0.unnervedPokes[contestantIds[i]] = 1;
+            eContestResources8.unnervedPokes[contestantIds[i]] = 1;
         }
     }
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_UNNERVE_WAITING);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_UNNERVE_WAITING);
     if (numUnnerved == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
 }
 
 // Worsens the condition of those that made appeals.
@@ -473,23 +473,23 @@ static void ContestEffect_WorsenConditionOfPrevMons(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (shared192D0.turnOrder[shared192D0.contestant] > shared192D0.turnOrder[i] &&
-            sContestantStatus[i].condition > 0 &&
+        if (eContestResources8.turnOrder[eContestResources8.contestant] > eContestResources8.turnOrder[i] &&
+            eContestantStatus[i].condition > 0 &&
             CanUnnerveContestant(i))
         {
-            sContestantStatus[i].condition = 0;
-            sContestantStatus[i].conditionMod = 2;
+            eContestantStatus[i].condition = 0;
+            eContestantStatus[i].conditionMod = 2;
             SetContestantEffectStringID(i, CONTEST_STRING_REGAINED_FORM);
             numHit++;
         }
     }
 
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_TAUNT_WELL);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_TAUNT_WELL);
     if (numHit == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_IGNORED);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_IGNORED);
 }
 
-// Badly startles POKéMON in good condition.
+// Badly startles POK�MON in good condition.
 static void ContestEffect_BadlyStartlesMonsInGoodCondition(void)
 {
     u8 numHit = 0;
@@ -497,42 +497,42 @@ static void ContestEffect_BadlyStartlesMonsInGoodCondition(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (shared192D0.turnOrder[shared192D0.contestant] > shared192D0.turnOrder[i])
+        if (eContestResources8.turnOrder[eContestResources8.contestant] > eContestResources8.turnOrder[i])
         {
-            if (sContestantStatus[i].condition > 0)
-                shared192D0.jam = 40;
+            if (eContestantStatus[i].condition > 0)
+                eContestResources8.jam = 40;
             else
-                shared192D0.jam = 10;
-            shared192D0.jamQueue[0] = i;
-            shared192D0.jamQueue[1] = 0xFF;
+                eContestResources8.jam = 10;
+            eContestResources8.jamQueue[0] = i;
+            eContestResources8.jamQueue[1] = 0xFF;
             if (WasAtLeastOneOpponentJammed())
                 numHit++;
         }
     }
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_JAM_WELL);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_JAM_WELL);
     if (numHit == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_IGNORED);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_IGNORED);
 }
 
 // The appeal works great if performed first.
 static void ContestEffect_BetterIfFirst(void)
 {
-    if (gUnknown_02039F26[shared192D0.contestant] == 0)
+    if (gUnknown_02039F26[eContestResources8.contestant] == 0)
     {
-        u16 move = sContestantStatus[shared192D0.contestant].currMove;
-        sContestantStatus[shared192D0.contestant].appeal2 += 2 * gContestEffects[gContestMoves[move].effect].appeal;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_HUSTLE_STANDOUT);
+        u16 move = eContestantStatus[eContestResources8.contestant].currMove;
+        eContestantStatus[eContestResources8.contestant].appeal2 += 2 * gContestEffects[gContestMoves[move].effect].appeal;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_HUSTLE_STANDOUT);
     }
 }
 
 // The appeal works great if performed last.
 static void ContestEffect_BetterIfLast(void)
 {
-    if (gUnknown_02039F26[shared192D0.contestant] == 3)
+    if (gUnknown_02039F26[eContestResources8.contestant] == 3)
     {
-        u16 move = sContestantStatus[shared192D0.contestant].currMove;
-        sContestantStatus[shared192D0.contestant].appeal2 += 2 * gContestEffects[gContestMoves[move].effect].appeal;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_WORK_HARD_UNNOTICED);
+        u16 move = eContestantStatus[eContestResources8.contestant].currMove;
+        eContestantStatus[eContestResources8.contestant].appeal2 += 2 * gContestEffects[gContestMoves[move].effect].appeal;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_WORK_HARD_UNNOTICED);
     }
 }
 
@@ -544,22 +544,22 @@ static void ContestEffect_AppealAsGoodAsPrevOnes(void)
 
     for (i = 0, appealSum = 0; i < 4; i++)
     {
-        if (shared192D0.turnOrder[shared192D0.contestant] > shared192D0.turnOrder[i])
-            appealSum += sContestantStatus[i].appeal2;
+        if (eContestResources8.turnOrder[eContestResources8.contestant] > eContestResources8.turnOrder[i])
+            appealSum += eContestantStatus[i].appeal2;
     }
     if (appealSum < 0)
         appealSum = 0;
 
-    if (shared192D0.turnOrder[shared192D0.contestant] == 0 || appealSum == 0)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] == 0 || appealSum == 0)
     {
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_NOT_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_NOT_WELL);
     }
     else
     {
-        sContestantStatus[shared192D0.contestant].appeal2 += appealSum / 2;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_WORK_BEFORE);
+        eContestantStatus[eContestResources8.contestant].appeal2 += appealSum / 2;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_WORK_BEFORE);
     }
-    sContestantStatus[shared192D0.contestant].appeal2 = RoundTowardsZero(sContestantStatus[shared192D0.contestant].appeal2);
+    eContestantStatus[eContestResources8.contestant].appeal2 = RoundTowardsZero(eContestantStatus[eContestResources8.contestant].appeal2);
 }
 
 // Makes the appeal as good as the one before it.
@@ -567,45 +567,45 @@ static void ContestEffect_AppealAsGoodAsPrevOne(void)
 {
     s16 appeal = 0;
 
-    if (shared192D0.turnOrder[shared192D0.contestant] != 0)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] != 0)
     {
         int i;
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[shared192D0.contestant] - 1 == shared192D0.turnOrder[i])
-                appeal = sContestantStatus[i].appeal2;
+            if (eContestResources8.turnOrder[eContestResources8.contestant] - 1 == eContestResources8.turnOrder[i])
+                appeal = eContestantStatus[i].appeal2;
         }
     }
-    if (shared192D0.turnOrder[shared192D0.contestant] == 0 || appeal <= 0)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] == 0 || appeal <= 0)
     {
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_NOT_WELL2);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_NOT_WELL2);
     }
     else
     {
-        sContestantStatus[shared192D0.contestant].appeal2 += appeal;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_WORK_PRECEDING);
+        eContestantStatus[eContestResources8.contestant].appeal2 += appeal;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_WORK_PRECEDING);
     }
 }
 
 // The appeal works better the later it is performed.
 static void ContestEffect_BetterWhenLater(void)
 {
-    u8 whichTurn = shared192D0.turnOrder[shared192D0.contestant];
+    u8 whichTurn = eContestResources8.turnOrder[eContestResources8.contestant];
     if (whichTurn == 0)
-        sContestantStatus[shared192D0.contestant].appeal2 = 10;
+        eContestantStatus[eContestResources8.contestant].appeal2 = 10;
     else
-        sContestantStatus[shared192D0.contestant].appeal2 = 20 * whichTurn;
+        eContestantStatus[eContestResources8.contestant].appeal2 = 20 * whichTurn;
     if (whichTurn == 0)
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_NOT_SHOWN_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_NOT_SHOWN_WELL);
     else if (whichTurn == 1)
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_SLIGHTLY_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_SLIGHTLY_WELL);
     else if (whichTurn == 2)
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_PRETTY_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_PRETTY_WELL);
     else
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_EXCELLENTLY);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_EXCELLENTLY);
 }
 
-// The appeal’s quality varies depending on its timing.
+// The appeal�s quality varies depending on its timing.
 static void ContestEffect_QualityDependsOnTiming(void)
 {
     u8 rval = Random() % 10;
@@ -614,31 +614,31 @@ static void ContestEffect_QualityDependsOnTiming(void)
     if (rval < 3)
     {
         appeal = 10;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_NOT_VERY_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_NOT_VERY_WELL);
     } else if (rval < 6)
     {
         appeal = 20;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_SLIGHTLY_WELL2);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_SLIGHTLY_WELL2);
     } else if (rval < 8)
     {
         appeal = 40;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_PRETTY_WELL2);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_PRETTY_WELL2);
     } else if (rval < 9)
     {
         appeal = 60;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_VERY_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_VERY_WELL);
     }
     else
     {
         appeal = 80;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_EXCELLENTLY2);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_EXCELLENTLY2);
     }
-    sContestantStatus[shared192D0.contestant].appeal2 = appeal;
+    eContestantStatus[eContestResources8.contestant].appeal2 = appeal;
 }
 
 static void ContestEffect_BetterIfSameType(void)
 {
-    s8 turnOrder = shared192D0.turnOrder[shared192D0.contestant];
+    s8 turnOrder = eContestResources8.turnOrder[eContestResources8.contestant];
     s8 i = turnOrder - 1, j;
     u16 move;
 
@@ -649,10 +649,10 @@ static void ContestEffect_BetterIfSameType(void)
     {
         for (j = 0; j < 4; j++)
         {
-            if (shared192D0.turnOrder[j] == i)
+            if (eContestResources8.turnOrder[j] == i)
                 break;
         }
-        if (sContestantStatus[j].noMoreTurns || sContestantStatus[j].nervous || sContestantStatus[j].numTurnsSkipped)
+        if (eContestantStatus[j].noMoreTurns || eContestantStatus[j].nervous || eContestantStatus[j].numTurnsSkipped)
         {
             if (--i < 0)
                 return;
@@ -663,29 +663,29 @@ static void ContestEffect_BetterIfSameType(void)
         }
     }
 
-    move = sContestantStatus[shared192D0.contestant].currMove;
-    if (gContestMoves[move].contestCategory == gContestMoves[sContestantStatus[j].currMove].contestCategory)
+    move = eContestantStatus[eContestResources8.contestant].currMove;
+    if (gContestMoves[move].contestCategory == gContestMoves[eContestantStatus[j].currMove].contestCategory)
     {
-        sContestantStatus[shared192D0.contestant].appeal2 += gContestEffects[gContestMoves[move].effect].appeal * 2;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_SAME_TYPE_GOOD);
+        eContestantStatus[eContestResources8.contestant].appeal2 += gContestEffects[gContestMoves[move].effect].appeal * 2;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_SAME_TYPE_GOOD);
     }
 }
 
 // Works well if different in type than the one before.
 static void ContestEffect_BetterIfDiffType(void)
 {
-    if (shared192D0.turnOrder[shared192D0.contestant] != 0)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] != 0)
     {
-        u16 move = sContestantStatus[shared192D0.contestant].currMove;
+        u16 move = eContestantStatus[eContestResources8.contestant].currMove;
         int i;
 
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[shared192D0.contestant] - 1 == shared192D0.turnOrder[i] &&
-                gContestMoves[move].contestCategory != gContestMoves[sContestantStatus[i].currMove].contestCategory)
+            if (eContestResources8.turnOrder[eContestResources8.contestant] - 1 == eContestResources8.turnOrder[i] &&
+                gContestMoves[move].contestCategory != gContestMoves[eContestantStatus[i].currMove].contestCategory)
             {
-                sContestantStatus[shared192D0.contestant].appeal2 += gContestEffects[gContestMoves[move].effect].appeal * 2;
-                SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_DIFF_TYPE_GOOD);
+                eContestantStatus[eContestResources8.contestant].appeal2 += gContestEffects[gContestMoves[move].effect].appeal * 2;
+                SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_DIFF_TYPE_GOOD);
                 break;
             }
         }
@@ -695,52 +695,52 @@ static void ContestEffect_BetterIfDiffType(void)
 // Affected by how well the appeal in front goes.
 static void ContestEffect_AffectedByPrevAppeal(void)
 {
-    if (shared192D0.turnOrder[shared192D0.contestant] != 0)
+    if (eContestResources8.turnOrder[eContestResources8.contestant] != 0)
     {
         int i;
 
         for (i = 0; i < 4; i++)
         {
-            if (shared192D0.turnOrder[shared192D0.contestant] - 1 == shared192D0.turnOrder[i])
+            if (eContestResources8.turnOrder[eContestResources8.contestant] - 1 == eContestResources8.turnOrder[i])
             {
-                if (sContestantStatus[shared192D0.contestant].appeal2 > sContestantStatus[i].appeal2)
+                if (eContestantStatus[eContestResources8.contestant].appeal2 > eContestantStatus[i].appeal2)
                 {
-                    sContestantStatus[shared192D0.contestant].appeal2 *= 2;
-                    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_STOOD_OUT_AS_MUCH);
+                    eContestantStatus[eContestResources8.contestant].appeal2 *= 2;
+                    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_STOOD_OUT_AS_MUCH);
                 }
-                else if (sContestantStatus[shared192D0.contestant].appeal2 < sContestantStatus[i].appeal2)
+                else if (eContestantStatus[eContestResources8.contestant].appeal2 < eContestantStatus[i].appeal2)
                 {
-                    sContestantStatus[shared192D0.contestant].appeal2 = 0;
-                    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_NOT_AS_WELL);
+                    eContestantStatus[eContestResources8.contestant].appeal2 = 0;
+                    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_NOT_AS_WELL);
                 }
             }
         }
     }
 }
 
-// Ups the user’s condition. Helps prevent nervousness.
+// Ups the user�s condition. Helps prevent nervousness.
 static void ContestEffect_ImproveConditionPreventNervousness(void)
 {
-    if (sContestantStatus[shared192D0.contestant].condition < 30)
+    if (eContestantStatus[eContestResources8.contestant].condition < 30)
     {
-        sContestantStatus[shared192D0.contestant].condition += 10;
-        sContestantStatus[shared192D0.contestant].conditionMod = 1;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_CONDITION_ROSE);
+        eContestantStatus[eContestResources8.contestant].condition += 10;
+        eContestantStatus[eContestResources8.contestant].conditionMod = 1;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_CONDITION_ROSE);
     }
     else
     {
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_NO_CONDITION_IMPROVE);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_NO_CONDITION_IMPROVE);
     }
 }
 
-// The appeal works well if the user’s condition is good.
+// The appeal works well if the user�s condition is good.
 static void ContestEffect_BetterWithGoodCondition(void)
 {
-    sContestantStatus[shared192D0.contestant].appealTripleCondition = TRUE;
-    if (sContestantStatus[shared192D0.contestant].condition != 0)
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_HOT_STATUS);
+    eContestantStatus[eContestResources8.contestant].appealTripleCondition = TRUE;
+    if (eContestantStatus[eContestResources8.contestant].condition != 0)
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_HOT_STATUS);
     else
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_BAD_CONDITION_WEAK_APPEAL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_BAD_CONDITION_WEAK_APPEAL);
 }
 
 // The next appeal can be made earlier next turn.
@@ -750,20 +750,20 @@ static void ContestEffect_NextAppealEarlier(void)
     s8 j;
     u8 turnOrder[4];
 
-    if (sContest.turnNumber != 4)
+    if (eContest.turnNumber != 4)
     {
         for (i = 0; i < 4; i++)
-            turnOrder[i] = sContestantStatus[i].nextTurnOrder;
+            turnOrder[i] = eContestantStatus[i].nextTurnOrder;
 
-        turnOrder[shared192D0.contestant] = 0xFF;
+        turnOrder[eContestResources8.contestant] = 0xFF;
 
         for (i = 0; i < 4; i++)
         {
             for (j = 0; j < 4; j++)
             {
-                if (j != shared192D0.contestant &&
+                if (j != eContestResources8.contestant &&
                     i == turnOrder[j] &&
-                    turnOrder[j] == sContestantStatus[j].nextTurnOrder)
+                    turnOrder[j] == eContestantStatus[j].nextTurnOrder)
                 {
                     turnOrder[j]++;
                     break;
@@ -773,15 +773,15 @@ static void ContestEffect_NextAppealEarlier(void)
                 break;
         }
 
-        turnOrder[shared192D0.contestant] = 0;
-        sContestantStatus[shared192D0.contestant].turnOrderMod = 1;
+        turnOrder[eContestResources8.contestant] = 0;
+        eContestantStatus[eContestResources8.contestant].turnOrderMod = 1;
 
         for (i = 0; i < 4; i++)
         {
-            sContestantStatus[i].nextTurnOrder = turnOrder[i];
+            eContestantStatus[i].nextTurnOrder = turnOrder[i];
         }
-        sContestantStatus[shared192D0.contestant].turnOrderModAction = 1;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_MOVE_UP_LINE);
+        eContestantStatus[eContestResources8.contestant].turnOrderModAction = 1;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_MOVE_UP_LINE);
     }
 }
 
@@ -792,20 +792,20 @@ static void ContestEffect_NextAppealLater(void)
     s8 j;
     u8 turnOrder[4];
 
-    if (sContest.turnNumber != 4)
+    if (eContest.turnNumber != 4)
     {
         for (i = 0; i < 4; i++)
-            turnOrder[i] = sContestantStatus[i].nextTurnOrder;
+            turnOrder[i] = eContestantStatus[i].nextTurnOrder;
 
-        turnOrder[shared192D0.contestant] = 0xFF;
+        turnOrder[eContestResources8.contestant] = 0xFF;
 
         for (i = 3; i > -1; i--)
         {
             for (j = 0; j < 4; j++)
             {
-                if (j != shared192D0.contestant &&
+                if (j != eContestResources8.contestant &&
                     i == turnOrder[j] &&
-                    turnOrder[j] == sContestantStatus[j].nextTurnOrder)
+                    turnOrder[j] == eContestantStatus[j].nextTurnOrder)
                 {
                     turnOrder[j]--;
                     break;
@@ -815,19 +815,19 @@ static void ContestEffect_NextAppealLater(void)
                 break;
         }
 
-        turnOrder[shared192D0.contestant] = 3;
-        sContestantStatus[shared192D0.contestant].turnOrderMod = 1;
+        turnOrder[eContestResources8.contestant] = 3;
+        eContestantStatus[eContestResources8.contestant].turnOrderMod = 1;
 
         for (i = 0; i < 4; i++)
         {
-            sContestantStatus[i].nextTurnOrder = turnOrder[i];
+            eContestantStatus[i].nextTurnOrder = turnOrder[i];
         }
-        sContestantStatus[shared192D0.contestant].turnOrderModAction = 2;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_MOVE_BACK_LINE);
+        eContestantStatus[eContestResources8.contestant].turnOrderModAction = 2;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_MOVE_BACK_LINE);
     }
 }
 
-// Makes the next turn’s order more easily scrambled.
+// Makes the next turn�s order more easily scrambled.
 static void ContestEffect_MakeScramblingTurnOrderEasier(void)
 {
     // dummied out?
@@ -841,11 +841,11 @@ static void ContestEffect_ScrambleNextTurnOrder(void)
     u8 turnOrder[4];
     u8 unselectedContestants[4];
 
-    if (sContest.turnNumber != 4)
+    if (eContest.turnNumber != 4)
     {
         for (i = 0; i < 4; i++)
         {
-            turnOrder[i] = sContestantStatus[i].nextTurnOrder;
+            turnOrder[i] = eContestantStatus[i].nextTurnOrder;
             unselectedContestants[i] = i;
         }
 
@@ -871,24 +871,24 @@ static void ContestEffect_ScrambleNextTurnOrder(void)
 
         for (i = 0; i < 4; i++)
         {
-            sContestantStatus[i].nextTurnOrder = turnOrder[i];
-            sContestantStatus[i].turnOrderMod = 2;
+            eContestantStatus[i].nextTurnOrder = turnOrder[i];
+            eContestantStatus[i].turnOrderMod = 2;
         }
-        sContestantStatus[shared192D0.contestant].turnOrderModAction = 3;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_SCRAMBLE_ORDER);
+        eContestantStatus[eContestResources8.contestant].turnOrderModAction = 3;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_SCRAMBLE_ORDER);
     }
 }
 
 // An appeal that excites the audience in any CONTEST.
 static void ContestEffect_ExciteAudienceInAnyContest(void)
 {
-    if (gContestMoves[sContestantStatus[shared192D0.contestant].currMove].contestCategory != gSpecialVar_ContestCategory)
+    if (gContestMoves[eContestantStatus[eContestResources8.contestant].currMove].contestCategory != gSpecialVar_ContestCategory)
     {
-        sContestantStatus[shared192D0.contestant].overrideCategoryExcitementMod = TRUE;
+        eContestantStatus[eContestResources8.contestant].overrideCategoryExcitementMod = TRUE;
     }
 }
 
-// Badly startles all POKéMON that made good appeals.
+// Badly startles all POK�MON that made good appeals.
 static void ContestEffect_BadlyStartleMonsWithGoodAppeals(void)
 {
     int i;
@@ -896,24 +896,24 @@ static void ContestEffect_BadlyStartleMonsWithGoodAppeals(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (shared192D0.turnOrder[shared192D0.contestant] > shared192D0.turnOrder[i])
+        if (eContestResources8.turnOrder[eContestResources8.contestant] > eContestResources8.turnOrder[i])
         {
-            if (sContestantStatus[i].appeal2 > 0)
+            if (eContestantStatus[i].appeal2 > 0)
             {
-                shared192D0.jam = sContestantStatus[i].appeal2 / 2;
-                shared192D0.jam = RoundUp(shared192D0.jam);
+                eContestResources8.jam = eContestantStatus[i].appeal2 / 2;
+                eContestResources8.jam = RoundUp(eContestResources8.jam);
             }
             else
-                shared192D0.jam = 10;
-            shared192D0.jamQueue[0] = i;
-            shared192D0.jamQueue[1] = 0xFF;
+                eContestResources8.jam = 10;
+            eContestResources8.jamQueue[0] = i;
+            eContestResources8.jamQueue[1] = 0xFF;
             if (WasAtLeastOneOpponentJammed())
                 numJammed++;
         }
     }
     if (numJammed == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
-    SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
+    SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTEMPT_STARTLE);
 }
 
 // The appeal works best the more the crowd is excited.
@@ -921,42 +921,42 @@ static void ContestEffect_BetterWhenAudienceExcited(void)
 {
     s16 appeal;
 
-    if (sContest.applauseLevel == 0)
+    if (eContest.applauseLevel == 0)
     {
         appeal = 10;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_NOT_VERY_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_NOT_VERY_WELL);
     }
-    else if (sContest.applauseLevel == 1)
+    else if (eContest.applauseLevel == 1)
     {
         appeal = 20;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_SLIGHTLY_WELL2);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_SLIGHTLY_WELL2);
     }
-    else if (sContest.applauseLevel == 2)
+    else if (eContest.applauseLevel == 2)
     {
         appeal = 30;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_PRETTY_WELL2);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_PRETTY_WELL2);
     }
-    else if (sContest.applauseLevel == 3)
+    else if (eContest.applauseLevel == 3)
     {
         appeal = 50;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_VERY_WELL);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_VERY_WELL);
     }
     else
     {
         appeal = 60;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_APPEAL_EXCELLENTLY2);
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_APPEAL_EXCELLENTLY2);
     }
-    sContestantStatus[shared192D0.contestant].appeal2 = appeal;
+    eContestantStatus[eContestResources8.contestant].appeal2 = appeal;
 }
 
 // Temporarily stops the crowd from growing excited.
 static void ContestEffect_DontExciteAudience(void)
 {
-    if (!shared19328.excitementFrozen)
+    if (!eContestResources10.excitementFrozen)
     {
-        shared19328.excitementFrozen = TRUE;
-        shared19328.excitementFreezer = shared192D0.contestant;
-        SetContestantEffectStringID(shared192D0.contestant, CONTEST_STRING_ATTRACTED_ATTENTION);
+        eContestResources10.excitementFrozen = TRUE;
+        eContestResources10.excitementFreezer = eContestResources8.contestant;
+        SetContestantEffectStringID(eContestResources8.contestant, CONTEST_STRING_ATTRACTED_ATTENTION);
     }
 }
 
@@ -967,38 +967,38 @@ static void JamByMoveCategory(u8 category)
 
     for (i = 0; i < 4; i++)
     {
-        if (shared192D0.turnOrder[shared192D0.contestant] > shared192D0.turnOrder[i])
+        if (eContestResources8.turnOrder[eContestResources8.contestant] > eContestResources8.turnOrder[i])
         {
-            if (category == gContestMoves[sContestantStatus[i].currMove].contestCategory)
-                shared192D0.jam = 40;
+            if (category == gContestMoves[eContestantStatus[i].currMove].contestCategory)
+                eContestResources8.jam = 40;
             else
-                shared192D0.jam = 10;
-            shared192D0.jamQueue[0] = i;
-            shared192D0.jamQueue[1] = 0xFF;
+                eContestResources8.jam = 10;
+            eContestResources8.jamQueue[0] = i;
+            eContestResources8.jamQueue[1] = 0xFF;
             if (WasAtLeastOneOpponentJammed())
                 numJammed++;
         }
     }
 
     if (numJammed == 0)
-        SetContestantEffectStringID2(shared192D0.contestant, CONTEST_STRING_MESSED_UP2);
+        SetContestantEffectStringID2(eContestResources8.contestant, CONTEST_STRING_MESSED_UP2);
 }
 
 static bool8 CanUnnerveContestant(u8 i)
 {
-    shared192D0.unnervedPokes[i] = 1;
-    if (sContestantStatus[i].immune)
+    eContestResources8.unnervedPokes[i] = 1;
+    if (eContestantStatus[i].immune)
     {
         SetContestantEffectStringID(i, CONTEST_STRING_AVOID_SEEING);
         return FALSE;
     }
-    else if (sContestantStatus[i].jamSafetyCount != 0)
+    else if (eContestantStatus[i].jamSafetyCount != 0)
     {
-        sContestantStatus[i].jamSafetyCount--;
+        eContestantStatus[i].jamSafetyCount--;
         SetContestantEffectStringID(i, CONTEST_STRING_AVERT_GAZE);
         return FALSE;
     }
-    else if (!sContestantStatus[i].noMoreTurns && sContestantStatus[i].numTurnsSkipped == 0)
+    else if (!eContestantStatus[i].noMoreTurns && eContestantStatus[i].numTurnsSkipped == 0)
     {
         return TRUE;
     }
@@ -1013,32 +1013,32 @@ static bool8 WasAtLeastOneOpponentJammed(void)
     s16 jamBuffer[4] = {0};
     int i;
 
-    for (i = 0; shared192D0.jamQueue[i] != 0xFF; i++)
+    for (i = 0; eContestResources8.jamQueue[i] != 0xFF; i++)
     {
-        u8 contestant = shared192D0.jamQueue[i];
+        u8 contestant = eContestResources8.jamQueue[i];
         if (CanUnnerveContestant(contestant))
         {
-            shared192D0.jam2 = shared192D0.jam;
-            if (sContestantStatus[contestant].moreEasilyStartled)
-                shared192D0.jam2 *= 2;
-            if (sContestantStatus[contestant].resistant)
+            eContestResources8.jam2 = eContestResources8.jam;
+            if (eContestantStatus[contestant].moreEasilyStartled)
+                eContestResources8.jam2 *= 2;
+            if (eContestantStatus[contestant].resistant)
             {
-                shared192D0.jam2 = 10;
+                eContestResources8.jam2 = 10;
                 SetContestantEffectStringID(contestant, CONTEST_STRING_LITTLE_DISTRACTED);
             }
             else
             {
-                shared192D0.jam2 -= sContestantStatus[contestant].jamReduction;
-                if (shared192D0.jam2 <= 0)
+                eContestResources8.jam2 -= eContestantStatus[contestant].jamReduction;
+                if (eContestResources8.jam2 <= 0)
                 {
-                    shared192D0.jam2 = 0;
+                    eContestResources8.jam2 = 0;
                     SetContestantEffectStringID(contestant, CONTEST_STRING_NOT_FAZED);
                 }
                 else
                 {
-                    JamContestant(contestant, shared192D0.jam2);
-                    SetStartledString(contestant, shared192D0.jam2);
-                    jamBuffer[contestant] = shared192D0.jam2;
+                    JamContestant(contestant, eContestResources8.jam2);
+                    SetStartledString(contestant, eContestResources8.jam2);
+                    jamBuffer[contestant] = eContestResources8.jam2;
                 }
             }
         }
@@ -1054,8 +1054,8 @@ static bool8 WasAtLeastOneOpponentJammed(void)
 
 static void JamContestant(u8 i, u8 jam)
 {
-    sContestantStatus[i].appeal2 -= jam;
-    sContestantStatus[i].jam += jam;
+    eContestantStatus[i].appeal2 -= jam;
+    eContestantStatus[i].jam += jam;
 }
 
 static s16 RoundTowardsZero(s16 score)