From 5d393adfcc1a994f9885a2720f3a0bb29afd5a6e Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Fri, 12 Jan 2018 18:16:52 -0500
Subject: start decompiling contest_ai

---
 src/contest.c    |  10 ++---
 src/contest_ai.c | 113 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 118 insertions(+), 5 deletions(-)
 create mode 100755 src/contest_ai.c

(limited to 'src')

diff --git a/src/contest.c b/src/contest.c
index 875fe4502..6a8887fb1 100644
--- a/src/contest.c
+++ b/src/contest.c
@@ -36,8 +36,8 @@ extern u8 AreMovesContestCombo(u16, u16);  // I don't think this is a bool
 extern void sub_80C8A38(u8);
 extern void sub_80C8AD0(u8);
 extern void sub_80C8C80(u8);
-extern void sub_81288F4();
-extern u8 sub_8128944(void);
+extern void ContestAI_ResetAI();
+extern u8 ContestAI_GetActionToUse(void);
 
 extern struct MusicPlayerInfo gMPlay_SE1;
 extern u16 gSpecialVar_ContestCategory;
@@ -391,7 +391,7 @@ void ClearContestVars(void)
     }
 
     memset(&shared192D0, 0, sizeof(shared192D0));
-    memset(shared192E4, 0, 0x44 * sizeof(*shared192E4));
+    memset(eContestAI, 0, sizeof(struct ContestAIInfo));
     memset(&shared19328, 0, sizeof(shared19328));
     memset(shared19338, 0, 4 * sizeof(*shared19338));
     if (!(gIsLinkContest & 1))
@@ -2629,8 +2629,8 @@ u16 GetChosenMove(u8 a)
     {
         u8 moveChoice;
 
-        sub_81288F4(a);
-        moveChoice = sub_8128944();
+        ContestAI_ResetAI(a);
+        moveChoice = ContestAI_GetActionToUse();
         return gContestMons[a].moves[moveChoice];
     }
 }
diff --git a/src/contest_ai.c b/src/contest_ai.c
new file mode 100755
index 000000000..9dfa6c2b9
--- /dev/null
+++ b/src/contest_ai.c
@@ -0,0 +1,113 @@
+#include "global.h"
+#include "contest.h"
+#include "random.h"
+#include "ewram.h"
+
+enum
+{
+    ContestAI_SettingUp,
+    ContestAI_Processing,
+    ContestAI_FinishedProcessing,
+    ContestAI_DoNotProcess
+};
+
+extern u8 *gAIScriptPtr;
+extern u8 *gContestAIs[];
+
+typedef void (* ContestAICmdFunc)(void);
+
+extern const ContestAICmdFunc sContestAICmdTable[]; // TODO: Move table to C file
+
+void ContestAI_DoAIProcessing(void);
+
+void ContestAI_ResetAI(u8 var)
+{
+    int i;
+    memset(eContestAI, 0, sizeof(struct ContestAIInfo));
+
+    for(i = 0; i < 4; i++)
+        eContestAI->unk5[i] = 100;
+
+    eContestAI->unk41 = var;
+    eContestAI->unk40 = 0;
+    eContestAI->flags = gContestMons[eContestAI->unk41].flags;
+}
+
+u8 ContestAI_GetActionToUse(void)
+{
+    while(eContestAI->flags != 0)
+    {
+        if(eContestAI->flags & 1)
+        {
+            eContestAI->aiState = 0;
+            ContestAI_DoAIProcessing();
+        }
+        eContestAI->flags >>= 1;
+        eContestAI->unk10++;
+        eContestAI->unk4 = 0;
+    }
+
+    while (1)
+    {
+        u8 rval = Random() & 3;
+        u8 r2 = eContestAI->unk5[rval];
+        int i;
+        for (i = 0; i < 4; i++)
+        {
+            if (r2 < eContestAI->unk5[i])
+                break;
+        }
+        if (i == 4)
+            return rval;
+    }
+}
+
+void ContestAI_DoAIProcessing(void)
+{
+    while(eContestAI->aiState != ContestAI_FinishedProcessing)
+    {
+        switch(eContestAI->aiState)
+        {
+            case ContestAI_DoNotProcess:
+                break;
+            case ContestAI_SettingUp:
+                gAIScriptPtr = gContestAIs[eContestAI->unk10];
+
+                if(gContestMons[eContestAI->unk41].moves[eContestAI->unk4] == 0)
+                    eContestAI->unk2 = 0; // don't process a move that doesn't exist.
+                else
+                    eContestAI->unk2 = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+                eContestAI->aiState++;
+                break;
+            case ContestAI_Processing:
+                if(eContestAI->unk2 != 0)
+                    sContestAICmdTable[*gAIScriptPtr](); // run the command.
+                else
+                {
+                    eContestAI->unk5[eContestAI->unk4] = 0; // don't consider a move that doesn't exist.
+                    eContestAI->aiAction |= 1;
+                }
+                if(eContestAI->aiAction & 1)
+                {
+                    eContestAI->unk4++;
+                    if(eContestAI->unk4 < 4)
+                        eContestAI->aiState = 0;
+                    else
+                        eContestAI->aiState++;
+                    eContestAI->aiAction &= 0xFE; // TODO: Define action flags
+                }
+                break;
+        }
+    }
+}
+
+u8 sub_8128A7C(u8 var)
+{
+    int i;
+
+    for(i = 0; i < 4; i++)
+        if(shared192D0.unk0[i] == var)
+            break;
+
+    return i;
+}
-- 
cgit v1.2.3


From fdeee269791ba9e163f32522d44526b0e2b58f29 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Fri, 12 Jan 2018 20:44:49 -0500
Subject: up to ContestAICmd_unk_14

---
 src/contest_ai.c | 198 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 198 insertions(+)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 9dfa6c2b9..124ec6357 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -111,3 +111,201 @@ u8 sub_8128A7C(u8 var)
 
     return i;
 }
