From 200e8214cf6cb9b69e7e619bb7263d70896eb03b Mon Sep 17 00:00:00 2001
From: Marcus Huderle <huderlem@gmail.com>
Date: Sun, 28 Feb 2021 10:43:56 -0600
Subject: [PATCH] Document GetOpponentMostCommonMonType and fix its fake
 matching

---
 src/battle_factory.c | 53 ++++++++++++++++++++++++++++++--------------
 1 file changed, 36 insertions(+), 17 deletions(-)

diff --git a/src/battle_factory.c b/src/battle_factory.c
index 9ba13b0d32..72772929a9 100644
--- a/src/battle_factory.c
+++ b/src/battle_factory.c
@@ -592,39 +592,58 @@ static void GenerateInitialRentalMons(void)
     }
 }
 
+// Determines if the upcoming opponent has a single most-common
+// type in its party. If there are two different types that are
+// tied, then the opponent is deemed to have no preferred type,
+// and NUMBER_OF_MON_TYPES is the result.
 static void GetOpponentMostCommonMonType(void)
 {
     u8 i;
-    u8 typesCount[NUMBER_OF_MON_TYPES];
-    u8 usedType[2];
+    u8 typeCounts[NUMBER_OF_MON_TYPES];
+    u8 mostCommonTypes[2];
 
     gFacilityTrainerMons = gBattleFrontierMons;
-    for (i = 0; i < NUMBER_OF_MON_TYPES; i++)
-        typesCount[i] = 0;
+
+    // Count the number of times each type occurs in the opponent's party.
+    for (i = TYPE_NORMAL; i < NUMBER_OF_MON_TYPES; i++)
+        typeCounts[i] = 0;
     for (i = 0; i < FRONTIER_PARTY_SIZE; i++)
     {
         u32 species = gFacilityTrainerMons[gFrontierTempParty[i]].species;
-
-        typesCount[gBaseStats[species].type1]++;
+        typeCounts[gBaseStats[species].type1]++;
         if (gBaseStats[species].type1 != gBaseStats[species].type2)
-            typesCount[gBaseStats[species].type2]++;
+            typeCounts[gBaseStats[species].type2]++;
     }
 
-    usedType[0] = 0;
-    usedType[1] = 0;
-    for (i = 1; i < NUMBER_OF_MON_TYPES; i++)
+    // Determine which are the two most-common types.
+    // The second most-common type is only updated if
+    // its count is equal to the most-common type.
+    mostCommonTypes[0] = TYPE_NORMAL;
+    mostCommonTypes[1] = TYPE_NORMAL;
+    for (i = TYPE_FIGHTING; i < NUMBER_OF_MON_TYPES; i++)
     {
-        if (typesCount[usedType[0]] < typesCount[i])
-            usedType[0] = i;
-        else if (typesCount[usedType[0]] == typesCount[i])
-            usedType[1] = i;
+        if (typeCounts[mostCommonTypes[0]] < typeCounts[i])
+            mostCommonTypes[0] = i;
+        else if (typeCounts[mostCommonTypes[0]] == typeCounts[i])
+            mostCommonTypes[1] = i;
     }
 
-    gSpecialVar_Result = gSpecialVar_Result; // Needed to match. Don't ask me why.
-    if (typesCount[usedType[0]] != 0 && (typesCount[usedType[0]] > typesCount[usedType[1]] || usedType[0] == usedType[1]))
-        gSpecialVar_Result = usedType[0];
+    if (typeCounts[mostCommonTypes[0]] != 0)
+    {
+        // The most-common type must be strictly greater than
+        // the second-most-common type, or the top two must be
+        // the same type.
+        if (typeCounts[mostCommonTypes[0]] > typeCounts[mostCommonTypes[1]])
+            gSpecialVar_Result = mostCommonTypes[0];
+        else if (mostCommonTypes[0] == mostCommonTypes[1])
+            gSpecialVar_Result = mostCommonTypes[0];
+        else
+            gSpecialVar_Result = NUMBER_OF_MON_TYPES;
+    }
     else
+    {
         gSpecialVar_Result = NUMBER_OF_MON_TYPES;
+    }
 }
 
 static void GetOpponentBattleStyle(void)