+
+void ContestAICmd_unk_00(void)
+{
+    s16 score = eContestAI->unk5[eContestAI->unk4] + (s8)gAIScriptPtr[1];
+
+    if (score > 255)
+        score = 255;
+    else if (score < 0)
+        score = 0;
+
+    eContestAI->unk5[eContestAI->unk4] = score;
+
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_get_turn(void)
+{
+    eContestAI->scriptResult = sContest.turnNumber;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_02(void)
+{
+    ContestAICmd_get_turn();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_03(void)
+{
+    ContestAICmd_get_turn();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_04(void)
+{
+    ContestAICmd_get_turn();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_05(void)
+{
+    ContestAICmd_get_turn();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_excitement(void)
+{
+    eContestAI->scriptResult = sContest.applauseLevel;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_07(void)
+{
+    ContestAICmd_get_excitement();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_08(void)
+{
+    ContestAICmd_get_excitement();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_09(void)
+{
+    ContestAICmd_get_excitement();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_0A(void)
+{
+    ContestAICmd_get_excitement();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_user_order(void)
+{
+    eContestAI->scriptResult = shared192D0.unk0[eContestAI->unk41];
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_0C(void)
+{
+    ContestAICmd_get_user_order();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_0D(void)
+{
+    ContestAICmd_get_user_order();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_0E(void)
+{
+    ContestAICmd_get_user_order();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_0F(void)
+{
+    ContestAICmd_get_user_order();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_user_condition_maybe(void)
+{
+    eContestAI->scriptResult = sContestantStatus[eContestAI->unk41].unkD / 10;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_11(void)
+{
+    ContestAICmd_get_user_condition_maybe();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_12(void)
+{
+    ContestAICmd_get_user_condition_maybe();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_13(void)
+{
+    ContestAICmd_get_user_condition_maybe();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_14(void)
+{
+    ContestAICmd_get_user_condition_maybe();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
-- 
cgit v1.2.3


From e33a9b2b535b401a47455065dd4cb9364ed9c9f7 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Fri, 12 Jan 2018 22:48:47 -0500
Subject: up to ContestAICmd_unk_2C

---
 src/contest_ai.c | 223 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 223 insertions(+)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 124ec6357..3ddac5550 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -11,6 +11,9 @@ enum
     ContestAI_DoNotProcess
 };
 
+extern s16 gUnknown_02038670[];
+extern u16 gSpecialVar_ContestCategory;
+
 extern u8 *gAIScriptPtr;
 extern u8 *gContestAIs[];
 
@@ -309,3 +312,223 @@ void ContestAICmd_unk_14(void)
     else
         gAIScriptPtr += 5;
 }
+
+void ContestAICmd_unk_15(void)
+{
+    eContestAI->scriptResult = sContestantStatus[eContestAI->unk41].unk4;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_16(void)
+{
+    ContestAICmd_unk_15();
+
+    if((s16)eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_17(void)
+{
+    ContestAICmd_unk_15();
+
+    if((s16)eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_18(void)
+{
+    ContestAICmd_unk_15();
+
+    if((s16)eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_19(void)
+{
+    ContestAICmd_unk_15();
+
+    if((s16)eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_1A(void)
+{
+    eContestAI->scriptResult = gUnknown_02038670[eContestAI->unk41];
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_1B(void)
+{
+    ContestAICmd_unk_1A();
+
+    if((s16)eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_1C(void)
+{
+    ContestAICmd_unk_1A();
+
+    if((s16)eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_1D(void)
+{
+    ContestAICmd_unk_1A();
+
+    if((s16)eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_1E(void)
+{
+    ContestAICmd_unk_1A();
+
+    if((s16)eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_get_contest_type(void)
+{
+    eContestAI->scriptResult = gSpecialVar_ContestCategory;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_20(void)
+{
+    ContestAICmd_get_contest_type();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_21(void)
+{
+    ContestAICmd_get_contest_type();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_move_excitement(void)
+{
+    eContestAI->scriptResult = Contest_GetMoveExcitement(gContestMons[eContestAI->unk41].moves[eContestAI->unk4]);
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_23(void)
+{
+    ContestAICmd_get_move_excitement();
+
+    if((s16)eContestAI->scriptResult < (s8)gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_24(void)
+{
+    ContestAICmd_get_move_excitement();
+
+    if((s16)eContestAI->scriptResult > (s8)gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_25(void)
+{
+    ContestAICmd_get_move_excitement();
+
+    if((s16)eContestAI->scriptResult == (s8)gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_26(void)
+{
+    ContestAICmd_get_move_excitement();
+
+    if((s16)eContestAI->scriptResult != (s8)gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_move_effect(void)
+{
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    eContestAI->scriptResult = gContestMoves[move].effect;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_28(void)
+{
+    ContestAICmd_get_move_effect();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_29(void)
+{
+    ContestAICmd_get_move_effect();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_move_effect_type(void)
+{
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].effectType;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_2B(void)
+{
+    ContestAICmd_get_move_effect_type();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_2C(void)
+{
+    ContestAICmd_get_move_effect_type();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
-- 
cgit v1.2.3


From 39575a7e6c15bc0d69f990fe1b9c3492f684c15e Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sat, 13 Jan 2018 01:11:13 -0500
Subject: up to ContestAICmd_unk_3F

---
 src/contest_ai.c | 212 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 212 insertions(+)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 3ddac5550..2fce17cbe 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -532,3 +532,215 @@ void ContestAICmd_unk_2C(void)
     else
         gAIScriptPtr += 5;
 }
+
+void ContestAICmd_check_move_has_highest_appeal(void)
+{
+    int i;
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+    u8 appeal = gContestEffects[gContestMoves[move].effect].appeal;
+
+    for(i = 0; i < 4; i++)
+    {
+        u16 newMove = gContestMons[eContestAI->unk41].moves[i];
+        if(newMove != 0 && appeal < gContestEffects[gContestMoves[newMove].effect].appeal)
+            break;
+    }
+
+    if(i == 4)
+        eContestAI->scriptResult = TRUE;
+    else
+        eContestAI->scriptResult = FALSE;
+
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_2E(void)
+{
+    ContestAICmd_check_move_has_highest_appeal();
+
+    if((s16)eContestAI->scriptResult != FALSE)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_2F(void)
+{
+    int i;
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+    u8 jam = gContestEffects[gContestMoves[move].effect].jam;
+
+    for(i = 0; i < 4; i++)
+    {
+        u16 newMove = gContestMons[eContestAI->unk41].moves[i];
+        if(newMove != 0 && jam < gContestEffects[gContestMoves[newMove].effect].jam)
+            break;
+    }
+
+    if(i == 4)
+        eContestAI->scriptResult = TRUE;
+    else
+        eContestAI->scriptResult = FALSE;
+
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_30(void)
+{
+    ContestAICmd_unk_2F();
+
+    if((s16)eContestAI->scriptResult != FALSE)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_31(void)
+{
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].appeal / 10;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_32(void)
+{
+    ContestAICmd_unk_31();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_33(void)
+{
+    ContestAICmd_unk_31();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_34(void)
+{
+    ContestAICmd_unk_31();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_35(void)
+{
+    ContestAICmd_unk_31();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_36(void)
+{
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].jam / 10;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_37(void)
+{
+    ContestAICmd_unk_36();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_38(void)
+{
+    ContestAICmd_unk_36();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_39(void)
+{
+    ContestAICmd_unk_36();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_3A(void)
+{
+    ContestAICmd_unk_36();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_move_used_count(void)
+{
+    s16 result;
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    if(move != sContestantStatus[eContestAI->unk41].prevMove)
+        result = 0; // move is unique and not reused.
+    else
+        result = sContestantStatus[eContestAI->unk41].moveRepeatCount + 1;
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_3C(void)
+{
+    ContestAICmd_get_move_used_count();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_3D(void)
+{
+    ContestAICmd_get_move_used_count();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_3E(void)
+{
+    ContestAICmd_get_move_used_count();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_3F(void)
+{
+    ContestAICmd_get_move_used_count();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
-- 
cgit v1.2.3


From 82e7961ec47071b4259fdaea16ee2707907b1143 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sat, 13 Jan 2018 02:39:10 -0500
Subject: up to ContestAICmd_unk_3F

---
 src/contest_ai.c | 94 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 94 insertions(+)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 2fce17cbe..a62a69194 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -744,3 +744,97 @@ void ContestAICmd_unk_3F(void)
     else
         gAIScriptPtr += 5;
 }
+
+extern u8 AreMovesContestCombo(u16, u16);
+
+/*
+void ContestAICmd_check_combo_starter(void)
+{
+    u8 result = 0;
+    int i;
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    for(i = 0; i < 4; i++)
+    {
+        u16 newMove = gContestMons[eContestAI->unk41].moves[i];
+        u16 isCombo = AreMovesContestCombo(move, gContestMons[eContestAI->unk41].moves[i]);
+        if(newMove && isCombo)
+        {
+            result = 1;
+            break;
+        }
+        if(isCombo) // dumb double r5 check?
+        {
+            result = 1;
+            break;
+        }
+    }
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 1;
+}*/
+
+/*
+    thumb_func_start ContestAICmd_check_combo_starter
+ContestAICmd_check_combo_starter: @ 8129B44
+    push {r4-r7,lr}
+    mov r7, r8
+    push {r7}
+    movs r5, 0
+    ldr r3, _08129BAC @ =gContestMons
+    ldr r2, _08129BB0 @ =gSharedMem + 0x192E4
+    ldrb r1, [r2, 0x4]
+    lsls r1, 1
+    adds r2, 0x41
+    ldrb r0, [r2]
+    lsls r0, 6
+    adds r1, r0
+    adds r3, 0x1E
+    adds r1, r3
+    ldrh r6, [r1]
+    movs r4, 0
+    mov r8, r2
+    adds r7, r3, 0
+_08129B68:
+    lsls r0, r4, 1
+    mov r2, r8
+    ldrb r1, [r2]
+    lsls r1, 6
+    adds r0, r1
+    adds r1, r0, r7
+    ldrh r0, [r1]
+    cmp r0, 0
+    beq _08129B8A
+    adds r1, r0, 0
+    adds r0, r6, 0
+    bl AreMovesContestCombo
+    lsls r0, 24
+    lsrs r5, r0, 24
+    cmp r5, 0
+    bne _08129B94
+_08129B8A:
+    adds r4, 0x1
+    cmp r4, 0x3
+    ble _08129B68
+    cmp r5, 0
+    beq _08129B96
+_08129B94:
+    movs r5, 0x1
+_08129B96:
+    ldr r0, _08129BB0 @ =gSharedMem + 0x192E4
+    strh r5, [r0, 0x18]
+    ldr r1, _08129BB4 @ =gAIScriptPtr
+    ldr r0, [r1]
+    adds r0, 0x1
+    str r0, [r1]
+    pop {r3}
+    mov r8, r3
+    pop {r4-r7}
+    pop {r0}
+    bx r0
+    .align 2, 0
+_08129BAC: .4byte gContestMons
+_08129BB0: .4byte gSharedMem + 0x192E4
+_08129BB4: .4byte gAIScriptPtr
+    thumb_func_end ContestAICmd_check_combo_starter
+*/
-- 
cgit v1.2.3


From e0f8841fbd434c06bba7471566629e197b896957 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sat, 13 Jan 2018 23:43:36 -0500
Subject: up to ContestAICmd_unk_52

---
 src/contest_ai.c | 291 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 214 insertions(+), 77 deletions(-)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index a62a69194..7c704be0a 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -3,6 +3,10 @@
 #include "random.h"
 #include "ewram.h"
 
+extern u8 AreMovesContestCombo(u16, u16);
+extern bool8 sub_8128A7C(u8);
+extern bool8 sub_80B214C(u8);
+
 enum
 {
     ContestAI_SettingUp,
@@ -745,9 +749,6 @@ void ContestAICmd_unk_3F(void)
         gAIScriptPtr += 5;
 }
 
-extern u8 AreMovesContestCombo(u16, u16);
-
-/*
 void ContestAICmd_check_combo_starter(void)
 {
     u8 result = 0;
@@ -756,85 +757,221 @@ void ContestAICmd_check_combo_starter(void)
 
     for(i = 0; i < 4; i++)
     {
-        u16 newMove = gContestMons[eContestAI->unk41].moves[i];
-        u16 isCombo = AreMovesContestCombo(move, gContestMons[eContestAI->unk41].moves[i]);
-        if(newMove && isCombo)
+        if (gContestMons[eContestAI->unk41].moves[i])
         {
-            result = 1;
-            break;
+            result = AreMovesContestCombo(move, gContestMons[eContestAI->unk41].moves[i]);
+            if (result)
+            {
+                result = 1;
+                break;
+            }
         }
-        if(isCombo) // dumb double r5 check?
+    }
+
+    if (result)
+        result = 1;
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_41(void)
+{
+    ContestAICmd_check_combo_starter();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_42(void)
+{
+    ContestAICmd_check_combo_starter();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_check_combo_finisher(void)
+{
+    u8 result = 0;
+    int i;
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    for(i = 0; i < 4; i++)
+    {
+        if (gContestMons[eContestAI->unk41].moves[i])
         {
-            result = 1;
-            break;
+            result = AreMovesContestCombo(gContestMons[eContestAI->unk41].moves[i], move);
+            if (result)
+            {
+                result = 1;
+                break;
+            }
         }
     }
 
+    if (result)
+        result = 1;
+
     eContestAI->scriptResult = result;
     gAIScriptPtr += 1;
-}*/
-
-/*
-    thumb_func_start ContestAICmd_check_combo_starter
-ContestAICmd_check_combo_starter: @ 8129B44
-    push {r4-r7,lr}
-    mov r7, r8
-    push {r7}
-    movs r5, 0
-    ldr r3, _08129BAC @ =gContestMons
-    ldr r2, _08129BB0 @ =gSharedMem + 0x192E4
-    ldrb r1, [r2, 0x4]
-    lsls r1, 1
-    adds r2, 0x41
-    ldrb r0, [r2]
-    lsls r0, 6
-    adds r1, r0
-    adds r3, 0x1E
-    adds r1, r3
-    ldrh r6, [r1]
-    movs r4, 0
-    mov r8, r2
-    adds r7, r3, 0
-_08129B68:
-    lsls r0, r4, 1
-    mov r2, r8
-    ldrb r1, [r2]
-    lsls r1, 6
-    adds r0, r1
-    adds r1, r0, r7
-    ldrh r0, [r1]
-    cmp r0, 0
-    beq _08129B8A
-    adds r1, r0, 0
-    adds r0, r6, 0
-    bl AreMovesContestCombo
-    lsls r0, 24
-    lsrs r5, r0, 24
-    cmp r5, 0
-    bne _08129B94
-_08129B8A:
-    adds r4, 0x1
-    cmp r4, 0x3
-    ble _08129B68
-    cmp r5, 0
-    beq _08129B96
-_08129B94:
-    movs r5, 0x1
-_08129B96:
-    ldr r0, _08129BB0 @ =gSharedMem + 0x192E4
-    strh r5, [r0, 0x18]
-    ldr r1, _08129BB4 @ =gAIScriptPtr
-    ldr r0, [r1]
-    adds r0, 0x1
-    str r0, [r1]
-    pop {r3}
-    mov r8, r3
-    pop {r4-r7}
-    pop {r0}
-    bx r0
-    .align 2, 0
-_08129BAC: .4byte gContestMons
-_08129BB0: .4byte gSharedMem + 0x192E4
-_08129BB4: .4byte gAIScriptPtr
-    thumb_func_end ContestAICmd_check_combo_starter
-*/
+}
+
+void ContestAICmd_unk_44(void)
+{
+    ContestAICmd_check_combo_finisher();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_45(void)
+{
+    ContestAICmd_check_combo_finisher();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_check_would_finish_combo(void)
+{
+    u8 result = 0;
+    u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
+
+    if(sContestantStatus[eContestAI->unk41].prevMove)
+        result = AreMovesContestCombo(sContestantStatus[eContestAI->unk41].prevMove, move);
+    
+    if(result)
+        result = 1;
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_47(void)
+{
+    ContestAICmd_check_would_finish_combo();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_48(void)
+{
+    ContestAICmd_check_would_finish_combo();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_get_condition(void)
+{
+    int var = sub_8128A7C(gAIScriptPtr[1]);
+
+    eContestAI->scriptResult = sContestantStatus[var].unkD / 10;
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_unk_4A(void)
+{
+    ContestAICmd_get_condition();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_4B(void)
+{
+    ContestAICmd_get_condition();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_4C(void)
+{
+    ContestAICmd_get_condition();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_4D(void)
+{
+    ContestAICmd_get_condition();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_get_used_combo_starter(void)
+{
+    u16 result = 0;
+    u8 var = sub_8128A7C(gAIScriptPtr[1]);
+
+    if(sub_80B214C(var))
+        result = gContestMoves[sContestantStatus[var].prevMove].comboStarterId ? 1 : 0;
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_unk_4F(void)
+{
+    ContestAICmd_get_used_combo_starter();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_50(void)
+{
+    ContestAICmd_get_used_combo_starter();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_51(void)
+{
+    ContestAICmd_get_used_combo_starter();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_52(void)
+{
+    ContestAICmd_get_used_combo_starter();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
-- 
cgit v1.2.3


From 74f4ece9184fc388528a775bd31f2cd4d3efe626 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sun, 14 Jan 2018 02:05:32 -0500
Subject: up to ContestAICmd_unk_67

---
 src/contest_ai.c | 205 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 205 insertions(+)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 7c704be0a..037564a9b 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -6,6 +6,7 @@
 extern u8 AreMovesContestCombo(u16, u16);
 extern bool8 sub_8128A7C(u8);
 extern bool8 sub_80B214C(u8);
+extern bool8 Contest_IsMonsTurnDisabled(u8);
 
 enum
 {
@@ -975,3 +976,207 @@ void ContestAICmd_unk_52(void)
     else
         gAIScriptPtr += 5;
 }
+
+void ContestAICmd_check_can_participate(void)
+{
+    if(Contest_IsMonsTurnDisabled(sub_8128A7C(gAIScriptPtr[1])))
+        eContestAI->scriptResult = FALSE;
+    else
+        eContestAI->scriptResult = TRUE;
+
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_unk_54(void)
+{
+    ContestAICmd_check_can_participate();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_55(void)
+{
+    ContestAICmd_check_can_participate();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_get_val_812A188(void)
+{
+    u8 var = sub_8128A7C(gAIScriptPtr[1]);
+
+    eContestAI->scriptResult = sContestantStatus[var].unk15_3;
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_unk_57(void)
+{
+    ContestAICmd_get_val_812A188();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_58(void)
+{
+    ContestAICmd_get_val_812A188();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_59(void)
+{
+    u8 var = sub_8128A7C(gAIScriptPtr[1]);
+
+    eContestAI->scriptResult = sContestantStatus[var].unk4 - sContestantStatus[eContestAI->unk41].unk4;
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_unk_5A(void)
+{
+    ContestAICmd_unk_59();
+
+    if((s16)eContestAI->scriptResult < 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_5B(void)
+{
+    ContestAICmd_unk_59();
+
+    if((s16)eContestAI->scriptResult > 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_5C(void)
+{
+    ContestAICmd_unk_59();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_5D(void)
+{
+    ContestAICmd_unk_59();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_5E(void)
+{
+    u8 var = sub_8128A7C(gAIScriptPtr[1]);
+
+    eContestAI->scriptResult = gUnknown_02038670[var] - gUnknown_02038670[eContestAI->unk41];
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_unk_5F(void)
+{
+    ContestAICmd_unk_5E();
+
+    if((s16)eContestAI->scriptResult < 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_60(void)
+{
+    ContestAICmd_unk_5E();
+
+    if((s16)eContestAI->scriptResult > 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_61(void)
+{
+    ContestAICmd_unk_5E();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_62(void)
+{
+    ContestAICmd_unk_5E();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_63(void)
+{
+    u8 var = sub_8128A7C(gAIScriptPtr[1]);
+    u8 var2 = gAIScriptPtr[2];
+    u16 move = sContest.unk19220[var2][var];
+
+    eContestAI->scriptResult = gContestMoves[move].effect;
+    gAIScriptPtr += 3;
+}
+
+void ContestAICmd_unk_64(void)
+{
+    ContestAICmd_unk_63();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_65(void)
+{
+    ContestAICmd_unk_63();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_66(void)
+{
+    ContestAICmd_unk_63();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_67(void)
+{
+    ContestAICmd_unk_63();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
-- 
cgit v1.2.3


From bc2abc39f6a8b47e844136a43fbc729eb5568833 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sun, 14 Jan 2018 04:46:09 -0500
Subject: up to ContestAICmd_unk_7E

---
 src/contest_ai.c | 191 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 191 insertions(+)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 037564a9b..3fc7cec3b 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -1180,3 +1180,194 @@ void ContestAICmd_unk_67(void)
     else
         gAIScriptPtr += 5;
 }
+
+void ContestAICmd_unk_68(void)
+{
+    u8 var = sub_8128A7C(gAIScriptPtr[1]);
+    u8 var2 = gAIScriptPtr[2];
+    s8 result = sContest.unk19248[var2][var];
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 3;
+}
+
+void ContestAICmd_unk_69(void)
+{
+    ContestAICmd_unk_68();
+
+    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_6A(void)
+{
+    ContestAICmd_unk_68();
+
+    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_6B(void)
+{
+    ContestAICmd_unk_68();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_6C(void)
+{
+    ContestAICmd_unk_68();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_6D(void)
+{
+    u8 var = sub_8128A7C(gAIScriptPtr[1]);
+    u8 var2 = gAIScriptPtr[2];
+    u16 move = sContest.unk19220[var2][var];
+
+    eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].effectType;
+    gAIScriptPtr += 3;
+}
+
+void ContestAICmd_unk_6E(void)
+{
+    ContestAICmd_unk_6D();
+
+    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_6F(void)
+{
+    ContestAICmd_unk_6D();
+
+    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+    else
+        gAIScriptPtr += 5;
+}
+
+void ContestAICmd_unk_70(void)
+{
+    eContestAI->scriptArr[gAIScriptPtr[1]] = eContestAI->scriptResult;
+    gAIScriptPtr += 2;
+}
+
+void ContestAICmd_unk_71(void)
+{
+    eContestAI->scriptArr[gAIScriptPtr[1]] = T1_READ_16(gAIScriptPtr + 2);
+    gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_72(void)
+{
+    // wtf? shouldn't T1_READ_16 work here? why the signed 8 load by gAIScriptPtr[2]?
+    eContestAI->scriptArr[gAIScriptPtr[1]] += ((s8)gAIScriptPtr[2] | gAIScriptPtr[3] << 8);
+    gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_73(void)
+{
+    eContestAI->scriptArr[gAIScriptPtr[1]] += eContestAI->scriptArr[gAIScriptPtr[2]];
+    gAIScriptPtr += 3;
+}
+
+void ContestAICmd_unk_74(void)
+{
+    eContestAI->scriptArr[gAIScriptPtr[1]] += eContestAI->scriptArr[gAIScriptPtr[2]];
+    gAIScriptPtr += 3;
+}
+
+void ContestAICmd_unk_75(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] < T1_READ_16(gAIScriptPtr + 2))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    else
+        gAIScriptPtr += 8;
+}
+
+void ContestAICmd_unk_76(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] > T1_READ_16(gAIScriptPtr + 2))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    else
+        gAIScriptPtr += 8;
+}
+
+void ContestAICmd_unk_77(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] == T1_READ_16(gAIScriptPtr + 2))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    else
+        gAIScriptPtr += 8;
+}
+
+void ContestAICmd_unk_78(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] != T1_READ_16(gAIScriptPtr + 2))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+    else
+        gAIScriptPtr += 8;
+}
+
+void ContestAICmd_unk_79(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] < ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    else
+        gAIScriptPtr += 7;
+}
+
+void ContestAICmd_unk_7A(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] > ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    else
+        gAIScriptPtr += 7;
+}
+
+void ContestAICmd_unk_7B(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] == ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    else
+        gAIScriptPtr += 7;
+}
+
+void ContestAICmd_unk_7C(void)
+{
+    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] != ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+    else
+        gAIScriptPtr += 7;
+}
+
+void ContestAICmd_unk_7D(void)
+{
+    if((Random() & 0xFF) < (s16)eContestAI->scriptArr[gAIScriptPtr[1]])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
+
+void ContestAICmd_unk_7E(void)
+{
+    if((Random() & 0xFF) > (s16)eContestAI->scriptArr[gAIScriptPtr[1]])
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+    else
+        gAIScriptPtr += 6;
+}
-- 
cgit v1.2.3


From 99d4f3c24a600af8dadfe921f127f68d0bd4f2c3 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sun, 14 Jan 2018 12:48:52 -0500
Subject: finish decompiling contest_ai.c

---
 src/contest_ai.c | 122 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 122 insertions(+)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 3fc7cec3b..ea0435775 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -27,6 +27,8 @@ typedef void (* ContestAICmdFunc)(void);
 extern const ContestAICmdFunc sContestAICmdTable[]; // TODO: Move table to C file
 
 void ContestAI_DoAIProcessing(void);
+void sub_812ACA4(u8 *);
+u8 sub_812ACC8(void);
 
 void ContestAI_ResetAI(u8 var)
 {
@@ -1371,3 +1373,123 @@ void ContestAICmd_unk_7E(void)
     else
         gAIScriptPtr += 6;
 }
+
+// jump
+void ContestAICmd_unk_7F(void)
+{
+    gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+}
+
+void ContestAICmd_unk_80(void)
+{
+    sub_812ACA4(gAIScriptPtr + 5);
+    gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+}
+
+void ContestAICmd_unk_81(void)
+{
+    if(!sub_812ACC8())
+        eContestAI->aiAction |= 1;
+}
+
+// push stack?
+void sub_812ACA4(u8 *ptr)
+{
+    u8 unk40 = eContestAI->unk40++;
+    eContestAI->stack[unk40] = (u32)ptr;
+}
+
+// pop stack?
+bool8 sub_812ACC8(void)
+{
+    if(eContestAI->unk40 != 0)
+    {
+        --eContestAI->unk40;
+        gAIScriptPtr = (u8 *)eContestAI->stack[eContestAI->unk40];
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+void ContestAICmd_check_for_exciting_move(void)
+{
+    int result = 0;
+    int i;
+
+    for(i = 0; i < 4; i++)
+    {
+        if(gContestMons[eContestAI->unk41].moves[i])
+        {
+            // why is it using gSharedMem + 0x19325? that does not exist...
+            if(Contest_GetMoveExcitement(gContestMons[eContestAI->unk41].moves[i]) == 1)
+            {
+                result = 1;
+                break;
+            }
+        }
+    }
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 1;
+}
+
+void ContestAICmd_unk_83(void)
+{
+    ContestAICmd_check_for_exciting_move();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_84(void)
+{
+    ContestAICmd_check_for_exciting_move();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_85(void)
+{
+    int result = 0;
+    int i;
+    u16 arg = T1_READ_16(gAIScriptPtr + 1);
+    
+    for(i = 0; i < 4; i++)
+    {
+        u16 move = gContestMons[eContestAI->unk41].moves[i];
+        if(move == arg)
+        {
+            result = 1;
+            break;
+        }
+    }
+
+    eContestAI->scriptResult = result;
+    gAIScriptPtr += 3;
+}
+
+void ContestAICmd_unk_86(void)
+{
+    ContestAICmd_unk_85();
+
+    if((s16)eContestAI->scriptResult != 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
+
+void ContestAICmd_unk_87(void)
+{
+    ContestAICmd_unk_85();
+
+    if((s16)eContestAI->scriptResult == 0)
+        gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
+    else
+        gAIScriptPtr += 4;
+}
-- 
cgit v1.2.3


From 8990b10732827087e04a2a02632769b252baaff6 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sun, 14 Jan 2018 13:19:30 -0500
Subject: move rodata to C

---
 src/contest_ai.c | 565 +++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 420 insertions(+), 145 deletions(-)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index ea0435775..f8f2812fb 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -4,7 +4,6 @@
 #include "ewram.h"
 
 extern u8 AreMovesContestCombo(u16, u16);
-extern bool8 sub_8128A7C(u8);
 extern bool8 sub_80B214C(u8);
 extern bool8 Contest_IsMonsTurnDisabled(u8);
 
@@ -22,13 +21,289 @@ extern u16 gSpecialVar_ContestCategory;
 extern u8 *gAIScriptPtr;
 extern u8 *gContestAIs[];
 
+static void ContestAICmd_unk_00(void);
+static void ContestAICmd_get_turn(void);
+static void ContestAICmd_unk_02(void);
+static void ContestAICmd_unk_03(void);
+static void ContestAICmd_unk_04(void);
+static void ContestAICmd_unk_05(void);
+static void ContestAICmd_get_excitement(void);
+static void ContestAICmd_unk_07(void);
+static void ContestAICmd_unk_08(void);
+static void ContestAICmd_unk_09(void);
+static void ContestAICmd_unk_0A(void);
+static void ContestAICmd_get_user_order(void);
+static void ContestAICmd_unk_0C(void);
+static void ContestAICmd_unk_0D(void);
+static void ContestAICmd_unk_0E(void);
+static void ContestAICmd_unk_0F(void);
+static void ContestAICmd_get_user_condition_maybe(void);
+static void ContestAICmd_unk_11(void);
+static void ContestAICmd_unk_12(void);
+static void ContestAICmd_unk_13(void);
+static void ContestAICmd_unk_14(void);
+static void ContestAICmd_unk_15(void);
+static void ContestAICmd_unk_16(void);
+static void ContestAICmd_unk_17(void);
+static void ContestAICmd_unk_18(void);
+static void ContestAICmd_unk_19(void);
+static void ContestAICmd_unk_1A(void);
+static void ContestAICmd_unk_1B(void);
+static void ContestAICmd_unk_1C(void);
+static void ContestAICmd_unk_1D(void);
+static void ContestAICmd_unk_1E(void);
+static void ContestAICmd_get_contest_type(void);
+static void ContestAICmd_unk_20(void);
+static void ContestAICmd_unk_21(void);
+static void ContestAICmd_get_move_excitement(void);
+static void ContestAICmd_unk_23(void);
+static void ContestAICmd_unk_24(void);
+static void ContestAICmd_unk_25(void);
+static void ContestAICmd_unk_26(void);
+static void ContestAICmd_get_move_effect(void);
+static void ContestAICmd_unk_28(void);
+static void ContestAICmd_unk_29(void);
+static void ContestAICmd_get_move_effect_type(void);
+static void ContestAICmd_unk_2B(void);
+static void ContestAICmd_unk_2C(void);
+static void ContestAICmd_check_move_has_highest_appeal(void);
+static void ContestAICmd_unk_2E(void);
+static void ContestAICmd_unk_2F(void);
+static void ContestAICmd_unk_30(void);
+static void ContestAICmd_unk_31(void);
+static void ContestAICmd_unk_32(void);
+static void ContestAICmd_unk_33(void);
+static void ContestAICmd_unk_34(void);
+static void ContestAICmd_unk_35(void);
+static void ContestAICmd_unk_36(void);
+static void ContestAICmd_unk_37(void);
+static void ContestAICmd_unk_38(void);
+static void ContestAICmd_unk_39(void);
+static void ContestAICmd_unk_3A(void);
+static void ContestAICmd_get_move_used_count(void);
+static void ContestAICmd_unk_3C(void);
+static void ContestAICmd_unk_3D(void);
+static void ContestAICmd_unk_3E(void);
+static void ContestAICmd_unk_3F(void);
+static void ContestAICmd_check_combo_starter(void);
+static void ContestAICmd_unk_41(void);
+static void ContestAICmd_unk_42(void);
+static void ContestAICmd_check_combo_finisher(void);
+static void ContestAICmd_unk_44(void);
+static void ContestAICmd_unk_45(void);
+static void ContestAICmd_check_would_finish_combo(void);
+static void ContestAICmd_unk_47(void);
+static void ContestAICmd_unk_48(void);
+static void ContestAICmd_get_condition(void);
+static void ContestAICmd_unk_4A(void);
+static void ContestAICmd_unk_4B(void);
+static void ContestAICmd_unk_4C(void);
+static void ContestAICmd_unk_4D(void);
+static void ContestAICmd_get_used_combo_starter(void);
+static void ContestAICmd_unk_4F(void);
+static void ContestAICmd_unk_50(void);
+static void ContestAICmd_unk_51(void);
+static void ContestAICmd_unk_52(void);
+static void ContestAICmd_check_can_participate(void);
+static void ContestAICmd_unk_54(void);
+static void ContestAICmd_unk_55(void);
+static void ContestAICmd_get_val_812A188(void);
+static void ContestAICmd_unk_57(void);
+static void ContestAICmd_unk_58(void);
+static void ContestAICmd_unk_59(void);
+static void ContestAICmd_unk_5A(void);
+static void ContestAICmd_unk_5B(void);
+static void ContestAICmd_unk_5C(void);
+static void ContestAICmd_unk_5D(void);
+static void ContestAICmd_unk_5E(void);
+static void ContestAICmd_unk_5F(void);
+static void ContestAICmd_unk_60(void);
+static void ContestAICmd_unk_61(void);
+static void ContestAICmd_unk_62(void);
+static void ContestAICmd_unk_63(void);
+static void ContestAICmd_unk_64(void);
+static void ContestAICmd_unk_65(void);
+static void ContestAICmd_unk_66(void);
+static void ContestAICmd_unk_67(void);
+static void ContestAICmd_unk_68(void);
+static void ContestAICmd_unk_69(void);
+static void ContestAICmd_unk_6A(void);
+static void ContestAICmd_unk_6B(void);
+static void ContestAICmd_unk_6C(void);
+static void ContestAICmd_unk_6D(void);
+static void ContestAICmd_unk_6E(void);
+static void ContestAICmd_unk_6F(void);
+static void ContestAICmd_unk_70(void);
+static void ContestAICmd_unk_71(void);
+static void ContestAICmd_unk_72(void);
+static void ContestAICmd_unk_73(void);
+static void ContestAICmd_unk_74(void);
+static void ContestAICmd_unk_75(void);
+static void ContestAICmd_unk_76(void);
+static void ContestAICmd_unk_77(void);
+static void ContestAICmd_unk_78(void);
+static void ContestAICmd_unk_79(void);
+static void ContestAICmd_unk_7A(void);
+static void ContestAICmd_unk_7B(void);
+static void ContestAICmd_unk_7C(void);
+static void ContestAICmd_unk_7D(void);
+static void ContestAICmd_unk_7E(void);
+static void ContestAICmd_unk_7F(void);
+static void ContestAICmd_unk_80(void);
+static void ContestAICmd_unk_81(void);
+static void ContestAICmd_check_for_exciting_move(void);
+static void ContestAICmd_unk_83(void);
+static void ContestAICmd_unk_84(void);
+static void ContestAICmd_unk_85(void);
+static void ContestAICmd_unk_86(void);
+static void ContestAICmd_unk_87(void);
+
 typedef void (* ContestAICmdFunc)(void);
 
-extern const ContestAICmdFunc sContestAICmdTable[]; // TODO: Move table to C file
+static const ContestAICmdFunc sContestAICmdTable[] =
+{
+    ContestAICmd_unk_00,
+    ContestAICmd_get_turn,
+    ContestAICmd_unk_02,
+    ContestAICmd_unk_03,
+    ContestAICmd_unk_04,
+    ContestAICmd_unk_05,
+    ContestAICmd_get_excitement,
+    ContestAICmd_unk_07,
+    ContestAICmd_unk_08,
+    ContestAICmd_unk_09,
+    ContestAICmd_unk_0A,
+    ContestAICmd_get_user_order,
+    ContestAICmd_unk_0C,
+    ContestAICmd_unk_0D,
+    ContestAICmd_unk_0E,
+    ContestAICmd_unk_0F,
+    ContestAICmd_get_user_condition_maybe,
+    ContestAICmd_unk_11,
+    ContestAICmd_unk_12,
+    ContestAICmd_unk_13,
+    ContestAICmd_unk_14,
+    ContestAICmd_unk_15,
+    ContestAICmd_unk_16,
+    ContestAICmd_unk_17,
+    ContestAICmd_unk_18,
+    ContestAICmd_unk_19,
+    ContestAICmd_unk_1A,
+    ContestAICmd_unk_1B,
+    ContestAICmd_unk_1C,
+    ContestAICmd_unk_1D,
+    ContestAICmd_unk_1E,
+    ContestAICmd_get_contest_type,
+    ContestAICmd_unk_20,
+    ContestAICmd_unk_21,
+    ContestAICmd_get_move_excitement,
+    ContestAICmd_unk_23,
+    ContestAICmd_unk_24,
+    ContestAICmd_unk_25,
+    ContestAICmd_unk_26,
+    ContestAICmd_get_move_effect,
+    ContestAICmd_unk_28,
+    ContestAICmd_unk_29,
+    ContestAICmd_get_move_effect_type,
+    ContestAICmd_unk_2B,
+    ContestAICmd_unk_2C,
+    ContestAICmd_check_move_has_highest_appeal,
+    ContestAICmd_unk_2E,
+    ContestAICmd_unk_2F,
+    ContestAICmd_unk_30,
+    ContestAICmd_unk_31,
+    ContestAICmd_unk_32,
+    ContestAICmd_unk_33,
+    ContestAICmd_unk_34,
+    ContestAICmd_unk_35,
+    ContestAICmd_unk_36,
+    ContestAICmd_unk_37,
+    ContestAICmd_unk_38,
+    ContestAICmd_unk_39,
+    ContestAICmd_unk_3A,
+    ContestAICmd_get_move_used_count,
+    ContestAICmd_unk_3C,
+    ContestAICmd_unk_3D,
+    ContestAICmd_unk_3E,
+    ContestAICmd_unk_3F,
+    ContestAICmd_check_combo_starter,
+    ContestAICmd_unk_41,
+    ContestAICmd_unk_42,
+    ContestAICmd_check_combo_finisher,
+    ContestAICmd_unk_44,
+    ContestAICmd_unk_45,
+    ContestAICmd_check_would_finish_combo,
+    ContestAICmd_unk_47,
+    ContestAICmd_unk_48,
+    ContestAICmd_get_condition,
+    ContestAICmd_unk_4A,
+    ContestAICmd_unk_4B,
+    ContestAICmd_unk_4C,
+    ContestAICmd_unk_4D,
+    ContestAICmd_get_used_combo_starter,
+    ContestAICmd_unk_4F,
+    ContestAICmd_unk_50,
+    ContestAICmd_unk_51,
+    ContestAICmd_unk_52,
+    ContestAICmd_check_can_participate,
+    ContestAICmd_unk_54,
+    ContestAICmd_unk_55,
+    ContestAICmd_get_val_812A188,
+    ContestAICmd_unk_57,
+    ContestAICmd_unk_58,
+    ContestAICmd_unk_59,
+    ContestAICmd_unk_5A,
+    ContestAICmd_unk_5B,
+    ContestAICmd_unk_5C,
+    ContestAICmd_unk_5D,
+    ContestAICmd_unk_5E,
+    ContestAICmd_unk_5F,
+    ContestAICmd_unk_60,
+    ContestAICmd_unk_61,
+    ContestAICmd_unk_62,
+    ContestAICmd_unk_63,
+    ContestAICmd_unk_64,
+    ContestAICmd_unk_65,
+    ContestAICmd_unk_66,
+    ContestAICmd_unk_67,
+    ContestAICmd_unk_68,
+    ContestAICmd_unk_69,
+    ContestAICmd_unk_6A,
+    ContestAICmd_unk_6B,
+    ContestAICmd_unk_6C,
+    ContestAICmd_unk_6D,
+    ContestAICmd_unk_6E,
+    ContestAICmd_unk_6F,
+    ContestAICmd_unk_70,
+    ContestAICmd_unk_71,
+    ContestAICmd_unk_72,
+    ContestAICmd_unk_73,
+    ContestAICmd_unk_74,
+    ContestAICmd_unk_75,
+    ContestAICmd_unk_76,
+    ContestAICmd_unk_77,
+    ContestAICmd_unk_78,
+    ContestAICmd_unk_79,
+    ContestAICmd_unk_7A,
+    ContestAICmd_unk_7B,
+    ContestAICmd_unk_7C,
+    ContestAICmd_unk_7D,
+    ContestAICmd_unk_7E,
+    ContestAICmd_unk_7F,
+    ContestAICmd_unk_80,
+    ContestAICmd_unk_81,
+    ContestAICmd_check_for_exciting_move,
+    ContestAICmd_unk_83,
+    ContestAICmd_unk_84,
+    ContestAICmd_unk_85,
+    ContestAICmd_unk_86,
+    ContestAICmd_unk_87,
+};
 
-void ContestAI_DoAIProcessing(void);
-void sub_812ACA4(u8 *);
-u8 sub_812ACC8(void);
+static void ContestAI_DoAIProcessing(void);
+static bool8 sub_8128A7C(u8);
+static void sub_812ACA4(u8 *);
+static u8 sub_812ACC8(void);
 
 void ContestAI_ResetAI(u8 var)
 {
@@ -72,7 +347,7 @@ u8 ContestAI_GetActionToUse(void)
     }
 }
 
-void ContestAI_DoAIProcessing(void)
+static void ContestAI_DoAIProcessing(void)
 {
     while(eContestAI->aiState != ContestAI_FinishedProcessing)
     {
@@ -111,7 +386,7 @@ void ContestAI_DoAIProcessing(void)
     }
 }
 
-u8 sub_8128A7C(u8 var)
+static u8 sub_8128A7C(u8 var)
 {
     int i;
 
@@ -122,7 +397,7 @@ u8 sub_8128A7C(u8 var)
     return i;
 }
 
-void ContestAICmd_unk_00(void)
+static void ContestAICmd_unk_00(void)
 {
     s16 score = eContestAI->unk5[eContestAI->unk4] + (s8)gAIScriptPtr[1];
 
@@ -136,13 +411,13 @@ void ContestAICmd_unk_00(void)
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_get_turn(void)
+static void ContestAICmd_get_turn(void)
 {
     eContestAI->scriptResult = sContest.turnNumber;
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_02(void)
+static void ContestAICmd_unk_02(void)
 {
     ContestAICmd_get_turn();
 
@@ -152,7 +427,7 @@ void ContestAICmd_unk_02(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_03(void)
+static void ContestAICmd_unk_03(void)
 {
     ContestAICmd_get_turn();
 
@@ -162,7 +437,7 @@ void ContestAICmd_unk_03(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_04(void)
+static void ContestAICmd_unk_04(void)
 {
     ContestAICmd_get_turn();
 
@@ -172,7 +447,7 @@ void ContestAICmd_unk_04(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_05(void)
+static void ContestAICmd_unk_05(void)
 {
     ContestAICmd_get_turn();
 
@@ -182,13 +457,13 @@ void ContestAICmd_unk_05(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_excitement(void)
+static void ContestAICmd_get_excitement(void)
 {
     eContestAI->scriptResult = sContest.applauseLevel;
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_07(void)
+static void ContestAICmd_unk_07(void)
 {
     ContestAICmd_get_excitement();
 
@@ -198,7 +473,7 @@ void ContestAICmd_unk_07(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_08(void)
+static void ContestAICmd_unk_08(void)
 {
     ContestAICmd_get_excitement();
 
@@ -208,7 +483,7 @@ void ContestAICmd_unk_08(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_09(void)
+static void ContestAICmd_unk_09(void)
 {
     ContestAICmd_get_excitement();
 
@@ -218,7 +493,7 @@ void ContestAICmd_unk_09(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_0A(void)
+static void ContestAICmd_unk_0A(void)
 {
     ContestAICmd_get_excitement();
 
@@ -228,13 +503,13 @@ void ContestAICmd_unk_0A(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_user_order(void)
+static void ContestAICmd_get_user_order(void)
 {
     eContestAI->scriptResult = shared192D0.unk0[eContestAI->unk41];
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_0C(void)
+static void ContestAICmd_unk_0C(void)
 {
     ContestAICmd_get_user_order();
 
@@ -244,7 +519,7 @@ void ContestAICmd_unk_0C(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_0D(void)
+static void ContestAICmd_unk_0D(void)
 {
     ContestAICmd_get_user_order();
 
@@ -254,7 +529,7 @@ void ContestAICmd_unk_0D(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_0E(void)
+static void ContestAICmd_unk_0E(void)
 {
     ContestAICmd_get_user_order();
 
@@ -264,7 +539,7 @@ void ContestAICmd_unk_0E(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_0F(void)
+static void ContestAICmd_unk_0F(void)
 {
     ContestAICmd_get_user_order();
 
@@ -274,13 +549,13 @@ void ContestAICmd_unk_0F(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_user_condition_maybe(void)
+static void ContestAICmd_get_user_condition_maybe(void)
 {
     eContestAI->scriptResult = sContestantStatus[eContestAI->unk41].unkD / 10;
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_11(void)
+static void ContestAICmd_unk_11(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
@@ -290,7 +565,7 @@ void ContestAICmd_unk_11(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_12(void)
+static void ContestAICmd_unk_12(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
@@ -300,7 +575,7 @@ void ContestAICmd_unk_12(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_13(void)
+static void ContestAICmd_unk_13(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
@@ -310,7 +585,7 @@ void ContestAICmd_unk_13(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_14(void)
+static void ContestAICmd_unk_14(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
@@ -320,13 +595,13 @@ void ContestAICmd_unk_14(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_15(void)
+static void ContestAICmd_unk_15(void)
 {
     eContestAI->scriptResult = sContestantStatus[eContestAI->unk41].unk4;
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_16(void)
+static void ContestAICmd_unk_16(void)
 {
     ContestAICmd_unk_15();
 
@@ -336,7 +611,7 @@ void ContestAICmd_unk_16(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_17(void)
+static void ContestAICmd_unk_17(void)
 {
     ContestAICmd_unk_15();
 
@@ -346,7 +621,7 @@ void ContestAICmd_unk_17(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_18(void)
+static void ContestAICmd_unk_18(void)
 {
     ContestAICmd_unk_15();
 
@@ -356,7 +631,7 @@ void ContestAICmd_unk_18(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_19(void)
+static void ContestAICmd_unk_19(void)
 {
     ContestAICmd_unk_15();
 
@@ -366,13 +641,13 @@ void ContestAICmd_unk_19(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_1A(void)
+static void ContestAICmd_unk_1A(void)
 {
     eContestAI->scriptResult = gUnknown_02038670[eContestAI->unk41];
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_1B(void)
+static void ContestAICmd_unk_1B(void)
 {
     ContestAICmd_unk_1A();
 
@@ -382,7 +657,7 @@ void ContestAICmd_unk_1B(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_1C(void)
+static void ContestAICmd_unk_1C(void)
 {
     ContestAICmd_unk_1A();
 
@@ -392,7 +667,7 @@ void ContestAICmd_unk_1C(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_1D(void)
+static void ContestAICmd_unk_1D(void)
 {
     ContestAICmd_unk_1A();
 
@@ -402,7 +677,7 @@ void ContestAICmd_unk_1D(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_1E(void)
+static void ContestAICmd_unk_1E(void)
 {
     ContestAICmd_unk_1A();
 
@@ -412,13 +687,13 @@ void ContestAICmd_unk_1E(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_get_contest_type(void)
+static void ContestAICmd_get_contest_type(void)
 {
     eContestAI->scriptResult = gSpecialVar_ContestCategory;
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_20(void)
+static void ContestAICmd_unk_20(void)
 {
     ContestAICmd_get_contest_type();
 
@@ -428,7 +703,7 @@ void ContestAICmd_unk_20(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_21(void)
+static void ContestAICmd_unk_21(void)
 {
     ContestAICmd_get_contest_type();
 
@@ -438,13 +713,13 @@ void ContestAICmd_unk_21(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_move_excitement(void)
+static void ContestAICmd_get_move_excitement(void)
 {
     eContestAI->scriptResult = Contest_GetMoveExcitement(gContestMons[eContestAI->unk41].moves[eContestAI->unk4]);
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_23(void)
+static void ContestAICmd_unk_23(void)
 {
     ContestAICmd_get_move_excitement();
 
@@ -454,7 +729,7 @@ void ContestAICmd_unk_23(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_24(void)
+static void ContestAICmd_unk_24(void)
 {
     ContestAICmd_get_move_excitement();
 
@@ -464,7 +739,7 @@ void ContestAICmd_unk_24(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_25(void)
+static void ContestAICmd_unk_25(void)
 {
     ContestAICmd_get_move_excitement();
 
@@ -474,7 +749,7 @@ void ContestAICmd_unk_25(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_26(void)
+static void ContestAICmd_unk_26(void)
 {
     ContestAICmd_get_move_excitement();
 
@@ -484,7 +759,7 @@ void ContestAICmd_unk_26(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_move_effect(void)
+static void ContestAICmd_get_move_effect(void)
 {
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
 
@@ -492,7 +767,7 @@ void ContestAICmd_get_move_effect(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_28(void)
+static void ContestAICmd_unk_28(void)
 {
     ContestAICmd_get_move_effect();
 
@@ -502,7 +777,7 @@ void ContestAICmd_unk_28(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_29(void)
+static void ContestAICmd_unk_29(void)
 {
     ContestAICmd_get_move_effect();
 
@@ -512,7 +787,7 @@ void ContestAICmd_unk_29(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_move_effect_type(void)
+static void ContestAICmd_get_move_effect_type(void)
 {
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
 
@@ -520,7 +795,7 @@ void ContestAICmd_get_move_effect_type(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_2B(void)
+static void ContestAICmd_unk_2B(void)
 {
     ContestAICmd_get_move_effect_type();
 
@@ -530,7 +805,7 @@ void ContestAICmd_unk_2B(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_2C(void)
+static void ContestAICmd_unk_2C(void)
 {
     ContestAICmd_get_move_effect_type();
 
@@ -540,7 +815,7 @@ void ContestAICmd_unk_2C(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_check_move_has_highest_appeal(void)
+static void ContestAICmd_check_move_has_highest_appeal(void)
 {
     int i;
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
@@ -561,7 +836,7 @@ void ContestAICmd_check_move_has_highest_appeal(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_2E(void)
+static void ContestAICmd_unk_2E(void)
 {
     ContestAICmd_check_move_has_highest_appeal();
 
@@ -571,7 +846,7 @@ void ContestAICmd_unk_2E(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_2F(void)
+static void ContestAICmd_unk_2F(void)
 {
     int i;
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
@@ -592,7 +867,7 @@ void ContestAICmd_unk_2F(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_30(void)
+static void ContestAICmd_unk_30(void)
 {
     ContestAICmd_unk_2F();
 
@@ -602,7 +877,7 @@ void ContestAICmd_unk_30(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_31(void)
+static void ContestAICmd_unk_31(void)
 {
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
 
@@ -610,7 +885,7 @@ void ContestAICmd_unk_31(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_32(void)
+static void ContestAICmd_unk_32(void)
 {
     ContestAICmd_unk_31();
 
@@ -620,7 +895,7 @@ void ContestAICmd_unk_32(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_33(void)
+static void ContestAICmd_unk_33(void)
 {
     ContestAICmd_unk_31();
 
@@ -630,7 +905,7 @@ void ContestAICmd_unk_33(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_34(void)
+static void ContestAICmd_unk_34(void)
 {
     ContestAICmd_unk_31();
 
@@ -640,7 +915,7 @@ void ContestAICmd_unk_34(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_35(void)
+static void ContestAICmd_unk_35(void)
 {
     ContestAICmd_unk_31();
 
@@ -650,7 +925,7 @@ void ContestAICmd_unk_35(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_36(void)
+static void ContestAICmd_unk_36(void)
 {
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
 
@@ -658,7 +933,7 @@ void ContestAICmd_unk_36(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_37(void)
+static void ContestAICmd_unk_37(void)
 {
     ContestAICmd_unk_36();
 
@@ -668,7 +943,7 @@ void ContestAICmd_unk_37(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_38(void)
+static void ContestAICmd_unk_38(void)
 {
     ContestAICmd_unk_36();
 
@@ -678,7 +953,7 @@ void ContestAICmd_unk_38(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_39(void)
+static void ContestAICmd_unk_39(void)
 {
     ContestAICmd_unk_36();
 
@@ -688,7 +963,7 @@ void ContestAICmd_unk_39(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_3A(void)
+static void ContestAICmd_unk_3A(void)
 {
     ContestAICmd_unk_36();
 
@@ -698,7 +973,7 @@ void ContestAICmd_unk_3A(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_move_used_count(void)
+static void ContestAICmd_get_move_used_count(void)
 {
     s16 result;
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
@@ -712,7 +987,7 @@ void ContestAICmd_get_move_used_count(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_3C(void)
+static void ContestAICmd_unk_3C(void)
 {
     ContestAICmd_get_move_used_count();
 
@@ -722,7 +997,7 @@ void ContestAICmd_unk_3C(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_3D(void)
+static void ContestAICmd_unk_3D(void)
 {
     ContestAICmd_get_move_used_count();
 
@@ -732,7 +1007,7 @@ void ContestAICmd_unk_3D(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_3E(void)
+static void ContestAICmd_unk_3E(void)
 {
     ContestAICmd_get_move_used_count();
 
@@ -742,7 +1017,7 @@ void ContestAICmd_unk_3E(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_3F(void)
+static void ContestAICmd_unk_3F(void)
 {
     ContestAICmd_get_move_used_count();
 
@@ -752,7 +1027,7 @@ void ContestAICmd_unk_3F(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_check_combo_starter(void)
+static void ContestAICmd_check_combo_starter(void)
 {
     u8 result = 0;
     int i;
@@ -778,7 +1053,7 @@ void ContestAICmd_check_combo_starter(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_41(void)
+static void ContestAICmd_unk_41(void)
 {
     ContestAICmd_check_combo_starter();
 
@@ -788,7 +1063,7 @@ void ContestAICmd_unk_41(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_42(void)
+static void ContestAICmd_unk_42(void)
 {
     ContestAICmd_check_combo_starter();
 
@@ -798,7 +1073,7 @@ void ContestAICmd_unk_42(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_check_combo_finisher(void)
+static void ContestAICmd_check_combo_finisher(void)
 {
     u8 result = 0;
     int i;
@@ -824,7 +1099,7 @@ void ContestAICmd_check_combo_finisher(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_44(void)
+static void ContestAICmd_unk_44(void)
 {
     ContestAICmd_check_combo_finisher();
 
@@ -834,7 +1109,7 @@ void ContestAICmd_unk_44(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_45(void)
+static void ContestAICmd_unk_45(void)
 {
     ContestAICmd_check_combo_finisher();
 
@@ -844,7 +1119,7 @@ void ContestAICmd_unk_45(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_check_would_finish_combo(void)
+static void ContestAICmd_check_would_finish_combo(void)
 {
     u8 result = 0;
     u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
@@ -859,7 +1134,7 @@ void ContestAICmd_check_would_finish_combo(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_47(void)
+static void ContestAICmd_unk_47(void)
 {
     ContestAICmd_check_would_finish_combo();
 
@@ -869,7 +1144,7 @@ void ContestAICmd_unk_47(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_48(void)
+static void ContestAICmd_unk_48(void)
 {
     ContestAICmd_check_would_finish_combo();
 
@@ -879,7 +1154,7 @@ void ContestAICmd_unk_48(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_get_condition(void)
+static void ContestAICmd_get_condition(void)
 {
     int var = sub_8128A7C(gAIScriptPtr[1]);
 
@@ -887,7 +1162,7 @@ void ContestAICmd_get_condition(void)
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_unk_4A(void)
+static void ContestAICmd_unk_4A(void)
 {
     ContestAICmd_get_condition();
 
@@ -897,7 +1172,7 @@ void ContestAICmd_unk_4A(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_4B(void)
+static void ContestAICmd_unk_4B(void)
 {
     ContestAICmd_get_condition();
 
@@ -907,7 +1182,7 @@ void ContestAICmd_unk_4B(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_4C(void)
+static void ContestAICmd_unk_4C(void)
 {
     ContestAICmd_get_condition();
 
@@ -917,7 +1192,7 @@ void ContestAICmd_unk_4C(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_4D(void)
+static void ContestAICmd_unk_4D(void)
 {
     ContestAICmd_get_condition();
 
@@ -927,7 +1202,7 @@ void ContestAICmd_unk_4D(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_get_used_combo_starter(void)
+static void ContestAICmd_get_used_combo_starter(void)
 {
     u16 result = 0;
     u8 var = sub_8128A7C(gAIScriptPtr[1]);
@@ -939,7 +1214,7 @@ void ContestAICmd_get_used_combo_starter(void)
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_unk_4F(void)
+static void ContestAICmd_unk_4F(void)
 {
     ContestAICmd_get_used_combo_starter();
 
@@ -949,7 +1224,7 @@ void ContestAICmd_unk_4F(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_50(void)
+static void ContestAICmd_unk_50(void)
 {
     ContestAICmd_get_used_combo_starter();
 
@@ -959,7 +1234,7 @@ void ContestAICmd_unk_50(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_51(void)
+static void ContestAICmd_unk_51(void)
 {
     ContestAICmd_get_used_combo_starter();
 
@@ -969,7 +1244,7 @@ void ContestAICmd_unk_51(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_52(void)
+static void ContestAICmd_unk_52(void)
 {
     ContestAICmd_get_used_combo_starter();
 
@@ -979,7 +1254,7 @@ void ContestAICmd_unk_52(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_check_can_participate(void)
+static void ContestAICmd_check_can_participate(void)
 {
     if(Contest_IsMonsTurnDisabled(sub_8128A7C(gAIScriptPtr[1])))
         eContestAI->scriptResult = FALSE;
@@ -989,7 +1264,7 @@ void ContestAICmd_check_can_participate(void)
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_unk_54(void)
+static void ContestAICmd_unk_54(void)
 {
     ContestAICmd_check_can_participate();
 
@@ -999,7 +1274,7 @@ void ContestAICmd_unk_54(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_55(void)
+static void ContestAICmd_unk_55(void)
 {
     ContestAICmd_check_can_participate();
 
@@ -1009,7 +1284,7 @@ void ContestAICmd_unk_55(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_get_val_812A188(void)
+static void ContestAICmd_get_val_812A188(void)
 {
     u8 var = sub_8128A7C(gAIScriptPtr[1]);
 
@@ -1017,7 +1292,7 @@ void ContestAICmd_get_val_812A188(void)
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_unk_57(void)
+static void ContestAICmd_unk_57(void)
 {
     ContestAICmd_get_val_812A188();
 
@@ -1027,7 +1302,7 @@ void ContestAICmd_unk_57(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_58(void)
+static void ContestAICmd_unk_58(void)
 {
     ContestAICmd_get_val_812A188();
 
@@ -1037,7 +1312,7 @@ void ContestAICmd_unk_58(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_59(void)
+static void ContestAICmd_unk_59(void)
 {
     u8 var = sub_8128A7C(gAIScriptPtr[1]);
 
@@ -1045,7 +1320,7 @@ void ContestAICmd_unk_59(void)
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_unk_5A(void)
+static void ContestAICmd_unk_5A(void)
 {
     ContestAICmd_unk_59();
 
@@ -1055,7 +1330,7 @@ void ContestAICmd_unk_5A(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_5B(void)
+static void ContestAICmd_unk_5B(void)
 {
     ContestAICmd_unk_59();
 
@@ -1065,7 +1340,7 @@ void ContestAICmd_unk_5B(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_5C(void)
+static void ContestAICmd_unk_5C(void)
 {
     ContestAICmd_unk_59();
 
@@ -1075,7 +1350,7 @@ void ContestAICmd_unk_5C(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_5D(void)
+static void ContestAICmd_unk_5D(void)
 {
     ContestAICmd_unk_59();
 
@@ -1085,7 +1360,7 @@ void ContestAICmd_unk_5D(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_5E(void)
+static void ContestAICmd_unk_5E(void)
 {
     u8 var = sub_8128A7C(gAIScriptPtr[1]);
 
@@ -1093,7 +1368,7 @@ void ContestAICmd_unk_5E(void)
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_unk_5F(void)
+static void ContestAICmd_unk_5F(void)
 {
     ContestAICmd_unk_5E();
 
@@ -1103,7 +1378,7 @@ void ContestAICmd_unk_5F(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_60(void)
+static void ContestAICmd_unk_60(void)
 {
     ContestAICmd_unk_5E();
 
@@ -1113,7 +1388,7 @@ void ContestAICmd_unk_60(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_61(void)
+static void ContestAICmd_unk_61(void)
 {
     ContestAICmd_unk_5E();
 
@@ -1123,7 +1398,7 @@ void ContestAICmd_unk_61(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_62(void)
+static void ContestAICmd_unk_62(void)
 {
     ContestAICmd_unk_5E();
 
@@ -1133,7 +1408,7 @@ void ContestAICmd_unk_62(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_63(void)
+static void ContestAICmd_unk_63(void)
 {
     u8 var = sub_8128A7C(gAIScriptPtr[1]);
     u8 var2 = gAIScriptPtr[2];
@@ -1143,7 +1418,7 @@ void ContestAICmd_unk_63(void)
     gAIScriptPtr += 3;
 }
 
-void ContestAICmd_unk_64(void)
+static void ContestAICmd_unk_64(void)
 {
     ContestAICmd_unk_63();
 
@@ -1153,7 +1428,7 @@ void ContestAICmd_unk_64(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_65(void)
+static void ContestAICmd_unk_65(void)
 {
     ContestAICmd_unk_63();
 
@@ -1163,7 +1438,7 @@ void ContestAICmd_unk_65(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_66(void)
+static void ContestAICmd_unk_66(void)
 {
     ContestAICmd_unk_63();
 
@@ -1173,7 +1448,7 @@ void ContestAICmd_unk_66(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_67(void)
+static void ContestAICmd_unk_67(void)
 {
     ContestAICmd_unk_63();
 
@@ -1183,7 +1458,7 @@ void ContestAICmd_unk_67(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_68(void)
+static void ContestAICmd_unk_68(void)
 {
     u8 var = sub_8128A7C(gAIScriptPtr[1]);
     u8 var2 = gAIScriptPtr[2];
@@ -1193,7 +1468,7 @@ void ContestAICmd_unk_68(void)
     gAIScriptPtr += 3;
 }
 
-void ContestAICmd_unk_69(void)
+static void ContestAICmd_unk_69(void)
 {
     ContestAICmd_unk_68();
 
@@ -1203,7 +1478,7 @@ void ContestAICmd_unk_69(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_6A(void)
+static void ContestAICmd_unk_6A(void)
 {
     ContestAICmd_unk_68();
 
@@ -1213,7 +1488,7 @@ void ContestAICmd_unk_6A(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_6B(void)
+static void ContestAICmd_unk_6B(void)
 {
     ContestAICmd_unk_68();
 
@@ -1223,7 +1498,7 @@ void ContestAICmd_unk_6B(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_6C(void)
+static void ContestAICmd_unk_6C(void)
 {
     ContestAICmd_unk_68();
 
@@ -1233,7 +1508,7 @@ void ContestAICmd_unk_6C(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_6D(void)
+static void ContestAICmd_unk_6D(void)
 {
     u8 var = sub_8128A7C(gAIScriptPtr[1]);
     u8 var2 = gAIScriptPtr[2];
@@ -1243,7 +1518,7 @@ void ContestAICmd_unk_6D(void)
     gAIScriptPtr += 3;
 }
 
-void ContestAICmd_unk_6E(void)
+static void ContestAICmd_unk_6E(void)
 {
     ContestAICmd_unk_6D();
 
@@ -1253,7 +1528,7 @@ void ContestAICmd_unk_6E(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_6F(void)
+static void ContestAICmd_unk_6F(void)
 {
     ContestAICmd_unk_6D();
 
@@ -1263,38 +1538,38 @@ void ContestAICmd_unk_6F(void)
         gAIScriptPtr += 5;
 }
 
-void ContestAICmd_unk_70(void)
+static void ContestAICmd_unk_70(void)
 {
     eContestAI->scriptArr[gAIScriptPtr[1]] = eContestAI->scriptResult;
     gAIScriptPtr += 2;
 }
 
-void ContestAICmd_unk_71(void)
+static void ContestAICmd_unk_71(void)
 {
     eContestAI->scriptArr[gAIScriptPtr[1]] = T1_READ_16(gAIScriptPtr + 2);
     gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_72(void)
+static void ContestAICmd_unk_72(void)
 {
     // wtf? shouldn't T1_READ_16 work here? why the signed 8 load by gAIScriptPtr[2]?
     eContestAI->scriptArr[gAIScriptPtr[1]] += ((s8)gAIScriptPtr[2] | gAIScriptPtr[3] << 8);
     gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_73(void)
+static void ContestAICmd_unk_73(void)
 {
     eContestAI->scriptArr[gAIScriptPtr[1]] += eContestAI->scriptArr[gAIScriptPtr[2]];
     gAIScriptPtr += 3;
 }
 
-void ContestAICmd_unk_74(void)
+static void ContestAICmd_unk_74(void)
 {
     eContestAI->scriptArr[gAIScriptPtr[1]] += eContestAI->scriptArr[gAIScriptPtr[2]];
     gAIScriptPtr += 3;
 }
 
-void ContestAICmd_unk_75(void)
+static void ContestAICmd_unk_75(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] < T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
@@ -1302,7 +1577,7 @@ void ContestAICmd_unk_75(void)
         gAIScriptPtr += 8;
 }
 
-void ContestAICmd_unk_76(void)
+static void ContestAICmd_unk_76(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] > T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
@@ -1310,7 +1585,7 @@ void ContestAICmd_unk_76(void)
         gAIScriptPtr += 8;
 }
 
-void ContestAICmd_unk_77(void)
+static void ContestAICmd_unk_77(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] == T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
@@ -1318,7 +1593,7 @@ void ContestAICmd_unk_77(void)
         gAIScriptPtr += 8;
 }
 
-void ContestAICmd_unk_78(void)
+static void ContestAICmd_unk_78(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] != T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
@@ -1326,7 +1601,7 @@ void ContestAICmd_unk_78(void)
         gAIScriptPtr += 8;
 }
 
-void ContestAICmd_unk_79(void)
+static void ContestAICmd_unk_79(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] < ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
@@ -1334,7 +1609,7 @@ void ContestAICmd_unk_79(void)
         gAIScriptPtr += 7;
 }
 
-void ContestAICmd_unk_7A(void)
+static void ContestAICmd_unk_7A(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] > ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
@@ -1342,7 +1617,7 @@ void ContestAICmd_unk_7A(void)
         gAIScriptPtr += 7;
 }
 
-void ContestAICmd_unk_7B(void)
+static void ContestAICmd_unk_7B(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] == ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
@@ -1350,7 +1625,7 @@ void ContestAICmd_unk_7B(void)
         gAIScriptPtr += 7;
 }
 
-void ContestAICmd_unk_7C(void)
+static void ContestAICmd_unk_7C(void)
 {
     if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] != ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
@@ -1358,7 +1633,7 @@ void ContestAICmd_unk_7C(void)
         gAIScriptPtr += 7;
 }
 
-void ContestAICmd_unk_7D(void)
+static void ContestAICmd_unk_7D(void)
 {
     if((Random() & 0xFF) < (s16)eContestAI->scriptArr[gAIScriptPtr[1]])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
@@ -1366,7 +1641,7 @@ void ContestAICmd_unk_7D(void)
         gAIScriptPtr += 6;
 }
 
-void ContestAICmd_unk_7E(void)
+static void ContestAICmd_unk_7E(void)
 {
     if((Random() & 0xFF) > (s16)eContestAI->scriptArr[gAIScriptPtr[1]])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
@@ -1375,32 +1650,32 @@ void ContestAICmd_unk_7E(void)
 }
 
 // jump
-void ContestAICmd_unk_7F(void)
+static void ContestAICmd_unk_7F(void)
 {
     gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
 }
 
-void ContestAICmd_unk_80(void)
+static void ContestAICmd_unk_80(void)
 {
     sub_812ACA4(gAIScriptPtr + 5);
     gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
 }
 
-void ContestAICmd_unk_81(void)
+static void ContestAICmd_unk_81(void)
 {
     if(!sub_812ACC8())
         eContestAI->aiAction |= 1;
 }
 
 // push stack?
-void sub_812ACA4(u8 *ptr)
+static void sub_812ACA4(u8 *ptr)
 {
     u8 unk40 = eContestAI->unk40++;
     eContestAI->stack[unk40] = (u32)ptr;
 }
 
 // pop stack?
-bool8 sub_812ACC8(void)
+static bool8 sub_812ACC8(void)
 {
     if(eContestAI->unk40 != 0)
     {
@@ -1412,7 +1687,7 @@ bool8 sub_812ACC8(void)
         return FALSE;
 }
 
-void ContestAICmd_check_for_exciting_move(void)
+static void ContestAICmd_check_for_exciting_move(void)
 {
     int result = 0;
     int i;
@@ -1434,7 +1709,7 @@ void ContestAICmd_check_for_exciting_move(void)
     gAIScriptPtr += 1;
 }
 
-void ContestAICmd_unk_83(void)
+static void ContestAICmd_unk_83(void)
 {
     ContestAICmd_check_for_exciting_move();
 
@@ -1444,7 +1719,7 @@ void ContestAICmd_unk_83(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_84(void)
+static void ContestAICmd_unk_84(void)
 {
     ContestAICmd_check_for_exciting_move();
 
@@ -1454,7 +1729,7 @@ void ContestAICmd_unk_84(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_85(void)
+static void ContestAICmd_unk_85(void)
 {
     int result = 0;
     int i;
@@ -1474,7 +1749,7 @@ void ContestAICmd_unk_85(void)
     gAIScriptPtr += 3;
 }
 
-void ContestAICmd_unk_86(void)
+static void ContestAICmd_unk_86(void)
 {
     ContestAICmd_unk_85();
 
@@ -1484,7 +1759,7 @@ void ContestAICmd_unk_86(void)
         gAIScriptPtr += 4;
 }
 
-void ContestAICmd_unk_87(void)
+static void ContestAICmd_unk_87(void)
 {
     ContestAICmd_unk_85();
 
-- 
cgit v1.2.3


From d7d947c6913d1a2a7a6401b8aac2041d536ad978 Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sun, 14 Jan 2018 13:59:12 -0500
Subject: formatting and clean up

---
 src/battle/battle_ai.c |  12 +-
 src/contest.c          |   3 +-
 src/contest_ai.c       | 465 ++++++++++++++++++++++++-------------------------
 3 files changed, 236 insertions(+), 244 deletions(-)

(limited to 'src')

diff --git a/src/battle/battle_ai.c b/src/battle/battle_ai.c
index 977e91f5c..80848d2fd 100644
--- a/src/battle/battle_ai.c
+++ b/src/battle/battle_ai.c
@@ -355,7 +355,7 @@ u8 BattleAI_GetAIActionToUse(void)
     {
         if (AI_THINKING_STRUCT->aiFlags & 1)
         {
-            AI_THINKING_STRUCT->aiState = AIState_SettingUp;
+            AI_THINKING_STRUCT->aiState = BATTLEAI_SETTING_UP;
             BattleAI_DoAIProcessing();
         }
         AI_THINKING_STRUCT->aiFlags >>= 1;
@@ -393,13 +393,13 @@ u8 BattleAI_GetAIActionToUse(void)
 
 void BattleAI_DoAIProcessing(void)
 {
-    while (AI_THINKING_STRUCT->aiState != AIState_FinishedProcessing)
+    while (AI_THINKING_STRUCT->aiState != BATTLEAI_FINISHED)
     {
         switch (AI_THINKING_STRUCT->aiState)
         {
-        case AIState_DoNotProcess: //Needed to match.
+        case BATTLEAI_DO_NOT_PROCESS: //Needed to match.
             break;
-        case AIState_SettingUp:
+        case BATTLEAI_SETTING_UP:
             gAIScriptPtr = BattleAIs[AI_THINKING_STRUCT->aiLogicId]; // set the AI ptr.
             if (gBattleMons[gBankAttacker].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
             {
@@ -411,7 +411,7 @@ void BattleAI_DoAIProcessing(void)
             }
             AI_THINKING_STRUCT->aiState++;
             break;
-        case AIState_Processing:
+        case BATTLEAI_PROCESSING:
             if (AI_THINKING_STRUCT->moveConsidered != MOVE_NONE)
                 sBattleAICmdTable[*gAIScriptPtr](); // run AI command.
             else
@@ -423,7 +423,7 @@ void BattleAI_DoAIProcessing(void)
             {
                 AI_THINKING_STRUCT->movesetIndex++;
                 if (AI_THINKING_STRUCT->movesetIndex < MAX_MON_MOVES && (AI_THINKING_STRUCT->aiAction & AI_ACTION_DO_NOT_ATTACK) == 0)
-                    AI_THINKING_STRUCT->aiState = AIState_SettingUp; // as long as their are more moves to process, keep setting this to setup state.
+                    AI_THINKING_STRUCT->aiState = BATTLEAI_SETTING_UP; // as long as their are more moves to process, keep setting this to setup state.
                 else
                     AI_THINKING_STRUCT->aiState++; // done processing.
                 AI_THINKING_STRUCT->aiAction &= (AI_ACTION_FLEE | AI_ACTION_WATCH | AI_ACTION_DO_NOT_ATTACK |
diff --git a/src/contest.c b/src/contest.c
index 6a8887fb1..df4bb361d 100644
--- a/src/contest.c
+++ b/src/contest.c
@@ -31,13 +31,12 @@
 #include "tv.h"
 #include "scanline_effect.h"
 #include "util.h"
+#include "contest_ai.h"
 
 extern u8 AreMovesContestCombo(u16, u16);  // I don't think this is a bool
 extern void sub_80C8A38(u8);
 extern void sub_80C8AD0(u8);
 extern void sub_80C8C80(u8);
-extern void ContestAI_ResetAI();
-extern u8 ContestAI_GetActionToUse(void);
 
 extern struct MusicPlayerInfo gMPlay_SE1;
 extern u16 gSpecialVar_ContestCategory;
diff --git a/src/contest_ai.c b/src/contest_ai.c
index f8f2812fb..0c1126ac5 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -1,20 +1,13 @@
 #include "global.h"
 #include "contest.h"
 #include "random.h"
+#include "contest_ai.h"
 #include "ewram.h"
 
 extern u8 AreMovesContestCombo(u16, u16);
 extern bool8 sub_80B214C(u8);
 extern bool8 Contest_IsMonsTurnDisabled(u8);
 
-enum
-{
-    ContestAI_SettingUp,
-    ContestAI_Processing,
-    ContestAI_FinishedProcessing,
-    ContestAI_DoNotProcess
-};
-
 extern s16 gUnknown_02038670[];
 extern u16 gSpecialVar_ContestCategory;
 
@@ -162,142 +155,142 @@ typedef void (* ContestAICmdFunc)(void);
 
 static const ContestAICmdFunc sContestAICmdTable[] =
 {
-    ContestAICmd_unk_00,
-    ContestAICmd_get_turn,
-    ContestAICmd_unk_02,
-    ContestAICmd_unk_03,
-    ContestAICmd_unk_04,
-    ContestAICmd_unk_05,
-    ContestAICmd_get_excitement,
-    ContestAICmd_unk_07,
-    ContestAICmd_unk_08,
-    ContestAICmd_unk_09,
-    ContestAICmd_unk_0A,
-    ContestAICmd_get_user_order,
-    ContestAICmd_unk_0C,
-    ContestAICmd_unk_0D,
-    ContestAICmd_unk_0E,
-    ContestAICmd_unk_0F,
-    ContestAICmd_get_user_condition_maybe,
-    ContestAICmd_unk_11,
-    ContestAICmd_unk_12,
-    ContestAICmd_unk_13,
-    ContestAICmd_unk_14,
-    ContestAICmd_unk_15,
-    ContestAICmd_unk_16,
-    ContestAICmd_unk_17,
-    ContestAICmd_unk_18,
-    ContestAICmd_unk_19,
-    ContestAICmd_unk_1A,
-    ContestAICmd_unk_1B,
-    ContestAICmd_unk_1C,
-    ContestAICmd_unk_1D,
-    ContestAICmd_unk_1E,
-    ContestAICmd_get_contest_type,
-    ContestAICmd_unk_20,
-    ContestAICmd_unk_21,
-    ContestAICmd_get_move_excitement,
-    ContestAICmd_unk_23,
-    ContestAICmd_unk_24,
-    ContestAICmd_unk_25,
-    ContestAICmd_unk_26,
-    ContestAICmd_get_move_effect,
-    ContestAICmd_unk_28,
-    ContestAICmd_unk_29,
-    ContestAICmd_get_move_effect_type,
-    ContestAICmd_unk_2B,
-    ContestAICmd_unk_2C,
-    ContestAICmd_check_move_has_highest_appeal,
-    ContestAICmd_unk_2E,
-    ContestAICmd_unk_2F,
-    ContestAICmd_unk_30,
-    ContestAICmd_unk_31,
-    ContestAICmd_unk_32,
-    ContestAICmd_unk_33,
-    ContestAICmd_unk_34,
-    ContestAICmd_unk_35,
-    ContestAICmd_unk_36,
-    ContestAICmd_unk_37,
-    ContestAICmd_unk_38,
-    ContestAICmd_unk_39,
-    ContestAICmd_unk_3A,
-    ContestAICmd_get_move_used_count,
-    ContestAICmd_unk_3C,
-    ContestAICmd_unk_3D,
-    ContestAICmd_unk_3E,
-    ContestAICmd_unk_3F,
-    ContestAICmd_check_combo_starter,
-    ContestAICmd_unk_41,
-    ContestAICmd_unk_42,
-    ContestAICmd_check_combo_finisher,
-    ContestAICmd_unk_44,
-    ContestAICmd_unk_45,
-    ContestAICmd_check_would_finish_combo,
-    ContestAICmd_unk_47,
-    ContestAICmd_unk_48,
-    ContestAICmd_get_condition,
-    ContestAICmd_unk_4A,
-    ContestAICmd_unk_4B,
-    ContestAICmd_unk_4C,
-    ContestAICmd_unk_4D,
-    ContestAICmd_get_used_combo_starter,
-    ContestAICmd_unk_4F,
-    ContestAICmd_unk_50,
-    ContestAICmd_unk_51,
-    ContestAICmd_unk_52,
-    ContestAICmd_check_can_participate,
-    ContestAICmd_unk_54,
-    ContestAICmd_unk_55,
-    ContestAICmd_get_val_812A188,
-    ContestAICmd_unk_57,
-    ContestAICmd_unk_58,
-    ContestAICmd_unk_59,
-    ContestAICmd_unk_5A,
-    ContestAICmd_unk_5B,
-    ContestAICmd_unk_5C,
-    ContestAICmd_unk_5D,
-    ContestAICmd_unk_5E,
-    ContestAICmd_unk_5F,
-    ContestAICmd_unk_60,
-    ContestAICmd_unk_61,
-    ContestAICmd_unk_62,
-    ContestAICmd_unk_63,
-    ContestAICmd_unk_64,
-    ContestAICmd_unk_65,
-    ContestAICmd_unk_66,
-    ContestAICmd_unk_67,
-    ContestAICmd_unk_68,
-    ContestAICmd_unk_69,
-    ContestAICmd_unk_6A,
-    ContestAICmd_unk_6B,
-    ContestAICmd_unk_6C,
-    ContestAICmd_unk_6D,
-    ContestAICmd_unk_6E,
-    ContestAICmd_unk_6F,
-    ContestAICmd_unk_70,
-    ContestAICmd_unk_71,
-    ContestAICmd_unk_72,
-    ContestAICmd_unk_73,
-    ContestAICmd_unk_74,
-    ContestAICmd_unk_75,
-    ContestAICmd_unk_76,
-    ContestAICmd_unk_77,
-    ContestAICmd_unk_78,
-    ContestAICmd_unk_79,
-    ContestAICmd_unk_7A,
-    ContestAICmd_unk_7B,
-    ContestAICmd_unk_7C,
-    ContestAICmd_unk_7D,
-    ContestAICmd_unk_7E,
-    ContestAICmd_unk_7F,
-    ContestAICmd_unk_80,
-    ContestAICmd_unk_81,
-    ContestAICmd_check_for_exciting_move,
-    ContestAICmd_unk_83,
-    ContestAICmd_unk_84,
-    ContestAICmd_unk_85,
-    ContestAICmd_unk_86,
-    ContestAICmd_unk_87,
+    ContestAICmd_unk_00,                          // 0x00
+    ContestAICmd_get_turn,                        // 0x01
+    ContestAICmd_unk_02,                          // 0x02
+    ContestAICmd_unk_03,                          // 0x03
+    ContestAICmd_unk_04,                          // 0x04
+    ContestAICmd_unk_05,                          // 0x05
+    ContestAICmd_get_excitement,                  // 0x06
+    ContestAICmd_unk_07,                          // 0x07
+    ContestAICmd_unk_08,                          // 0x08
+    ContestAICmd_unk_09,                          // 0x09
+    ContestAICmd_unk_0A,                          // 0x0A
+    ContestAICmd_get_user_order,                  // 0x0B
+    ContestAICmd_unk_0C,                          // 0x0C
+    ContestAICmd_unk_0D,                          // 0x0D
+    ContestAICmd_unk_0E,                          // 0x0E
+    ContestAICmd_unk_0F,                          // 0x0F
+    ContestAICmd_get_user_condition_maybe,        // 0x10
+    ContestAICmd_unk_11,                          // 0x11
+    ContestAICmd_unk_12,                          // 0x12
+    ContestAICmd_unk_13,                          // 0x13
+    ContestAICmd_unk_14,                          // 0x14
+    ContestAICmd_unk_15,                          // 0x15
+    ContestAICmd_unk_16,                          // 0x16
+    ContestAICmd_unk_17,                          // 0x17
+    ContestAICmd_unk_18,                          // 0x18
+    ContestAICmd_unk_19,                          // 0x19
+    ContestAICmd_unk_1A,                          // 0x1A
+    ContestAICmd_unk_1B,                          // 0x1B
+    ContestAICmd_unk_1C,                          // 0x1C
+    ContestAICmd_unk_1D,                          // 0x1D
+    ContestAICmd_unk_1E,                          // 0x1E
+    ContestAICmd_get_contest_type,                // 0x1F
+    ContestAICmd_unk_20,                          // 0x20
+    ContestAICmd_unk_21,                          // 0x21
+    ContestAICmd_get_move_excitement,             // 0x22
+    ContestAICmd_unk_23,                          // 0x23
+    ContestAICmd_unk_24,                          // 0x24
+    ContestAICmd_unk_25,                          // 0x25
+    ContestAICmd_unk_26,                          // 0x26
+    ContestAICmd_get_move_effect,                 // 0x27
+    ContestAICmd_unk_28,                          // 0x28
+    ContestAICmd_unk_29,                          // 0x29
+    ContestAICmd_get_move_effect_type,            // 0x2A
+    ContestAICmd_unk_2B,                          // 0x2B
+    ContestAICmd_unk_2C,                          // 0x2C
+    ContestAICmd_check_move_has_highest_appeal,   // 0x2D
+    ContestAICmd_unk_2E,                          // 0x2E
+    ContestAICmd_unk_2F,                          // 0x2F
+    ContestAICmd_unk_30,                          // 0x30
+    ContestAICmd_unk_31,                          // 0x31
+    ContestAICmd_unk_32,                          // 0x32
+    ContestAICmd_unk_33,                          // 0x33
+    ContestAICmd_unk_34,                          // 0x34
+    ContestAICmd_unk_35,                          // 0x35
+    ContestAICmd_unk_36,                          // 0x36
+    ContestAICmd_unk_37,                          // 0x37
+    ContestAICmd_unk_38,                          // 0x38
+    ContestAICmd_unk_39,                          // 0x39
+    ContestAICmd_unk_3A,                          // 0x3A
+    ContestAICmd_get_move_used_count,             // 0x3B
+    ContestAICmd_unk_3C,                          // 0x3C
+    ContestAICmd_unk_3D,                          // 0x3D
+    ContestAICmd_unk_3E,                          // 0x3E
+    ContestAICmd_unk_3F,                          // 0x3F
+    ContestAICmd_check_combo_starter,             // 0x40
+    ContestAICmd_unk_41,                          // 0x41
+    ContestAICmd_unk_42,                          // 0x42
+    ContestAICmd_check_combo_finisher,            // 0x43
+    ContestAICmd_unk_44,                          // 0x44
+    ContestAICmd_unk_45,                          // 0x45
+    ContestAICmd_check_would_finish_combo,        // 0x46
+    ContestAICmd_unk_47,                          // 0x47
+    ContestAICmd_unk_48,                          // 0x48
+    ContestAICmd_get_condition,                   // 0x49
+    ContestAICmd_unk_4A,                          // 0x4A
+    ContestAICmd_unk_4B,                          // 0x4B
+    ContestAICmd_unk_4C,                          // 0x4C
+    ContestAICmd_unk_4D,                          // 0x4D
+    ContestAICmd_get_used_combo_starter,          // 0x4E
+    ContestAICmd_unk_4F,                          // 0x4F
+    ContestAICmd_unk_50,                          // 0x50
+    ContestAICmd_unk_51,                          // 0x51
+    ContestAICmd_unk_52,                          // 0x52
+    ContestAICmd_check_can_participate,           // 0x53
+    ContestAICmd_unk_54,                          // 0x54
+    ContestAICmd_unk_55,                          // 0x55
+    ContestAICmd_get_val_812A188,                 // 0x56
+    ContestAICmd_unk_57,                          // 0x57
+    ContestAICmd_unk_58,                          // 0x58
+    ContestAICmd_unk_59,                          // 0x59
+    ContestAICmd_unk_5A,                          // 0x5A
+    ContestAICmd_unk_5B,                          // 0x5B
+    ContestAICmd_unk_5C,                          // 0x5C
+    ContestAICmd_unk_5D,                          // 0x5D
+    ContestAICmd_unk_5E,                          // 0x5E
+    ContestAICmd_unk_5F,                          // 0x5F
+    ContestAICmd_unk_60,                          // 0x60
+    ContestAICmd_unk_61,                          // 0x61
+    ContestAICmd_unk_62,                          // 0x62
+    ContestAICmd_unk_63,                          // 0x63
+    ContestAICmd_unk_64,                          // 0x64
+    ContestAICmd_unk_65,                          // 0x65
+    ContestAICmd_unk_66,                          // 0x66
+    ContestAICmd_unk_67,                          // 0x67
+    ContestAICmd_unk_68,                          // 0x68
+    ContestAICmd_unk_69,                          // 0x69
+    ContestAICmd_unk_6A,                          // 0x6A
+    ContestAICmd_unk_6B,                          // 0x6B
+    ContestAICmd_unk_6C,                          // 0x6C
+    ContestAICmd_unk_6D,                          // 0x6D
+    ContestAICmd_unk_6E,                          // 0x6E
+    ContestAICmd_unk_6F,                          // 0x6F
+    ContestAICmd_unk_70,                          // 0x70
+    ContestAICmd_unk_71,                          // 0x71
+    ContestAICmd_unk_72,                          // 0x72
+    ContestAICmd_unk_73,                          // 0x73
+    ContestAICmd_unk_74,                          // 0x74
+    ContestAICmd_unk_75,                          // 0x75
+    ContestAICmd_unk_76,                          // 0x76
+    ContestAICmd_unk_77,                          // 0x77
+    ContestAICmd_unk_78,                          // 0x78
+    ContestAICmd_unk_79,                          // 0x79
+    ContestAICmd_unk_7A,                          // 0x7A
+    ContestAICmd_unk_7B,                          // 0x7B
+    ContestAICmd_unk_7C,                          // 0x7C
+    ContestAICmd_unk_7D,                          // 0x7D
+    ContestAICmd_unk_7E,                          // 0x7E
+    ContestAICmd_unk_7F,                          // 0x7F
+    ContestAICmd_unk_80,                          // 0x80
+    ContestAICmd_unk_81,                          // 0x81
+    ContestAICmd_check_for_exciting_move,         // 0x82
+    ContestAICmd_unk_83,                          // 0x83
+    ContestAICmd_unk_84,                          // 0x84
+    ContestAICmd_unk_85,                          // 0x85
+    ContestAICmd_unk_86,                          // 0x86
+    ContestAICmd_unk_87,                          // 0x87
 };
 
 static void ContestAI_DoAIProcessing(void);
@@ -349,13 +342,13 @@ u8 ContestAI_GetActionToUse(void)
 
 static void ContestAI_DoAIProcessing(void)
 {
-    while(eContestAI->aiState != ContestAI_FinishedProcessing)
+    while(eContestAI->aiState != CONTESTAI_FINISHED)
     {
         switch(eContestAI->aiState)
         {
-            case ContestAI_DoNotProcess:
+            case CONTESTAI_DO_NOT_PROCESS:
                 break;
-            case ContestAI_SettingUp:
+            case CONTESTAI_SETTING_UP:
                 gAIScriptPtr = gContestAIs[eContestAI->unk10];
 
                 if(gContestMons[eContestAI->unk41].moves[eContestAI->unk4] == 0)
@@ -364,7 +357,7 @@ static void ContestAI_DoAIProcessing(void)
                     eContestAI->unk2 = gContestMons[eContestAI->unk41].moves[eContestAI->unk4];
                 eContestAI->aiState++;
                 break;
-            case ContestAI_Processing:
+            case CONTESTAI_PROCESSING:
                 if(eContestAI->unk2 != 0)
                     sContestAICmdTable[*gAIScriptPtr](); // run the command.
                 else
@@ -421,7 +414,7 @@ static void ContestAICmd_unk_02(void)
 {
     ContestAICmd_get_turn();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -431,7 +424,7 @@ static void ContestAICmd_unk_03(void)
 {
     ContestAICmd_get_turn();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -441,7 +434,7 @@ static void ContestAICmd_unk_04(void)
 {
     ContestAICmd_get_turn();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -451,7 +444,7 @@ static void ContestAICmd_unk_05(void)
 {
     ContestAICmd_get_turn();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -467,7 +460,7 @@ static void ContestAICmd_unk_07(void)
 {
     ContestAICmd_get_excitement();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -477,7 +470,7 @@ static void ContestAICmd_unk_08(void)
 {
     ContestAICmd_get_excitement();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -487,7 +480,7 @@ static void ContestAICmd_unk_09(void)
 {
     ContestAICmd_get_excitement();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -497,7 +490,7 @@ static void ContestAICmd_unk_0A(void)
 {
     ContestAICmd_get_excitement();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -513,7 +506,7 @@ static void ContestAICmd_unk_0C(void)
 {
     ContestAICmd_get_user_order();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -523,7 +516,7 @@ static void ContestAICmd_unk_0D(void)
 {
     ContestAICmd_get_user_order();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -533,7 +526,7 @@ static void ContestAICmd_unk_0E(void)
 {
     ContestAICmd_get_user_order();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -543,7 +536,7 @@ static void ContestAICmd_unk_0F(void)
 {
     ContestAICmd_get_user_order();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -559,7 +552,7 @@ static void ContestAICmd_unk_11(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -569,7 +562,7 @@ static void ContestAICmd_unk_12(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -579,7 +572,7 @@ static void ContestAICmd_unk_13(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -589,7 +582,7 @@ static void ContestAICmd_unk_14(void)
 {
     ContestAICmd_get_user_condition_maybe();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -605,7 +598,7 @@ static void ContestAICmd_unk_16(void)
 {
     ContestAICmd_unk_15();
 
-    if((s16)eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -615,7 +608,7 @@ static void ContestAICmd_unk_17(void)
 {
     ContestAICmd_unk_15();
 
-    if((s16)eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -625,7 +618,7 @@ static void ContestAICmd_unk_18(void)
 {
     ContestAICmd_unk_15();
 
-    if((s16)eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -635,7 +628,7 @@ static void ContestAICmd_unk_19(void)
 {
     ContestAICmd_unk_15();
 
-    if((s16)eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -651,7 +644,7 @@ static void ContestAICmd_unk_1B(void)
 {
     ContestAICmd_unk_1A();
 
-    if((s16)eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -661,7 +654,7 @@ static void ContestAICmd_unk_1C(void)
 {
     ContestAICmd_unk_1A();
 
-    if((s16)eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -671,7 +664,7 @@ static void ContestAICmd_unk_1D(void)
 {
     ContestAICmd_unk_1A();
 
-    if((s16)eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -681,7 +674,7 @@ static void ContestAICmd_unk_1E(void)
 {
     ContestAICmd_unk_1A();
 
-    if((s16)eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0))
+    if(eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -697,7 +690,7 @@ static void ContestAICmd_unk_20(void)
 {
     ContestAICmd_get_contest_type();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -707,7 +700,7 @@ static void ContestAICmd_unk_21(void)
 {
     ContestAICmd_get_contest_type();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -723,7 +716,7 @@ static void ContestAICmd_unk_23(void)
 {
     ContestAICmd_get_move_excitement();
 
-    if((s16)eContestAI->scriptResult < (s8)gAIScriptPtr[0])
+    if(eContestAI->scriptResult < (s8)gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -733,7 +726,7 @@ static void ContestAICmd_unk_24(void)
 {
     ContestAICmd_get_move_excitement();
 
-    if((s16)eContestAI->scriptResult > (s8)gAIScriptPtr[0])
+    if(eContestAI->scriptResult > (s8)gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -743,7 +736,7 @@ static void ContestAICmd_unk_25(void)
 {
     ContestAICmd_get_move_excitement();
 
-    if((s16)eContestAI->scriptResult == (s8)gAIScriptPtr[0])
+    if(eContestAI->scriptResult == (s8)gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -753,7 +746,7 @@ static void ContestAICmd_unk_26(void)
 {
     ContestAICmd_get_move_excitement();
 
-    if((s16)eContestAI->scriptResult != (s8)gAIScriptPtr[0])
+    if(eContestAI->scriptResult != (s8)gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -771,7 +764,7 @@ static void ContestAICmd_unk_28(void)
 {
     ContestAICmd_get_move_effect();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -781,7 +774,7 @@ static void ContestAICmd_unk_29(void)
 {
     ContestAICmd_get_move_effect();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -799,7 +792,7 @@ static void ContestAICmd_unk_2B(void)
 {
     ContestAICmd_get_move_effect_type();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -809,7 +802,7 @@ static void ContestAICmd_unk_2C(void)
 {
     ContestAICmd_get_move_effect_type();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -840,7 +833,7 @@ static void ContestAICmd_unk_2E(void)
 {
     ContestAICmd_check_move_has_highest_appeal();
 
-    if((s16)eContestAI->scriptResult != FALSE)
+    if(eContestAI->scriptResult != FALSE)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -871,7 +864,7 @@ static void ContestAICmd_unk_30(void)
 {
     ContestAICmd_unk_2F();
 
-    if((s16)eContestAI->scriptResult != FALSE)
+    if(eContestAI->scriptResult != FALSE)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -889,7 +882,7 @@ static void ContestAICmd_unk_32(void)
 {
     ContestAICmd_unk_31();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -899,7 +892,7 @@ static void ContestAICmd_unk_33(void)
 {
     ContestAICmd_unk_31();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -909,7 +902,7 @@ static void ContestAICmd_unk_34(void)
 {
     ContestAICmd_unk_31();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -919,7 +912,7 @@ static void ContestAICmd_unk_35(void)
 {
     ContestAICmd_unk_31();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -937,7 +930,7 @@ static void ContestAICmd_unk_37(void)
 {
     ContestAICmd_unk_36();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -947,7 +940,7 @@ static void ContestAICmd_unk_38(void)
 {
     ContestAICmd_unk_36();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -957,7 +950,7 @@ static void ContestAICmd_unk_39(void)
 {
     ContestAICmd_unk_36();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -967,7 +960,7 @@ static void ContestAICmd_unk_3A(void)
 {
     ContestAICmd_unk_36();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -991,7 +984,7 @@ static void ContestAICmd_unk_3C(void)
 {
     ContestAICmd_get_move_used_count();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1001,7 +994,7 @@ static void ContestAICmd_unk_3D(void)
 {
     ContestAICmd_get_move_used_count();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1011,7 +1004,7 @@ static void ContestAICmd_unk_3E(void)
 {
     ContestAICmd_get_move_used_count();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1021,7 +1014,7 @@ static void ContestAICmd_unk_3F(void)
 {
     ContestAICmd_get_move_used_count();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1057,7 +1050,7 @@ static void ContestAICmd_unk_41(void)
 {
     ContestAICmd_check_combo_starter();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1067,7 +1060,7 @@ static void ContestAICmd_unk_42(void)
 {
     ContestAICmd_check_combo_starter();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1103,7 +1096,7 @@ static void ContestAICmd_unk_44(void)
 {
     ContestAICmd_check_combo_finisher();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1113,7 +1106,7 @@ static void ContestAICmd_unk_45(void)
 {
     ContestAICmd_check_combo_finisher();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1138,7 +1131,7 @@ static void ContestAICmd_unk_47(void)
 {
     ContestAICmd_check_would_finish_combo();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1148,7 +1141,7 @@ static void ContestAICmd_unk_48(void)
 {
     ContestAICmd_check_would_finish_combo();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1166,7 +1159,7 @@ static void ContestAICmd_unk_4A(void)
 {
     ContestAICmd_get_condition();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1176,7 +1169,7 @@ static void ContestAICmd_unk_4B(void)
 {
     ContestAICmd_get_condition();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1186,7 +1179,7 @@ static void ContestAICmd_unk_4C(void)
 {
     ContestAICmd_get_condition();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1196,7 +1189,7 @@ static void ContestAICmd_unk_4D(void)
 {
     ContestAICmd_get_condition();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1218,7 +1211,7 @@ static void ContestAICmd_unk_4F(void)
 {
     ContestAICmd_get_used_combo_starter();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1228,7 +1221,7 @@ static void ContestAICmd_unk_50(void)
 {
     ContestAICmd_get_used_combo_starter();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1238,7 +1231,7 @@ static void ContestAICmd_unk_51(void)
 {
     ContestAICmd_get_used_combo_starter();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1248,7 +1241,7 @@ static void ContestAICmd_unk_52(void)
 {
     ContestAICmd_get_used_combo_starter();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1268,7 +1261,7 @@ static void ContestAICmd_unk_54(void)
 {
     ContestAICmd_check_can_participate();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1278,7 +1271,7 @@ static void ContestAICmd_unk_55(void)
 {
     ContestAICmd_check_can_participate();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1296,7 +1289,7 @@ static void ContestAICmd_unk_57(void)
 {
     ContestAICmd_get_val_812A188();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1306,7 +1299,7 @@ static void ContestAICmd_unk_58(void)
 {
     ContestAICmd_get_val_812A188();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1324,7 +1317,7 @@ static void ContestAICmd_unk_5A(void)
 {
     ContestAICmd_unk_59();
 
-    if((s16)eContestAI->scriptResult < 0)
+    if(eContestAI->scriptResult < 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1334,7 +1327,7 @@ static void ContestAICmd_unk_5B(void)
 {
     ContestAICmd_unk_59();
 
-    if((s16)eContestAI->scriptResult > 0)
+    if(eContestAI->scriptResult > 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1344,7 +1337,7 @@ static void ContestAICmd_unk_5C(void)
 {
     ContestAICmd_unk_59();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1354,7 +1347,7 @@ static void ContestAICmd_unk_5D(void)
 {
     ContestAICmd_unk_59();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1372,7 +1365,7 @@ static void ContestAICmd_unk_5F(void)
 {
     ContestAICmd_unk_5E();
 
-    if((s16)eContestAI->scriptResult < 0)
+    if(eContestAI->scriptResult < 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1382,7 +1375,7 @@ static void ContestAICmd_unk_60(void)
 {
     ContestAICmd_unk_5E();
 
-    if((s16)eContestAI->scriptResult > 0)
+    if(eContestAI->scriptResult > 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1392,7 +1385,7 @@ static void ContestAICmd_unk_61(void)
 {
     ContestAICmd_unk_5E();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1402,7 +1395,7 @@ static void ContestAICmd_unk_62(void)
 {
     ContestAICmd_unk_5E();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1422,7 +1415,7 @@ static void ContestAICmd_unk_64(void)
 {
     ContestAICmd_unk_63();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1432,7 +1425,7 @@ static void ContestAICmd_unk_65(void)
 {
     ContestAICmd_unk_63();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1442,7 +1435,7 @@ static void ContestAICmd_unk_66(void)
 {
     ContestAICmd_unk_63();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1452,7 +1445,7 @@ static void ContestAICmd_unk_67(void)
 {
     ContestAICmd_unk_63();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1472,7 +1465,7 @@ static void ContestAICmd_unk_69(void)
 {
     ContestAICmd_unk_68();
 
-    if((s16)eContestAI->scriptResult < gAIScriptPtr[0])
+    if(eContestAI->scriptResult < gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1482,7 +1475,7 @@ static void ContestAICmd_unk_6A(void)
 {
     ContestAICmd_unk_68();
 
-    if((s16)eContestAI->scriptResult > gAIScriptPtr[0])
+    if(eContestAI->scriptResult > gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1492,7 +1485,7 @@ static void ContestAICmd_unk_6B(void)
 {
     ContestAICmd_unk_68();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1502,7 +1495,7 @@ static void ContestAICmd_unk_6C(void)
 {
     ContestAICmd_unk_68();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1522,7 +1515,7 @@ static void ContestAICmd_unk_6E(void)
 {
     ContestAICmd_unk_6D();
 
-    if((s16)eContestAI->scriptResult == gAIScriptPtr[0])
+    if(eContestAI->scriptResult == gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1532,7 +1525,7 @@ static void ContestAICmd_unk_6F(void)
 {
     ContestAICmd_unk_6D();
 
-    if((s16)eContestAI->scriptResult != gAIScriptPtr[0])
+    if(eContestAI->scriptResult != gAIScriptPtr[0])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1713,7 +1706,7 @@ static void ContestAICmd_unk_83(void)
 {
     ContestAICmd_check_for_exciting_move();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1723,7 +1716,7 @@ static void ContestAICmd_unk_84(void)
 {
     ContestAICmd_check_for_exciting_move();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1753,7 +1746,7 @@ static void ContestAICmd_unk_86(void)
 {
     ContestAICmd_unk_85();
 
-    if((s16)eContestAI->scriptResult != 0)
+    if(eContestAI->scriptResult != 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
@@ -1763,7 +1756,7 @@ static void ContestAICmd_unk_87(void)
 {
     ContestAICmd_unk_85();
 
-    if((s16)eContestAI->scriptResult == 0)
+    if(eContestAI->scriptResult == 0)
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0);
     else
         gAIScriptPtr += 4;
-- 
cgit v1.2.3


From a5403f03dd49711f8c2f719e8bfa8a83f427563c Mon Sep 17 00:00:00 2001
From: ProjectRevoTPP <projectrevotpp@hotmail.com>
Date: Sun, 14 Jan 2018 14:16:40 -0500
Subject: scriptArr to s16

---
 src/contest_ai.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'src')

diff --git a/src/contest_ai.c b/src/contest_ai.c
index 0c1126ac5..66b387270 100755
--- a/src/contest_ai.c
+++ b/src/contest_ai.c
@@ -1564,7 +1564,7 @@ static void ContestAICmd_unk_74(void)
 
 static void ContestAICmd_unk_75(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] < T1_READ_16(gAIScriptPtr + 2))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] < T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
     else
         gAIScriptPtr += 8;
@@ -1572,7 +1572,7 @@ static void ContestAICmd_unk_75(void)
 
 static void ContestAICmd_unk_76(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] > T1_READ_16(gAIScriptPtr + 2))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] > T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
     else
         gAIScriptPtr += 8;
@@ -1580,7 +1580,7 @@ static void ContestAICmd_unk_76(void)
 
 static void ContestAICmd_unk_77(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] == T1_READ_16(gAIScriptPtr + 2))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] == T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
     else
         gAIScriptPtr += 8;
@@ -1588,7 +1588,7 @@ static void ContestAICmd_unk_77(void)
 
 static void ContestAICmd_unk_78(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] != T1_READ_16(gAIScriptPtr + 2))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] != T1_READ_16(gAIScriptPtr + 2))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
     else
         gAIScriptPtr += 8;
@@ -1596,7 +1596,7 @@ static void ContestAICmd_unk_78(void)
 
 static void ContestAICmd_unk_79(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] < ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] < (eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
     else
         gAIScriptPtr += 7;
@@ -1604,7 +1604,7 @@ static void ContestAICmd_unk_79(void)
 
 static void ContestAICmd_unk_7A(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] > ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] > (eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
     else
         gAIScriptPtr += 7;
@@ -1612,7 +1612,7 @@ static void ContestAICmd_unk_7A(void)
 
 static void ContestAICmd_unk_7B(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] == ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] == (eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
     else
         gAIScriptPtr += 7;
@@ -1620,7 +1620,7 @@ static void ContestAICmd_unk_7B(void)
 
 static void ContestAICmd_unk_7C(void)
 {
-    if((s16)eContestAI->scriptArr[gAIScriptPtr[1]] != ((s16)eContestAI->scriptArr[gAIScriptPtr[2]]))
+    if(eContestAI->scriptArr[gAIScriptPtr[1]] != (eContestAI->scriptArr[gAIScriptPtr[2]]))
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
     else
         gAIScriptPtr += 7;
@@ -1628,7 +1628,7 @@ static void ContestAICmd_unk_7C(void)
 
 static void ContestAICmd_unk_7D(void)
 {
-    if((Random() & 0xFF) < (s16)eContestAI->scriptArr[gAIScriptPtr[1]])
+    if((Random() & 0xFF) < eContestAI->scriptArr[gAIScriptPtr[1]])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -1636,7 +1636,7 @@ static void ContestAICmd_unk_7D(void)
 
 static void ContestAICmd_unk_7E(void)
 {
-    if((Random() & 0xFF) > (s16)eContestAI->scriptArr[gAIScriptPtr[1]])
+    if((Random() & 0xFF) > eContestAI->scriptArr[gAIScriptPtr[1]])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
-- 
cgit v1.2.3