Merge branch 'master' of https://github.com/pret/pokeemerald into menu

src/battle_ai_script_commands.c

@@ -45,19 +45,19 @@ AI scripts.
 */
 
 extern u32 gBattleTypeFlags;
-extern u8 gActiveBank;
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
+extern u8 gActiveBattler;
+extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
 extern u16 gCurrentMove;
-extern u8 gBankTarget;
-extern u8 gAbsentBankFlags;
-extern u16 gLastMoves[BATTLE_BANKS_COUNT];
+extern u8 gBattlerTarget;
+extern u8 gAbsentBattlerFlags;
+extern u16 gLastMoves[MAX_BATTLERS_COUNT];
 extern u16 gTrainerBattleOpponent_A;
 extern u16 gTrainerBattleOpponent_B;
-extern u32 gStatuses3[BATTLE_BANKS_COUNT];
-extern u16 gSideAffecting[2];
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern u32 gStatuses3[MAX_BATTLERS_COUNT];
+extern u16 gSideStatuses[2];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
 extern u16 gDynamicBasePower;
-extern u8 gBattleMoveFlags;
+extern u8 gMoveResultFlags;
 extern s32 gBattleMoveDamage;
 extern u8 gCritMultiplier;
 extern u16 gBattleWeather;
@@ -179,7 +179,7 @@ static void BattleAICmd_if_holds_item(void);
 // ewram
 
 EWRAM_DATA const u8 *gAIScriptPtr = NULL;
-EWRAM_DATA static u8 sBank_AI = 0;
+EWRAM_DATA static u8 sBattler_AI = 0;
 
 // const rom data
 
@@ -352,7 +352,7 @@ void BattleAI_SetupAIData(u8 defaultScoreMoves)
         defaultScoreMoves >>= 1;
     }
 
-    moveLimitations = CheckMoveLimitations(gActiveBank, 0, 0xFF);
+    moveLimitations = CheckMoveLimitations(gActiveBattler, 0, 0xFF);
 
     // ignore moves that aren't possible to use
     for (i = 0; i < 4; i++)
@@ -363,18 +363,18 @@ void BattleAI_SetupAIData(u8 defaultScoreMoves)
         AI_THINKING_STRUCT->simulatedRNG[i] = 100 - (Random() % 16);
     }
     gBattleResources->AI_ScriptsStack->size = 0;
-    sBank_AI = gActiveBank;
+    sBattler_AI = gActiveBattler;
     // decide a random target bank in doubles
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
-        gBankTarget = (Random() & BIT_MON) + (GetBankSide(gActiveBank) ^ BIT_SIDE);
-        if (gAbsentBankFlags & gBitTable[gBankTarget])
-            gBankTarget ^= BIT_MON;
+        gBattlerTarget = (Random() & BIT_FLANK) + (GetBattlerSide(gActiveBattler) ^ BIT_SIDE);
+        if (gAbsentBattlerFlags & gBitTable[gBattlerTarget])
+            gBattlerTarget ^= BIT_FLANK;
     }
     // in singles there's only one choice
     else
     {
-        gBankTarget = sBank_AI ^ BIT_SIDE;
+        gBattlerTarget = sBattler_AI ^ BIT_SIDE;
     }
 
     if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
@@ -444,7 +444,7 @@ static u8 BattleAI_ChooseMoveOrAction_Singles(void)
 
     for (i = 1; i < 4; i++)
     {
-        if (gBattleMons[sBank_AI].moves[i] != 0) // emerald adds an extra move ID check for some reason.
+        if (gBattleMons[sBattler_AI].moves[i] != 0) // emerald adds an extra move ID check for some reason.
         {
             // in ruby, the order of these if statements are reversed.
             if (currentMoveArray[0] == AI_THINKING_STRUCT->score[i])
@@ -479,7 +479,7 @@ static u8 BattleAI_ChooseMoveOrAction_Doubles(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (i == sBank_AI || gBattleMons[i].hp == 0)
+        if (i == sBattler_AI || gBattleMons[i].hp == 0)
         {
             actionOrMoveIndex[i] = -1;
             bestMovePointsForTarget[i] = -1;
@@ -491,9 +491,9 @@ static u8 BattleAI_ChooseMoveOrAction_Doubles(void)
             else
                 BattleAI_SetupAIData(0xF);
 
-            gBankTarget = i;
+            gBattlerTarget = i;
 
-            if ((i & BIT_SIDE) != (sBank_AI & BIT_SIDE))
+            if ((i & BIT_SIDE) != (sBattler_AI & BIT_SIDE))
                 RecordLastUsedMoveByTarget();
 
             AI_THINKING_STRUCT->aiLogicId = 0;
@@ -521,7 +521,7 @@ static u8 BattleAI_ChooseMoveOrAction_Doubles(void)
                 mostViableMovesNo = 1;
                 for (j = 1; j < 4; j++)
                 {
-                    if (gBattleMons[sBank_AI].moves[j] != 0)
+                    if (gBattleMons[sBattler_AI].moves[j] != 0)
                     {
                         if (mostViableMovesScores[0] == AI_THINKING_STRUCT->score[j])
                         {
@@ -542,7 +542,7 @@ static u8 BattleAI_ChooseMoveOrAction_Doubles(void)
                 bestMovePointsForTarget[i] = mostViableMovesScores[0];
 
                 // don't use a move against ally if it has less than 100 pts
-                if (i == (sBank_AI ^ BIT_MON) && bestMovePointsForTarget[i] < 100)
+                if (i == (sBattler_AI ^ BIT_FLANK) && bestMovePointsForTarget[i] < 100)
                 {
                     bestMovePointsForTarget[i] = -1;
                     mostViableMovesScores[0] = mostViableMovesScores[0]; // needed to match
@@ -573,8 +573,8 @@ static u8 BattleAI_ChooseMoveOrAction_Doubles(void)
         }
     }
 
-    gBankTarget = mostViableTargetsArray[Random() % mostViableTargetsNo];
-    return actionOrMoveIndex[gBankTarget];
+    gBattlerTarget = mostViableTargetsArray[Random() % mostViableTargetsNo];
+    return actionOrMoveIndex[gBattlerTarget];
 }
 
 static void BattleAI_DoAIProcessing(void)
@@ -587,13 +587,13 @@ static void BattleAI_DoAIProcessing(void)
                 break;
             case AIState_SettingUp:
                 gAIScriptPtr = gBattleAI_ScriptsTable[AI_THINKING_STRUCT->aiLogicId]; // set AI ptr to logic ID.
-                if (gBattleMons[sBank_AI].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
+                if (gBattleMons[sBattler_AI].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
                 {
                     AI_THINKING_STRUCT->moveConsidered = 0;
                 }
                 else
                 {
-                    AI_THINKING_STRUCT->moveConsidered = gBattleMons[sBank_AI].moves[AI_THINKING_STRUCT->movesetIndex];
+                    AI_THINKING_STRUCT->moveConsidered = gBattleMons[sBattler_AI].moves[AI_THINKING_STRUCT->movesetIndex];
                 }
                 AI_THINKING_STRUCT->aiState++;
                 break;
@@ -627,18 +627,18 @@ static void RecordLastUsedMoveByTarget(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (gBattleResources->battleHistory->usedMoves[gBankTarget].moves[i] == gLastMoves[gBankTarget])
+        if (gBattleResources->battleHistory->usedMoves[gBattlerTarget].moves[i] == gLastMoves[gBattlerTarget])
             break;
-        if (gBattleResources->battleHistory->usedMoves[gBankTarget].moves[i] != gLastMoves[gBankTarget]  // HACK: This redundant condition is a hack to make the asm match.
-         && gBattleResources->battleHistory->usedMoves[gBankTarget].moves[i] == 0)
+        if (gBattleResources->battleHistory->usedMoves[gBattlerTarget].moves[i] != gLastMoves[gBattlerTarget]  // HACK: This redundant condition is a hack to make the asm match.
+         && gBattleResources->battleHistory->usedMoves[gBattlerTarget].moves[i] == 0)
         {
-            gBattleResources->battleHistory->usedMoves[gBankTarget].moves[i] = gLastMoves[gBankTarget];
+            gBattleResources->battleHistory->usedMoves[gBattlerTarget].moves[i] = gLastMoves[gBattlerTarget];
             break;
         }
     }
 }
 
-void ClearBankMoveHistory(u8 bank)
+void ClearBattlerMoveHistory(u8 bank)
 {
     s32 i;
 
@@ -651,7 +651,7 @@ void RecordAbilityBattle(u8 bank, u8 abilityId)
     gBattleResources->battleHistory->abilities[bank] = abilityId;
 }
 
-void ClearBankAbilityHistory(u8 bank)
+void ClearBattlerAbilityHistory(u8 bank)
 {
     gBattleResources->battleHistory->abilities[bank] = 0;
 }
@@ -721,9 +721,9 @@ static void BattleAICmd_if_hp_less_than(void)
     u16 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if ((u32)(100 * gBattleMons[bank].hp / gBattleMons[bank].maxHP) < gAIScriptPtr[2])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 3);
@@ -736,9 +736,9 @@ static void BattleAICmd_if_hp_more_than(void)
     u16 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if ((u32)(100 * gBattleMons[bank].hp / gBattleMons[bank].maxHP) > gAIScriptPtr[2])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 3);
@@ -751,9 +751,9 @@ static void BattleAICmd_if_hp_equal(void)
     u16 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if ((u32)(100 * gBattleMons[bank].hp / gBattleMons[bank].maxHP) == gAIScriptPtr[2])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 3);
@@ -766,9 +766,9 @@ static void BattleAICmd_if_hp_not_equal(void)
     u16 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if ((u32)(100 * gBattleMons[bank].hp / gBattleMons[bank].maxHP) != gAIScriptPtr[2])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 3);
@@ -782,9 +782,9 @@ static void BattleAICmd_if_status(void)
     u32 status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     status = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -800,9 +800,9 @@ static void BattleAICmd_if_not_status(void)
     u32 status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     status = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -818,9 +818,9 @@ static void BattleAICmd_if_status2(void)
     u32 status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     status = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -836,9 +836,9 @@ static void BattleAICmd_if_not_status2(void)
     u32 status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     status = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -854,9 +854,9 @@ static void BattleAICmd_if_status3(void)
     u32 status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     status = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -872,9 +872,9 @@ static void BattleAICmd_if_not_status3(void)
     u32 status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     status = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -890,14 +890,14 @@ static void BattleAICmd_if_side_affecting(void)
     u32 side, status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
-    side = GET_BANK_SIDE(bank);
+    side = GET_BATTLER_SIDE(bank);
     status = AIScriptRead32(gAIScriptPtr + 2);
 
-    if ((gSideAffecting[side] & status) != 0)
+    if ((gSideStatuses[side] & status) != 0)
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 6);
     else
         gAIScriptPtr += 10;
@@ -909,14 +909,14 @@ static void BattleAICmd_if_not_side_affecting(void)
     u32 side, status;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
-    side = GET_BANK_SIDE(bank);
+    side = GET_BATTLER_SIDE(bank);
     status = AIScriptRead32(gAIScriptPtr + 2);
 
-    if ((gSideAffecting[side] & status) == 0)
+    if ((gSideStatuses[side] & status) == 0)
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 6);
     else
         gAIScriptPtr += 10;
@@ -1084,8 +1084,8 @@ static void BattleAICmd_if_user_has_attacking_move(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (gBattleMons[sBank_AI].moves[i] != 0
-            && gBattleMoves[gBattleMons[sBank_AI].moves[i]].power != 0)
+        if (gBattleMons[sBattler_AI].moves[i] != 0
+            && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
             break;
     }
     if (i == 4)
@@ -1100,8 +1100,8 @@ static void BattleAICmd_if_user_has_no_attacking_moves(void)
 
     for (i = 0; i < 4; i++)
     {
-        if (gBattleMons[sBank_AI].moves[i] != 0
-         && gBattleMoves[gBattleMons[sBank_AI].moves[i]].power != 0)
+        if (gBattleMons[sBattler_AI].moves[i] != 0
+         && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
             break;
     }
     if (i != 4)
@@ -1123,16 +1123,16 @@ static void BattleAICmd_get_type(void)
     switch (typeVar)
     {
     case AI_TYPE1_USER: // AI user primary type
-        AI_THINKING_STRUCT->funcResult = gBattleMons[sBank_AI].type1;
+        AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type1;
         break;
     case AI_TYPE1_TARGET: // target primary type
-        AI_THINKING_STRUCT->funcResult = gBattleMons[gBankTarget].type1;
+        AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type1;
         break;
     case AI_TYPE2_USER: // AI user secondary type
-        AI_THINKING_STRUCT->funcResult = gBattleMons[sBank_AI].type2;
+        AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type2;
         break;
     case AI_TYPE2_TARGET: // target secondary type
-        AI_THINKING_STRUCT->funcResult = gBattleMons[gBankTarget].type2;
+        AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type2;
         break;
     case AI_TYPE_MOVE: // type of move being pointed to
         AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].type;
@@ -1146,14 +1146,14 @@ static u8 BattleAI_GetWantedBank(u8 bank)
     switch (bank)
     {
         case AI_USER:
-            return sBank_AI;
+            return sBattler_AI;
         case AI_TARGET:
         default:
-            return gBankTarget;
+            return gBattlerTarget;
         case AI_USER_PARTNER:
-            return sBank_AI ^ BIT_MON;
+            return sBattler_AI ^ BIT_FLANK;
         case AI_TARGET_PARTNER:
-            return gBankTarget ^ BIT_MON;
+            return gBattlerTarget ^ BIT_FLANK;
     }
 }
 
@@ -1196,24 +1196,24 @@ static void BattleAICmd_get_how_powerful_move_is(void)
         gDynamicBasePower = 0;
         *(&gBattleStruct->dynamicMoveType) = 0;
         gBattleScripting.dmgMultiplier = 1;
-        gBattleMoveFlags = 0;
+        gMoveResultFlags = 0;
         gCritMultiplier = 1;
 
         for (checkedMove = 0; checkedMove < 4; checkedMove++)
         {
             for (i = 0; sDiscouragedPowerfulMoveEffects[i] != 0xFFFF; i++)
             {
-                if (gBattleMoves[gBattleMons[sBank_AI].moves[checkedMove]].effect == sDiscouragedPowerfulMoveEffects[i])
+                if (gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].effect == sDiscouragedPowerfulMoveEffects[i])
                     break;
             }
 
-            if (gBattleMons[sBank_AI].moves[checkedMove] != MOVE_NONE
+            if (gBattleMons[sBattler_AI].moves[checkedMove] != MOVE_NONE
                 && sDiscouragedPowerfulMoveEffects[i] == 0xFFFF
-                && gBattleMoves[gBattleMons[sBank_AI].moves[checkedMove]].power > 1)
+                && gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].power > 1)
             {
-                gCurrentMove = gBattleMons[sBank_AI].moves[checkedMove];
-                AI_CalcDmg(sBank_AI, gBankTarget);
-                TypeCalc(gCurrentMove, sBank_AI, gBankTarget);
+                gCurrentMove = gBattleMons[sBattler_AI].moves[checkedMove];
+                AI_CalcDmg(sBattler_AI, gBattlerTarget);
+                TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
                 moveDmgs[checkedMove] = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[checkedMove] / 100;
                 if (moveDmgs[checkedMove] == 0)
                     moveDmgs[checkedMove] = 1;
@@ -1246,9 +1246,9 @@ static void BattleAICmd_get_how_powerful_move_is(void)
 static void BattleAICmd_get_last_used_bank_move(void)
 {
     if (gAIScriptPtr[1] == AI_USER)
-        AI_THINKING_STRUCT->funcResult = gLastMoves[sBank_AI];
+        AI_THINKING_STRUCT->funcResult = gLastMoves[sBattler_AI];
     else
-        AI_THINKING_STRUCT->funcResult = gLastMoves[gBankTarget];
+        AI_THINKING_STRUCT->funcResult = gLastMoves[gBattlerTarget];
 
     gAIScriptPtr += 2;
 }
@@ -1271,7 +1271,7 @@ static void BattleAICmd_if_not_equal_(void) // same as if_not_equal
 
 static void BattleAICmd_if_user_goes(void)
 {
-    if (GetWhoStrikesFirst(sBank_AI, gBankTarget, TRUE) == gAIScriptPtr[1])
+    if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) == gAIScriptPtr[1])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -1279,7 +1279,7 @@ static void BattleAICmd_if_user_goes(void)
 
 static void BattleAICmd_if_user_doesnt_go(void)
 {
-    if (GetWhoStrikesFirst(sBank_AI, gBankTarget, TRUE) != gAIScriptPtr[1])
+    if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) != gAIScriptPtr[1])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -1303,26 +1303,26 @@ static void BattleAICmd_count_usable_party_mons(void)
     AI_THINKING_STRUCT->funcResult = 0;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
-    if (GetBankSide(bank) == SIDE_PLAYER)
+    if (GetBattlerSide(bank) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
 
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
-        u32 identity;
-        bankOnField1 = gBattlePartyID[bank];
-        identity = GetBankIdentity(bank) ^ BIT_MON;
-        bankOnField2 = gBattlePartyID[GetBankByIdentity(identity)];
+        u32 position;
+        bankOnField1 = gBattlerPartyIndexes[bank];
+        position = GetBattlerPosition(bank) ^ BIT_FLANK;
+        bankOnField2 = gBattlerPartyIndexes[GetBattlerAtPosition(position)];
     }
     else // in singles there's only one bank by side
     {
-        bankOnField1 = gBattlePartyID[bank];
-        bankOnField2 = gBattlePartyID[bank];
+        bankOnField1 = gBattlerPartyIndexes[bank];
+        bankOnField2 = gBattlerPartyIndexes[bank];
     }
 
     for (i = 0; i < PARTY_SIZE; i++)
@@ -1356,11 +1356,11 @@ static void BattleAICmd_get_ability(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
-    if (gActiveBank != bank)
+    if (gActiveBattler != bank)
     {
         if (BATTLE_HISTORY->abilities[bank] != 0)
         {
@@ -1482,18 +1482,18 @@ static void BattleAICmd_get_highest_type_effectiveness(void)
     dynamicMoveType = &gBattleStruct->dynamicMoveType;
     *dynamicMoveType = 0;
     gBattleScripting.dmgMultiplier = 1;
-    gBattleMoveFlags = 0;
+    gMoveResultFlags = 0;
     gCritMultiplier = 1;
     AI_THINKING_STRUCT->funcResult = 0;
 
     for (i = 0; i < 4; i++)
     {
         gBattleMoveDamage = AI_EFFECTIVENESS_x1;
-        gCurrentMove = gBattleMons[sBank_AI].moves[i];
+        gCurrentMove = gBattleMons[sBattler_AI].moves[i];
 
         if (gCurrentMove)
         {
-            TypeCalc(gCurrentMove, sBank_AI, gBankTarget);
+            TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
 
             // reduce by 1/3.
             if (gBattleMoveDamage == 120)
@@ -1505,7 +1505,7 @@ static void BattleAICmd_get_highest_type_effectiveness(void)
             if (gBattleMoveDamage == 15)
                 gBattleMoveDamage = AI_EFFECTIVENESS_x0_25;
 
-            if (gBattleMoveFlags & MOVESTATUS_NOTAFFECTED)
+            if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
                 gBattleMoveDamage = AI_EFFECTIVENESS_x0;
 
             if (AI_THINKING_STRUCT->funcResult < gBattleMoveDamage)
@@ -1522,13 +1522,13 @@ static void BattleAICmd_if_type_effectiveness(void)
     gDynamicBasePower = 0;
     gBattleStruct->dynamicMoveType = 0;
     gBattleScripting.dmgMultiplier = 1;
-    gBattleMoveFlags = 0;
+    gMoveResultFlags = 0;
     gCritMultiplier = 1;
 
     gBattleMoveDamage = AI_EFFECTIVENESS_x1;
     gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
 
-    TypeCalc(gCurrentMove, sBank_AI, gBankTarget);
+    TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
 
     if (gBattleMoveDamage == 120)
         gBattleMoveDamage = AI_EFFECTIVENESS_x2;
@@ -1539,7 +1539,7 @@ static void BattleAICmd_if_type_effectiveness(void)
     if (gBattleMoveDamage == 15)
         gBattleMoveDamage = AI_EFFECTIVENESS_x0_25;
 
-    if (gBattleMoveFlags & MOVESTATUS_NOTAFFECTED)
+    if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
         gBattleMoveDamage = AI_EFFECTIVENESS_x0;
 
     // store gBattleMoveDamage in a u8 variable because gAIScriptPtr[1] is a u8.
@@ -1569,14 +1569,14 @@ static void BattleAICmd_if_status_in_party(void)
     switch(gAIScriptPtr[1])
     {
         case AI_USER:
-            bank = sBank_AI;
+            bank = sBattler_AI;
             break;
         default:
-            bank = gBankTarget;
+            bank = gBattlerTarget;
             break;
     }
 
-    party = (GetBankSide(bank) == SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
+    party = (GetBattlerSide(bank) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
 
     statusToCompareTo = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -1606,14 +1606,14 @@ static void BattleAICmd_if_status_not_in_party(void)
     switch(gAIScriptPtr[1])
     {
         case 1:
-            bank = sBank_AI;
+            bank = sBattler_AI;
             break;
         default:
-            bank = gBankTarget;
+            bank = gBattlerTarget;
             break;
     }
 
-    party = (GetBankSide(bank) == SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
+    party = (GetBattlerSide(bank) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
 
     statusToCompareTo = AIScriptRead32(gAIScriptPtr + 2);
 
@@ -1667,9 +1667,9 @@ static void BattleAICmd_if_stat_level_less_than(void)
     u32 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if (gBattleMons[bank].statStages[gAIScriptPtr[2]] < gAIScriptPtr[3])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 4);
@@ -1682,9 +1682,9 @@ static void BattleAICmd_if_stat_level_more_than(void)
     u32 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if (gBattleMons[bank].statStages[gAIScriptPtr[2]] > gAIScriptPtr[3])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 4);
@@ -1697,9 +1697,9 @@ static void BattleAICmd_if_stat_level_equal(void)
     u32 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if (gBattleMons[bank].statStages[gAIScriptPtr[2]] == gAIScriptPtr[3])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 4);
@@ -1712,9 +1712,9 @@ static void BattleAICmd_if_stat_level_not_equal(void)
     u32 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if (gBattleMons[bank].statStages[gAIScriptPtr[2]] != gAIScriptPtr[3])
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 4);
@@ -1733,11 +1733,11 @@ static void BattleAICmd_if_can_faint(void)
     gDynamicBasePower = 0;
     gBattleStruct->dynamicMoveType = 0;
     gBattleScripting.dmgMultiplier = 1;
-    gBattleMoveFlags = 0;
+    gMoveResultFlags = 0;
     gCritMultiplier = 1;
     gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
-    AI_CalcDmg(sBank_AI, gBankTarget);
-    TypeCalc(gCurrentMove, sBank_AI, gBankTarget);
+    AI_CalcDmg(sBattler_AI, gBattlerTarget);
+    TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
 
     gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
 
@@ -1745,7 +1745,7 @@ static void BattleAICmd_if_can_faint(void)
     if (gBattleMoveDamage == 0)
         gBattleMoveDamage = 1;
 
-    if (gBattleMons[gBankTarget].hp <= gBattleMoveDamage)
+    if (gBattleMons[gBattlerTarget].hp <= gBattleMoveDamage)
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1762,17 +1762,17 @@ static void BattleAICmd_if_cant_faint(void)
     gDynamicBasePower = 0;
     gBattleStruct->dynamicMoveType = 0;
     gBattleScripting.dmgMultiplier = 1;
-    gBattleMoveFlags = 0;
+    gMoveResultFlags = 0;
     gCritMultiplier = 1;
     gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
-    AI_CalcDmg(sBank_AI, gBankTarget);
-    TypeCalc(gCurrentMove, sBank_AI, gBankTarget);
+    AI_CalcDmg(sBattler_AI, gBattlerTarget);
+    TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
 
     gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
 
     // this macro is missing the damage 0 = 1 assumption.
 
-    if (gBattleMons[gBankTarget].hp > gBattleMoveDamage)
+    if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -1788,7 +1788,7 @@ static void BattleAICmd_if_has_move(void)
         case AI_USER:
             for (i = 0; i < 4; i++)
             {
-                if (gBattleMons[sBank_AI].moves[i] == *movePtr)
+                if (gBattleMons[sBattler_AI].moves[i] == *movePtr)
                     break;
             }
             if (i == 4)
@@ -1802,7 +1802,7 @@ static void BattleAICmd_if_has_move(void)
                 return;
             }
         case AI_USER_PARTNER:
-            if (gBattleMons[sBank_AI ^ BIT_MON].hp == 0)
+            if (gBattleMons[sBattler_AI ^ BIT_FLANK].hp == 0)
             {
                 gAIScriptPtr += 8;
                 return;
@@ -1811,7 +1811,7 @@ static void BattleAICmd_if_has_move(void)
             {
                 for (i = 0; i < 4; i++)
                 {
-                    if (gBattleMons[sBank_AI ^ BIT_MON].moves[i] == *movePtr)
+                    if (gBattleMons[sBattler_AI ^ BIT_FLANK].moves[i] == *movePtr)
                         break;
                 }
             }
@@ -1829,7 +1829,7 @@ static void BattleAICmd_if_has_move(void)
         case AI_TARGET_PARTNER:
             for (i = 0; i < 4; i++)
             {
-                if (BATTLE_HISTORY->usedMoves[gBankTarget].moves[i] == *movePtr)
+                if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] == *movePtr)
                     break;
             }
             if (i == 4)
@@ -1856,7 +1856,7 @@ static void BattleAICmd_if_doesnt_have_move(void)
         case AI_USER_PARTNER: // UB: no separate check for user partner
             for (i = 0; i < 4; i++)
             {
-                if (gBattleMons[sBank_AI].moves[i] == *movePtr)
+                if (gBattleMons[sBattler_AI].moves[i] == *movePtr)
                     break;
             }
             if (i != 4)
@@ -1873,7 +1873,7 @@ static void BattleAICmd_if_doesnt_have_move(void)
         case AI_TARGET_PARTNER:
             for (i = 0; i < 4; i++)
             {
-                if (BATTLE_HISTORY->usedMoves[gBankTarget].moves[i] == *movePtr)
+                if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] == *movePtr)
                     break;
             }
             if (i != 4)
@@ -1899,7 +1899,7 @@ static void BattleAICmd_if_has_move_with_effect(void)
     case AI_USER_PARTNER:
         for (i = 0; i < 4; i++)
         {
-            if (gBattleMons[sBank_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBank_AI].moves[i]].effect == gAIScriptPtr[2])
+            if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
                 break;
         }
         if (i == 4)
@@ -1911,8 +1911,8 @@ static void BattleAICmd_if_has_move_with_effect(void)
     case AI_TARGET_PARTNER:
         for (i = 0; i < 4; i++)
         {
-            // UB: checks sBank_AI instead of gBankTarget
-            if (gBattleMons[sBank_AI].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBankTarget].moves[i]].effect == gAIScriptPtr[2])
+            // UB: checks sBattler_AI instead of gBattlerTarget
+            if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i]].effect == gAIScriptPtr[2])
                 break;
         }
         if (i == 4)
@@ -1933,7 +1933,7 @@ static void BattleAICmd_if_doesnt_have_move_with_effect(void)
     case AI_USER_PARTNER:
         for (i = 0; i < 4; i++)
         {
-            if(gBattleMons[sBank_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBank_AI].moves[i]].effect == gAIScriptPtr[2])
+            if(gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
                 break;
         }
         if (i != 4)
@@ -1945,7 +1945,7 @@ static void BattleAICmd_if_doesnt_have_move_with_effect(void)
     case AI_TARGET_PARTNER:
         for (i = 0; i < 4; i++)
         {
-            if (BATTLE_HISTORY->usedMoves[gBankTarget].moves[i] && gBattleMoves[BATTLE_HISTORY->usedMoves[gBankTarget].moves[i]].effect == gAIScriptPtr[2])
+            if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i]].effect == gAIScriptPtr[2])
                 break;
         }
         if (i != 4)
@@ -1961,9 +1961,9 @@ static void BattleAICmd_if_any_move_disabled_or_encored(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     if (gAIScriptPtr[2] == 0)
     {
@@ -1993,7 +1993,7 @@ static void BattleAICmd_if_curr_move_disabled_or_encored(void)
     switch (gAIScriptPtr[1])
     {
     case 0:
-        if (gDisableStructs[gActiveBank].disabledMove == AI_THINKING_STRUCT->moveConsidered)
+        if (gDisableStructs[gActiveBattler].disabledMove == AI_THINKING_STRUCT->moveConsidered)
         {
             gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 2);
             return;
@@ -2001,7 +2001,7 @@ static void BattleAICmd_if_curr_move_disabled_or_encored(void)
         gAIScriptPtr += 6;
         return;
     case 1:
-        if (gDisableStructs[gActiveBank].encoredMove == AI_THINKING_STRUCT->moveConsidered)
+        if (gDisableStructs[gActiveBattler].encoredMove == AI_THINKING_STRUCT->moveConsidered)
         {
             gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 2);
             return;
@@ -2039,11 +2039,11 @@ static void BattleAICmd_get_hold_effect(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
-    if (gActiveBank != bank)
+    if (gActiveBattler != bank)
         AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(BATTLE_HISTORY->itemEffects[bank]);
     else
         AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(gBattleMons[bank].item);
@@ -2057,7 +2057,7 @@ static void BattleAICmd_if_holds_item(void)
     u16 item;
     u8 var1, var2;
 
-    if ((bank & BIT_SIDE) == (sBank_AI & BIT_SIDE))
+    if ((bank & BIT_SIDE) == (sBattler_AI & BIT_SIDE))
         item = gBattleMons[bank].item;
     else
         item = BATTLE_HISTORY->itemEffects[bank];
@@ -2077,9 +2077,9 @@ static void BattleAICmd_get_gender(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = GetGenderFromSpeciesAndPersonality(gBattleMons[bank].species, gBattleMons[bank].personality);
 
@@ -2091,9 +2091,9 @@ static void BattleAICmd_is_first_turn_for(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = gDisableStructs[bank].isFirstTurn;
 
@@ -2105,9 +2105,9 @@ static void BattleAICmd_get_stockpile_count(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = gDisableStructs[bank].stockpileCounter;
 
@@ -2126,9 +2126,9 @@ static void BattleAICmd_get_used_held_item(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     // This is likely a leftover from Ruby's code and its ugly ewram access
     #ifdef NONMATCHING
@@ -2166,9 +2166,9 @@ static void BattleAICmd_get_protect_count(void)
     u8 bank;
 
     if (gAIScriptPtr[1] == AI_USER)
-        bank = sBank_AI;
+        bank = sBattler_AI;
     else
-        bank = gBankTarget;
+        bank = gBattlerTarget;
 
     AI_THINKING_STRUCT->funcResult = gDisableStructs[bank].protectUses;
 
@@ -2221,7 +2221,7 @@ static void BattleAICmd_if_level_cond(void)
     switch (gAIScriptPtr[1])
     {
     case 0: // greater than
-        if (gBattleMons[sBank_AI].level > gBattleMons[gBankTarget].level)
+        if (gBattleMons[sBattler_AI].level > gBattleMons[gBattlerTarget].level)
         {
             gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 2);
             return;
@@ -2229,7 +2229,7 @@ static void BattleAICmd_if_level_cond(void)
         gAIScriptPtr += 6;
         return;
     case 1: // less than
-        if (gBattleMons[sBank_AI].level < gBattleMons[gBankTarget].level)
+        if (gBattleMons[sBattler_AI].level < gBattleMons[gBattlerTarget].level)
         {
             gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 2);
             return;
@@ -2237,7 +2237,7 @@ static void BattleAICmd_if_level_cond(void)
         gAIScriptPtr += 6;
         return;
     case 2: // equal
-        if (gBattleMons[sBank_AI].level == gBattleMons[gBankTarget].level)
+        if (gBattleMons[sBattler_AI].level == gBattleMons[gBattlerTarget].level)
         {
             gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 2);
             return;
@@ -2249,7 +2249,7 @@ static void BattleAICmd_if_level_cond(void)
 
 static void BattleAICmd_if_target_taunted(void)
 {
-    if (gDisableStructs[gBankTarget].tauntTimer1 != 0)
+    if (gDisableStructs[gBattlerTarget].tauntTimer1 != 0)
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -2257,7 +2257,7 @@ static void BattleAICmd_if_target_taunted(void)
 
 static void BattleAICmd_if_target_not_taunted(void)
 {
-    if (gDisableStructs[gBankTarget].tauntTimer1 == 0)
+    if (gDisableStructs[gBattlerTarget].tauntTimer1 == 0)
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;
@@ -2265,7 +2265,7 @@ static void BattleAICmd_if_target_not_taunted(void)
 
 static void BattleAICmd_if_target_is_ally(void)
 {
-    if ((sBank_AI & BIT_SIDE) == (gBankTarget & BIT_SIDE))
+    if ((sBattler_AI & BIT_SIDE) == (gBattlerTarget & BIT_SIDE))
         gAIScriptPtr = AIScriptReadPtr(gAIScriptPtr + 1);
     else
         gAIScriptPtr += 5;

src/battle_ai_switch_items.c

@@ -10,16 +10,16 @@
 #include "constants/items.h"
 #include "pokemon_item_effects.h"
 
-extern u8 gActiveBank;
-extern u8 gAbsentBankFlags;
+extern u8 gActiveBattler;
+extern u8 gAbsentBattlerFlags;
 extern u32 gBattleTypeFlags;
-extern u32 gStatuses3[BATTLE_BANKS_COUNT];
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern u16 gLastLandedMoves[BATTLE_BANKS_COUNT];
-extern u8 gLastHitBy[BATTLE_BANKS_COUNT];
+extern u32 gStatuses3[MAX_BATTLERS_COUNT];
+extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern u16 gLastLandedMoves[MAX_BATTLERS_COUNT];
+extern u8 gLastHitBy[MAX_BATTLERS_COUNT];
 extern u16 gDynamicBasePower;
-extern u8 gBattleMoveFlags;
+extern u8 gMoveResultFlags;
 extern u8 gCritMultiplier;
 extern s32 gBattleMoveDamage;
 
@@ -35,11 +35,11 @@ static bool8 ShouldUseItem(void);
 
 static bool8 ShouldSwitchIfPerishSong(void)
 {
-    if (gStatuses3[gActiveBank] & STATUS3_PERISH_SONG
-        && gDisableStructs[gActiveBank].perishSongTimer1 == 0)
+    if (gStatuses3[gActiveBattler] & STATUS3_PERISH_SONG
+        && gDisableStructs[gActiveBattler].perishSongTimer1 == 0)
     {
-        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = 6;
-        EmitTwoReturnValues(1, ACTION_SWITCH, 0);
+        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = 6;
+        BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0);
         return TRUE;
     }
 
@@ -48,7 +48,7 @@ static bool8 ShouldSwitchIfPerishSong(void)
 
 static bool8 ShouldSwitchIfWonderGuard(void)
 {
-    u8 opposingIdentity;
+    u8 opposingPosition;
     u8 opposingBank;
     u8 moveFlags;
     s32 i, j;
@@ -60,27 +60,27 @@ static bool8 ShouldSwitchIfWonderGuard(void)
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
         return FALSE;
 
-    opposingIdentity = GetBankIdentity(gActiveBank) ^ BIT_SIDE;
+    opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(gActiveBattler));
 
-    if (gBattleMons[GetBankByIdentity(opposingIdentity)].ability != ABILITY_WONDER_GUARD)
+    if (gBattleMons[GetBattlerAtPosition(opposingPosition)].ability != ABILITY_WONDER_GUARD)
         return FALSE;
 
     // check if pokemon has a super effective move
-    for (opposingBank = GetBankByIdentity(opposingIdentity), i = 0; i < 4; i++)
+    for (opposingBank = GetBattlerAtPosition(opposingPosition), i = 0; i < 4; i++)
     {
-        move = gBattleMons[gActiveBank].moves[i];
+        move = gBattleMons[gActiveBattler].moves[i];
         if (move == MOVE_NONE)
             continue;
 
         moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
-        if (moveFlags & MOVESTATUS_SUPEREFFECTIVE)
+        if (moveFlags & MOVE_RESULT_SUPER_EFFECTIVE)
             return FALSE;
     }
 
     // get party information
     if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
     {
-        if ((gActiveBank & BIT_MON) == 0)
+        if ((gActiveBattler & BIT_FLANK) == 0)
             firstId = 0, lastId = 3;
         else
             firstId = 3, lastId = 6;
@@ -90,7 +90,7 @@ static bool8 ShouldSwitchIfWonderGuard(void)
         firstId = 0, lastId = 6;
     }
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -104,24 +104,24 @@ static bool8 ShouldSwitchIfWonderGuard(void)
             continue;
         if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
             continue;
-        if (i == gBattlePartyID[gActiveBank])
+        if (i == gBattlerPartyIndexes[gActiveBattler])
             continue;
 
         GetMonData(&party[i], MON_DATA_SPECIES); // unused return value
         GetMonData(&party[i], MON_DATA_ALT_ABILITY); // unused return value
 
-        for (opposingBank = GetBankByIdentity(opposingIdentity), j = 0; j < 4; j++)
+        for (opposingBank = GetBattlerAtPosition(opposingPosition), j = 0; j < 4; j++)
         {
             move = GetMonData(&party[i], MON_DATA_MOVE1 + j);
             if (move == MOVE_NONE)
                 continue;
 
             moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
-            if (moveFlags & MOVESTATUS_SUPEREFFECTIVE && Random() % 3 < 2)
+            if (moveFlags & MOVE_RESULT_SUPER_EFFECTIVE && Random() % 3 < 2)
             {
                 // we found a mon
-                *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = i;
-                EmitTwoReturnValues(1, ACTION_SWITCH, 0);
+                *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = i;
+                BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0);
                 return TRUE;
             }
         }
@@ -141,42 +141,42 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void)
 
     if (HasSuperEffectiveMoveAgainstOpponents(TRUE) && Random() % 3 != 0)
         return FALSE;
-    if (gLastLandedMoves[gActiveBank] == 0)
+    if (gLastLandedMoves[gActiveBattler] == 0)
         return FALSE;
-    if (gLastLandedMoves[gActiveBank] == 0xFFFF)
+    if (gLastLandedMoves[gActiveBattler] == 0xFFFF)
         return FALSE;
-    if (gBattleMoves[gLastLandedMoves[gActiveBank]].power == 0)
+    if (gBattleMoves[gLastLandedMoves[gActiveBattler]].power == 0)
         return FALSE;
 
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
-        bankIn1 = gActiveBank;
-        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)])
-            bankIn2 = gActiveBank;
+        bankIn1 = gActiveBattler;
+        if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))])
+            bankIn2 = gActiveBattler;
         else
-            bankIn2 = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON);
+            bankIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)));
     }
     else
     {
-        bankIn1 = gActiveBank;
-        bankIn2 = gActiveBank;
+        bankIn1 = gActiveBattler;
+        bankIn2 = gActiveBattler;
     }
 
-    if (gBattleMoves[gLastLandedMoves[gActiveBank]].type == TYPE_FIRE)
+    if (gBattleMoves[gLastLandedMoves[gActiveBattler]].type == TYPE_FIRE)
         absorbingTypeAbility = ABILITY_FLASH_FIRE;
-    else if (gBattleMoves[gLastLandedMoves[gActiveBank]].type == TYPE_WATER)
+    else if (gBattleMoves[gLastLandedMoves[gActiveBattler]].type == TYPE_WATER)
         absorbingTypeAbility = ABILITY_WATER_ABSORB;
-    else if (gBattleMoves[gLastLandedMoves[gActiveBank]].type == TYPE_ELECTRIC)
+    else if (gBattleMoves[gLastLandedMoves[gActiveBattler]].type == TYPE_ELECTRIC)
         absorbingTypeAbility = ABILITY_VOLT_ABSORB;
     else
         return FALSE;
 
-    if (gBattleMons[gActiveBank].ability == absorbingTypeAbility)
+    if (gBattleMons[gActiveBattler].ability == absorbingTypeAbility)
         return FALSE;
 
     if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
     {
-        if ((gActiveBank & BIT_MON) == 0)
+        if ((gActiveBattler & BIT_FLANK) == 0)
             firstId = 0, lastId = 3;
         else
             firstId = 3, lastId = 6;
@@ -186,7 +186,7 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void)
         firstId = 0, lastId = 6;
     }
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -202,9 +202,9 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void)
             continue;
         if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
             continue;
-        if (i == gBattlePartyID[bankIn1])
+        if (i == gBattlerPartyIndexes[bankIn1])
             continue;
-        if (i == gBattlePartyID[bankIn2])
+        if (i == gBattlerPartyIndexes[bankIn2])
             continue;
         if (i == *(gBattleStruct->monToSwitchIntoId + bankIn1))
             continue;
@@ -220,8 +220,8 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void)
         if (absorbingTypeAbility == monAbility && Random() & 1)
         {
             // we found a mon
-            *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = i;
-            EmitTwoReturnValues(1, ACTION_SWITCH, 0);
+            *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = i;
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0);
             return TRUE;
         }
     }
@@ -231,34 +231,34 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void)
 
 static bool8 ShouldSwitchIfNaturalCure(void)
 {
-    if (!(gBattleMons[gActiveBank].status1 & STATUS_SLEEP))
+    if (!(gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP))
         return FALSE;
-    if (gBattleMons[gActiveBank].ability != ABILITY_NATURAL_CURE)
+    if (gBattleMons[gActiveBattler].ability != ABILITY_NATURAL_CURE)
         return FALSE;
-    if (gBattleMons[gActiveBank].hp < gBattleMons[gActiveBank].maxHP / 2)
+    if (gBattleMons[gActiveBattler].hp < gBattleMons[gActiveBattler].maxHP / 2)
         return FALSE;
 
-    if ((gLastLandedMoves[gActiveBank] == 0 || gLastLandedMoves[gActiveBank] == 0xFFFF) && Random() & 1)
+    if ((gLastLandedMoves[gActiveBattler] == 0 || gLastLandedMoves[gActiveBattler] == 0xFFFF) && Random() & 1)
     {
-        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = 6;
-        EmitTwoReturnValues(1, ACTION_SWITCH, 0);
+        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = 6;
+        BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0);
         return TRUE;
     }
-    else if (gBattleMoves[gLastLandedMoves[gActiveBank]].power == 0 && Random() & 1)
+    else if (gBattleMoves[gLastLandedMoves[gActiveBattler]].power == 0 && Random() & 1)
     {
-        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = 6;
-        EmitTwoReturnValues(1, ACTION_SWITCH, 0);
+        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = 6;
+        BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0);
         return TRUE;
     }
 
-    if (FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTAFFECTED, 1))
+    if (FindMonWithFlagsAndSuperEffective(MOVE_RESULT_DOESNT_AFFECT_FOE, 1))
         return TRUE;
-    if (FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTVERYEFFECTIVE, 1))
+    if (FindMonWithFlagsAndSuperEffective(MOVE_RESULT_NOT_VERY_EFFECTIVE, 1))
         return TRUE;
     if (Random() & 1)
     {
-        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = 6;
-        EmitTwoReturnValues(1, ACTION_SWITCH, 0);
+        *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = 6;
+        BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0);
         return TRUE;
     }
 
@@ -267,25 +267,25 @@ static bool8 ShouldSwitchIfNaturalCure(void)
 
 static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng)
 {
-    u8 opposingIdentity;
+    u8 opposingPosition;
     u8 opposingBank;
     s32 i;
     u8 moveFlags;
     u16 move;
 
-    opposingIdentity = GetBankIdentity(gActiveBank) ^ BIT_SIDE;
-    opposingBank = GetBankByIdentity(opposingIdentity);
+    opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(gActiveBattler));
+    opposingBank = GetBattlerAtPosition(opposingPosition);
 
-    if (!(gAbsentBankFlags & gBitTable[opposingBank]))
+    if (!(gAbsentBattlerFlags & gBitTable[opposingBank]))
     {
         for (i = 0; i < 4; i++)
         {
-            move = gBattleMons[gActiveBank].moves[i];
+            move = gBattleMons[gActiveBattler].moves[i];
             if (move == MOVE_NONE)
                 continue;
 
             moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
-            if (moveFlags & MOVESTATUS_SUPEREFFECTIVE)
+            if (moveFlags & MOVE_RESULT_SUPER_EFFECTIVE)
             {
                 if (noRng)
                     return TRUE;
@@ -297,18 +297,18 @@ static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng)
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
         return FALSE;
 
-    opposingBank = GetBankByIdentity(opposingIdentity ^ BIT_MON);
+    opposingBank = GetBattlerAtPosition(BATTLE_PARTNER(opposingPosition));
 
-    if (!(gAbsentBankFlags & gBitTable[opposingBank]))
+    if (!(gAbsentBattlerFlags & gBitTable[opposingBank]))
     {
         for (i = 0; i < 4; i++)
         {
-            move = gBattleMons[gActiveBank].moves[i];
+            move = gBattleMons[gActiveBattler].moves[i];
             if (move == MOVE_NONE)
                 continue;
 
             moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
-            if (moveFlags & MOVESTATUS_SUPEREFFECTIVE)
+            if (moveFlags & MOVE_RESULT_SUPER_EFFECTIVE)
             {
                 if (noRng)
                     return TRUE;
@@ -328,8 +328,8 @@ static bool8 AreStatsRaised(void)
 
     for (i = 0; i < BATTLE_STATS_NO; i++)
     {
-        if (gBattleMons[gActiveBank].statStages[i] > 6)
-            buffedStatsValue += gBattleMons[gActiveBank].statStages[i] - 6;
+        if (gBattleMons[gActiveBattler].statStages[i] > 6)
+            buffedStatsValue += gBattleMons[gActiveBattler].statStages[i] - 6;
     }
 
     return (buffedStatsValue > 3);
@@ -345,32 +345,32 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent)
     u16 move;
     u8 moveFlags;
 
-    if (gLastLandedMoves[gActiveBank] == 0)
+    if (gLastLandedMoves[gActiveBattler] == 0)
         return FALSE;
-    if (gLastLandedMoves[gActiveBank] == 0xFFFF)
+    if (gLastLandedMoves[gActiveBattler] == 0xFFFF)
         return FALSE;
-    if (gLastHitBy[gActiveBank] == 0xFF)
+    if (gLastHitBy[gActiveBattler] == 0xFF)
         return FALSE;
-    if (gBattleMoves[gLastLandedMoves[gActiveBank]].power == 0)
+    if (gBattleMoves[gLastLandedMoves[gActiveBattler]].power == 0)
         return FALSE;
 
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
-        bankIn1 = gActiveBank;
-        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)])
-            bankIn2 = gActiveBank;
+        bankIn1 = gActiveBattler;
+        if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))])
+            bankIn2 = gActiveBattler;
         else
-            bankIn2 = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON);
+            bankIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)));
     }
     else
     {
-        bankIn1 = gActiveBank;
-        bankIn2 = gActiveBank;
+        bankIn1 = gActiveBattler;
+        bankIn2 = gActiveBattler;
     }
 
     if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
     {
-        if ((gActiveBank & BIT_MON) == 0)
+        if ((gActiveBattler & BIT_FLANK) == 0)
             firstId = 0, lastId = 3;
         else
             firstId = 3, lastId = 6;
@@ -380,7 +380,7 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent)
         firstId = 0, lastId = 6;
     }
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -396,9 +396,9 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent)
             continue;
         if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
             continue;
-        if (i == gBattlePartyID[bankIn1])
+        if (i == gBattlerPartyIndexes[bankIn1])
             continue;
-        if (i == gBattlePartyID[bankIn2])
+        if (i == gBattlerPartyIndexes[bankIn2])
             continue;
         if (i == *(gBattleStruct->monToSwitchIntoId + bankIn1))
             continue;
@@ -411,10 +411,10 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent)
         else
             monAbility = gBaseStats[species].ability1;
 
-        moveFlags = AI_TypeCalc(gLastLandedMoves[gActiveBank], species, monAbility);
+        moveFlags = AI_TypeCalc(gLastLandedMoves[gActiveBattler], species, monAbility);
         if (moveFlags & flags)
         {
-            bankIn1 = gLastHitBy[gActiveBank];
+            bankIn1 = gLastHitBy[gActiveBattler];
 
             for (j = 0; j < 4; j++)
             {
@@ -423,10 +423,10 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent)
                     continue;
 
                 moveFlags = AI_TypeCalc(move, gBattleMons[bankIn1].species, gBattleMons[bankIn1].ability);
-                if (moveFlags & MOVESTATUS_SUPEREFFECTIVE && Random() % moduloPercent == 0)
+                if (moveFlags & MOVE_RESULT_SUPER_EFFECTIVE && Random() % moduloPercent == 0)
                 {
-                    *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = i;
-                    EmitTwoReturnValues(1, ACTION_SWITCH, 0);
+                    *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = i;
+                    BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0);
                     return TRUE;
                 }
             }
@@ -446,19 +446,19 @@ static bool8 ShouldSwitch(void)
     s32 i;
     s32 availableToSwitch;
 
-    if (gBattleMons[*(activeBankPtr = &gActiveBank)].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION))
+    if (gBattleMons[*(activeBankPtr = &gActiveBattler)].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION))
         return FALSE;
-    if (gStatuses3[gActiveBank] & STATUS3_ROOTED)
+    if (gStatuses3[gActiveBattler] & STATUS3_ROOTED)
         return FALSE;
-    if (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gActiveBank, ABILITY_SHADOW_TAG, 0, 0))
+    if (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gActiveBattler, ABILITY_SHADOW_TAG, 0, 0))
         return FALSE;
-    if (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gActiveBank, ABILITY_ARENA_TRAP, 0, 0))
+    if (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gActiveBattler, ABILITY_ARENA_TRAP, 0, 0))
         return FALSE; // misses the flying or levitate check
     if (AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, ABILITY_MAGNET_PULL, 0, 0))
     {
-        if (gBattleMons[gActiveBank].type1 == TYPE_STEEL)
+        if (gBattleMons[gActiveBattler].type1 == TYPE_STEEL)
             return FALSE;
-        if (gBattleMons[gActiveBank].type2 == TYPE_STEEL)
+        if (gBattleMons[gActiveBattler].type2 == TYPE_STEEL)
             return FALSE;
     }
     if (gBattleTypeFlags & BATTLE_TYPE_ARENA)
@@ -468,10 +468,10 @@ static bool8 ShouldSwitch(void)
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
         bankIn1 = *activeBankPtr;
-        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(*activeBankPtr) ^ BIT_MON)])
+        if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(GetBattlerPosition(*activeBankPtr) ^ BIT_FLANK)])
             bankIn2 = *activeBankPtr;
         else
-            bankIn2 = GetBankByIdentity(GetBankIdentity(*activeBankPtr) ^ BIT_MON);
+            bankIn2 = GetBattlerAtPosition(GetBattlerPosition(*activeBankPtr) ^ BIT_FLANK);
     }
     else
     {
@@ -481,7 +481,7 @@ static bool8 ShouldSwitch(void)
 
     if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
     {
-        if ((gActiveBank & BIT_MON) == 0)
+        if ((gActiveBattler & BIT_FLANK) == 0)
             firstId = 0, lastId = 3;
         else
             firstId = 3, lastId = 6;
@@ -491,7 +491,7 @@ static bool8 ShouldSwitch(void)
         firstId = 0, lastId = 6;
     }
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -504,9 +504,9 @@ static bool8 ShouldSwitch(void)
             continue;
         if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
             continue;
-        if (i == gBattlePartyID[bankIn1])
+        if (i == gBattlerPartyIndexes[bankIn1])
             continue;
-        if (i == gBattlePartyID[bankIn2])
+        if (i == gBattlerPartyIndexes[bankIn2])
             continue;
         if (i == *(gBattleStruct->monToSwitchIntoId + bankIn1))
             continue;
@@ -530,8 +530,8 @@ static bool8 ShouldSwitch(void)
         return FALSE;
     if (AreStatsRaised())
         return FALSE;
-    if (FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTAFFECTED, 2)
-        || FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTVERYEFFECTIVE, 3))
+    if (FindMonWithFlagsAndSuperEffective(MOVE_RESULT_DOESNT_AFFECT_FOE, 2)
+        || FindMonWithFlagsAndSuperEffective(MOVE_RESULT_NOT_VERY_EFFECTIVE, 3))
         return TRUE;
 
     return FALSE;
@@ -543,9 +543,9 @@ void AI_TrySwitchOrUseItem(void)
     u8 bankIn1, bankIn2;
     s32 firstId;
     s32 lastId; // + 1
-    u8 bankIdentity = GetBankIdentity(gActiveBank);
+    u8 bankIdentity = GetBattlerPosition(gActiveBattler);
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -554,25 +554,25 @@ void AI_TrySwitchOrUseItem(void)
     {
         if (ShouldSwitch())
         {
-            if (*(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) == 6)
+            if (*(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) == 6)
             {
                 s32 monToSwitchId = GetMostSuitableMonToSwitchInto();
                 if (monToSwitchId == 6)
                 {
                     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
                     {
-                        bankIn1 = GetBankByIdentity(bankIdentity);
+                        bankIn1 = GetBattlerAtPosition(bankIdentity);
                         bankIn2 = bankIn1;
                     }
                     else
                     {
-                        bankIn1 = GetBankByIdentity(bankIdentity);
-                        bankIn2 = GetBankByIdentity(bankIdentity ^ BIT_MON);
+                        bankIn1 = GetBattlerAtPosition(bankIdentity);
+                        bankIn2 = GetBattlerAtPosition(bankIdentity ^ BIT_FLANK);
                     }
 
                     if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
                     {
-                        if ((gActiveBank & BIT_MON) == 0)
+                        if ((gActiveBattler & BIT_FLANK) == 0)
                             firstId = 0, lastId = 3;
                         else
                             firstId = 3, lastId = 6;
@@ -586,9 +586,9 @@ void AI_TrySwitchOrUseItem(void)
                     {
                         if (GetMonData(&party[monToSwitchId], MON_DATA_HP) == 0)
                             continue;
-                        if (monToSwitchId == gBattlePartyID[bankIn1])
+                        if (monToSwitchId == gBattlerPartyIndexes[bankIn1])
                             continue;
-                        if (monToSwitchId == gBattlePartyID[bankIn2])
+                        if (monToSwitchId == gBattlerPartyIndexes[bankIn2])
                             continue;
                         if (monToSwitchId == *(gBattleStruct->monToSwitchIntoId + bankIn1))
                             continue;
@@ -599,10 +599,10 @@ void AI_TrySwitchOrUseItem(void)
                     }
                 }
 
-                *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank) = monToSwitchId;
+                *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = monToSwitchId;
             }
 
-            *(gBattleStruct->monToSwitchIntoId + gActiveBank) = *(gBattleStruct->AI_monToSwitchIntoId + gActiveBank);
+            *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler);
             return;
         }
         else if (ShouldUseItem())
@@ -611,7 +611,7 @@ void AI_TrySwitchOrUseItem(void)
         }
     }
 
-    EmitTwoReturnValues(1, ACTION_USE_MOVE, (gActiveBank ^ BIT_SIDE) << 8);
+    BtlController_EmitTwoReturnValues(1, B_ACTION_USE_MOVE, (gActiveBattler ^ BIT_SIDE) << 8);
 }
 
 static void ModulateByTypeEffectiveness(u8 atkType, u8 defType1, u8 defType2, u8 *var)
@@ -651,34 +651,34 @@ u8 GetMostSuitableMonToSwitchInto(void)
     u8 invalidMons;
     u16 move;
 
-    if (*(gBattleStruct->monToSwitchIntoId + gActiveBank) != 6)
-        return *(gBattleStruct->monToSwitchIntoId + gActiveBank);
+    if (*(gBattleStruct->monToSwitchIntoId + gActiveBattler) != 6)
+        return *(gBattleStruct->monToSwitchIntoId + gActiveBattler);
     if (gBattleTypeFlags & BATTLE_TYPE_ARENA)
-        return gBattlePartyID[gActiveBank] + 1;
+        return gBattlerPartyIndexes[gActiveBattler] + 1;
 
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
-        bankIn1 = gActiveBank;
-        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)])
-            bankIn2 = gActiveBank;
+        bankIn1 = gActiveBattler;
+        if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ BIT_FLANK)])
+            bankIn2 = gActiveBattler;
         else
-            bankIn2 = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON);
+            bankIn2 = GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ BIT_FLANK);
 
         // UB: It considers the opponent only player's side even though it can battle alongside player;
-        opposingBank = Random() & BIT_MON;
-        if (gAbsentBankFlags & gBitTable[opposingBank])
-            opposingBank ^= BIT_MON;
+        opposingBank = Random() & BIT_FLANK;
+        if (gAbsentBattlerFlags & gBitTable[opposingBank])
+            opposingBank ^= BIT_FLANK;
     }
     else
     {
-        opposingBank = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_SIDE);
-        bankIn1 = gActiveBank;
-        bankIn2 = gActiveBank;
+        opposingBank = GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ BIT_SIDE);
+        bankIn1 = gActiveBattler;
+        bankIn2 = gActiveBattler;
     }
 
     if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
     {
-        if ((gActiveBank & BIT_MON) == 0)
+        if ((gActiveBattler & BIT_FLANK) == 0)
             firstId = 0, lastId = 3;
         else
             firstId = 3, lastId = 6;
@@ -688,7 +688,7 @@ u8 GetMostSuitableMonToSwitchInto(void)
         firstId = 0, lastId = 6;
     }
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -706,8 +706,8 @@ u8 GetMostSuitableMonToSwitchInto(void)
             if (species != SPECIES_NONE
                 && GetMonData(&party[i], MON_DATA_HP) != 0
                 && !(gBitTable[i] & invalidMons)
-                && gBattlePartyID[bankIn1] != i
-                && gBattlePartyID[bankIn2] != i
+                && gBattlerPartyIndexes[bankIn1] != i
+                && gBattlerPartyIndexes[bankIn2] != i
                 && i != *(gBattleStruct->monToSwitchIntoId + bankIn1)
                 && i != *(gBattleStruct->monToSwitchIntoId + bankIn2))
             {
@@ -734,7 +734,7 @@ u8 GetMostSuitableMonToSwitchInto(void)
             for (i = 0; i < 4; i++)
             {
                 move = GetMonData(&party[bestMonId], MON_DATA_MOVE1 + i);
-                if (move != MOVE_NONE && TypeCalc(move, gActiveBank, opposingBank) & MOVESTATUS_SUPEREFFECTIVE)
+                if (move != MOVE_NONE && TypeCalc(move, gActiveBattler, opposingBank) & MOVE_RESULT_SUPER_EFFECTIVE)
                     break;
             }
 
@@ -752,7 +752,7 @@ u8 GetMostSuitableMonToSwitchInto(void)
     gDynamicBasePower = 0;
     gBattleStruct->dynamicMoveType = 0;
     gBattleScripting.dmgMultiplier = 1;
-    gBattleMoveFlags = 0;
+    gMoveResultFlags = 0;
     gCritMultiplier = 1;
     bestDmg = 0;
     bestMonId = 6;
@@ -764,9 +764,9 @@ u8 GetMostSuitableMonToSwitchInto(void)
             continue;
         if (GetMonData(&party[i], MON_DATA_HP) == 0)
             continue;
-        if (gBattlePartyID[bankIn1] == i)
+        if (gBattlerPartyIndexes[bankIn1] == i)
             continue;
-        if (gBattlePartyID[bankIn2] == i)
+        if (gBattlerPartyIndexes[bankIn2] == i)
             continue;
         if (i == *(gBattleStruct->monToSwitchIntoId + bankIn1))
             continue;
@@ -779,8 +779,8 @@ u8 GetMostSuitableMonToSwitchInto(void)
             gBattleMoveDamage = 0;
             if (move != MOVE_NONE && gBattleMoves[move].power != 1)
             {
-                AI_CalcDmg(gActiveBank, opposingBank);
-                TypeCalc(move, gActiveBank, opposingBank);
+                AI_CalcDmg(gActiveBattler, opposingBank);
+                TypeCalc(move, gActiveBattler, opposingBank);
             }
             if (bestDmg < gBattleMoveDamage)
             {
@@ -817,10 +817,10 @@ static bool8 ShouldUseItem(void)
     u8 validMons = 0;
     bool8 shouldUse = FALSE;
 
-    if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON2)
+    if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_RIGHT)
         return FALSE;
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         party = gPlayerParty;
     else
         party = gEnemyParty;
@@ -855,14 +855,14 @@ static bool8 ShouldUseItem(void)
         else
             itemEffects = gItemEffectTable[item - 13];
 
-        *(gBattleStruct->AI_itemType + gActiveBank / 2) = GetAI_ItemType(item, itemEffects);
+        *(gBattleStruct->AI_itemType + gActiveBattler / 2) = GetAI_ItemType(item, itemEffects);
 
-        switch (*(gBattleStruct->AI_itemType + gActiveBank / 2))
+        switch (*(gBattleStruct->AI_itemType + gActiveBattler / 2))
         {
         case AI_ITEM_FULL_RESTORE:
-            if (gBattleMons[gActiveBank].hp >= gBattleMons[gActiveBank].maxHP / 4)
+            if (gBattleMons[gActiveBattler].hp >= gBattleMons[gActiveBattler].maxHP / 4)
                 break;
-            if (gBattleMons[gActiveBank].hp == 0)
+            if (gBattleMons[gActiveBattler].hp == 0)
                 break;
             shouldUse = TRUE;
             break;
@@ -870,65 +870,65 @@ static bool8 ShouldUseItem(void)
             paramOffset = GetItemEffectParamOffset(item, 4, 4);
             if (paramOffset == 0)
                 break;
-            if (gBattleMons[gActiveBank].hp == 0)
+            if (gBattleMons[gActiveBattler].hp == 0)
                 break;
-            if (gBattleMons[gActiveBank].hp < gBattleMons[gActiveBank].maxHP / 4 || gBattleMons[gActiveBank].maxHP - gBattleMons[gActiveBank].hp > itemEffects[paramOffset])
+            if (gBattleMons[gActiveBattler].hp < gBattleMons[gActiveBattler].maxHP / 4 || gBattleMons[gActiveBattler].maxHP - gBattleMons[gActiveBattler].hp > itemEffects[paramOffset])
                 shouldUse = TRUE;
             break;
         case AI_ITEM_CURE_CONDITION:
-            *(gBattleStruct->AI_itemFlags + gActiveBank / 2) = 0;
-            if (itemEffects[3] & 0x20 && gBattleMons[gActiveBank].status1 & STATUS_SLEEP)
+            *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) = 0;
+            if (itemEffects[3] & 0x20 && gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP)
             {
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x20;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x20;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x10 && (gBattleMons[gActiveBank].status1 & STATUS_POISON || gBattleMons[gActiveBank].status1 & STATUS_TOXIC_POISON))
+            if (itemEffects[3] & 0x10 && (gBattleMons[gActiveBattler].status1 & STATUS1_POISON || gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_POISON))
             {
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x10;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x10;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x8 && gBattleMons[gActiveBank].status1 & STATUS_BURN)
+            if (itemEffects[3] & 0x8 && gBattleMons[gActiveBattler].status1 & STATUS1_BURN)
             {
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x8;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x8;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x4 && gBattleMons[gActiveBank].status1 & STATUS_FREEZE)
+            if (itemEffects[3] & 0x4 && gBattleMons[gActiveBattler].status1 & STATUS1_FREEZE)
             {
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x4;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x4;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x2 && gBattleMons[gActiveBank].status1 & STATUS_PARALYSIS)
+            if (itemEffects[3] & 0x2 && gBattleMons[gActiveBattler].status1 & STATUS1_PARALYSIS)
             {
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x2;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x2;
                 shouldUse = TRUE;
             }
-            if (itemEffects[3] & 0x1 && gBattleMons[gActiveBank].status2 & STATUS2_CONFUSION)
+            if (itemEffects[3] & 0x1 && gBattleMons[gActiveBattler].status2 & STATUS2_CONFUSION)
             {
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x1;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x1;
                 shouldUse = TRUE;
             }
             break;
         case AI_ITEM_X_STAT:
-            *(gBattleStruct->AI_itemFlags + gActiveBank / 2) = 0;
-            if (gDisableStructs[gActiveBank].isFirstTurn == 0)
+            *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) = 0;
+            if (gDisableStructs[gActiveBattler].isFirstTurn == 0)
                 break;
             if (itemEffects[0] & 0xF)
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x1;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x1;
             if (itemEffects[1] & 0xF0)
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x2;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x2;
             if (itemEffects[1] & 0xF)
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x4;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x4;
             if (itemEffects[2] & 0xF)
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x8;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x8;
             if (itemEffects[2] & 0xF0)
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x20;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x20;
             if (itemEffects[0] & 0x30)
-                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x80;
+                *(gBattleStruct->AI_itemFlags + gActiveBattler / 2) |= 0x80;
             shouldUse = TRUE;
             break;
         case AI_ITEM_GUARD_SPECS:
-            bankSide = GetBankSide(gActiveBank);
-            if (gDisableStructs[gActiveBank].isFirstTurn != 0 && gSideTimers[bankSide].mistTimer == 0)
+            bankSide = GetBattlerSide(gActiveBattler);
+            if (gDisableStructs[gActiveBattler].isFirstTurn != 0 && gSideTimers[bankSide].mistTimer == 0)
                 shouldUse = TRUE;
             break;
         case AI_ITEM_NOT_RECOGNIZABLE:
@@ -937,8 +937,8 @@ static bool8 ShouldUseItem(void)
 
         if (shouldUse)
         {
-            EmitTwoReturnValues(1, ACTION_USE_ITEM, 0);
-            *(gBattleStruct->chosenItem + (gActiveBank / 2) * 2) = item;
+            BtlController_EmitTwoReturnValues(1, B_ACTION_USE_ITEM, 0);
+            *(gBattleStruct->chosenItem + (gActiveBattler / 2) * 2) = item;
             gBattleResources->battleHistory->trainerItems[i] = 0;
             return shouldUse;
         }

src/battle_anim.c

@@ -25,8 +25,8 @@
 
 #define ANIM_SPRITE_INDEX_COUNT 8
 
-extern u8 gBankAttacker;
-extern u8 gBankTarget;
+extern u8 gBattlerAttacker;
+extern u8 gBattlerTarget;
 extern u16 gBattle_WIN0H;
 extern u16 gBattle_WIN0V;
 extern u16 gBattle_WIN1H;
@@ -35,8 +35,8 @@ extern u16 gBattle_BG1_X;
 extern u16 gBattle_BG1_Y;
 extern u16 gBattle_BG2_X;
 extern u16 gBattle_BG2_Y;
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern u8 gBattlerSpriteIds[MAX_BATTLERS_COUNT];
 extern struct MusicPlayerInfo gMPlayInfo_BGM;
 extern struct MusicPlayerInfo gMPlayInfo_SE1;
 extern struct MusicPlayerInfo gMPlayInfo_SE2;
@@ -130,9 +130,9 @@ EWRAM_DATA static u8 sMonAnimTaskIdArray[2] = {0};
 EWRAM_DATA u8 gAnimMoveTurn = 0;
 EWRAM_DATA static u8 sAnimBackgroundFadeState = 0;
 EWRAM_DATA static u16 sAnimMoveIndex = 0; // set but unused.
-EWRAM_DATA u8 gAnimBankAttacker = 0;
-EWRAM_DATA u8 gAnimBankTarget = 0;
-EWRAM_DATA u16 gAnimSpeciesByBanks[BATTLE_BANKS_COUNT] = {0};
+EWRAM_DATA u8 gBattleAnimAttacker = 0;
+EWRAM_DATA u8 gBattleAnimTarget = 0;
+EWRAM_DATA u16 gAnimSpeciesByBanks[MAX_BATTLERS_COUNT] = {0};
 EWRAM_DATA u8 gUnknown_02038440 = 0;
 
 // const rom data
@@ -214,15 +214,15 @@ void ClearBattleAnimationVars(void)
     gAnimMoveTurn = 0;
     sAnimBackgroundFadeState = 0;
     sAnimMoveIndex = 0;
-    gAnimBankAttacker = 0;
-    gAnimBankTarget = 0;
+    gBattleAnimAttacker = 0;
+    gBattleAnimTarget = 0;
     gUnknown_02038440 = 0;
 }
 
 void DoMoveAnim(u16 move)
 {
-    gAnimBankAttacker = gBankAttacker;
-    gAnimBankTarget = gBankTarget;
+    gBattleAnimAttacker = gBattlerAttacker;
+    gBattleAnimTarget = gBattlerTarget;
     LaunchBattleAnimation(gBattleAnims_Moves, move, TRUE);
 }
 
@@ -234,12 +234,12 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo
     {
         sub_80A8278();
         UpdateOamPriorityInAllHealthboxes(0);
-        for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+        for (i = 0; i < MAX_BATTLERS_COUNT; i++)
         {
-            if (GetBankSide(i) != 0)
-                gAnimSpeciesByBanks[i] = GetMonData(&gEnemyParty[gBattlePartyID[i]], MON_DATA_SPECIES);
+            if (GetBattlerSide(i) != 0)
+                gAnimSpeciesByBanks[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
             else
-                gAnimSpeciesByBanks[i] = GetMonData(&gPlayerParty[gBattlePartyID[i]], MON_DATA_SPECIES);
+                gAnimSpeciesByBanks[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
         }
     }
     else
@@ -409,7 +409,7 @@ static void ScriptCmd_createsprite(void)
         else
             argVar *= -1;
 
-        subpriority = sub_80A82E4(gAnimBankTarget) + (s8)(argVar);
+        subpriority = sub_80A82E4(gBattleAnimTarget) + (s8)(argVar);
     }
     else
     {
@@ -418,13 +418,13 @@ static void ScriptCmd_createsprite(void)
         else
             argVar *= -1;
 
-        subpriority = sub_80A82E4(gAnimBankAttacker) + (s8)(argVar);
+        subpriority = sub_80A82E4(gBattleAnimAttacker) + (s8)(argVar);
     }
 
     if (subpriority < 3)
         subpriority = 3;
 
-    CreateSpriteAndAnimate(template, GetBankPosition(gAnimBankTarget, 2), GetBankPosition(gAnimBankTarget, 3), subpriority);
+    CreateSpriteAndAnimate(template, GetBattlerSpriteCoord(gBattleAnimTarget, 2), GetBattlerSpriteCoord(gBattleAnimTarget, 3), subpriority);
     gAnimVisualTaskCount++;
 }
 
@@ -565,7 +565,7 @@ static void sub_80A40F4(u8 taskId)
     u8 newTaskId;
 
     s16 *selfData = gTasks[taskId].data;
-    u8 bankSpriteId = gBankSpriteIds[selfData[t1_MONBG_BANK]];
+    u8 bankSpriteId = gBattlerSpriteIds[selfData[t1_MONBG_BANK]];
     gSprites[bankSpriteId].invisible = 1;
 
     if (!selfData[t1_CREATE_ANOTHER_TASK])
@@ -607,14 +607,14 @@ static void ScriptCmd_monbg(void)
 
     animBank = sBattleAnimScriptPtr[0];
     if (animBank & ANIM_TARGET)
-        bank = gAnimBankTarget;
+        bank = gBattleAnimTarget;
     else
-        bank = gAnimBankAttacker;
+        bank = gBattleAnimAttacker;
 
-    if (IsAnimBankSpriteVisible(bank))
+    if (IsBattlerSpriteVisible(bank))
     {
-        u8 identity = GetBankIdentity(bank);
-        if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+        u8 position = GetBattlerPosition(bank);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
             toBG_2 = FALSE;
         else
             toBG_2 = TRUE;
@@ -629,11 +629,11 @@ static void ScriptCmd_monbg(void)
 
     }
 
-    bank ^= BIT_MON;
-    if (IsAnimBankSpriteVisible(bank))
+    bank ^= BIT_FLANK;
+    if (IsBattlerSpriteVisible(bank))
     {
-        u8 identity = GetBankIdentity(bank);
-        if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+        u8 position = GetBattlerPosition(bank);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
             toBG_2 = FALSE;
         else
             toBG_2 = TRUE;
@@ -652,20 +652,20 @@ static void ScriptCmd_monbg(void)
     gAnimScriptCallback = WaitAnimFrameCount;
 }
 
-bool8 IsAnimBankSpriteVisible(u8 bank)
+bool8 IsBattlerSpriteVisible(u8 bank)
 {
     if (IsContest())
     {
-        if (bank == gAnimBankAttacker)
+        if (bank == gBattleAnimAttacker)
             return TRUE;
         else
             return FALSE;
     }
-    if (!IsBankSpritePresent(bank))
+    if (!IsBattlerSpritePresent(bank))
         return FALSE;
     if (IsContest())
         return TRUE; // this line wont ever be reached.
-    if (!gBattleSpritesDataPtr->bankData[bank].invisible || !gSprites[gBankSpriteIds[bank]].invisible)
+    if (!gBattleSpritesDataPtr->battlerData[bank].invisible || !gSprites[gBattlerSpriteIds[bank]].invisible)
         return TRUE;
 
     return FALSE;
@@ -699,7 +699,7 @@ void sub_80A438C(u8 bank, bool8 toBG_2, bool8 setSpriteInvisible)
         SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1);
         SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0);
 
-        bankSpriteId = gBankSpriteIds[bank];
+        bankSpriteId = gBattlerSpriteIds[bank];
 
         gBattle_BG1_X =  -(gSprites[bankSpriteId].pos1.x + gSprites[bankSpriteId].pos2.x) + 0x20;
         if (IsContest() && IsSpeciesNotUnown(gContestResources->field_18->field_0))
@@ -707,7 +707,7 @@ void sub_80A438C(u8 bank, bool8 toBG_2, bool8 setSpriteInvisible)
 
         gBattle_BG1_Y =  -(gSprites[bankSpriteId].pos1.y + gSprites[bankSpriteId].pos2.y) + 0x20;
         if (setSpriteInvisible)
-            gSprites[gBankSpriteIds[bank]].invisible = 1;
+            gSprites[gBattlerSpriteIds[bank]].invisible = 1;
 
         SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X);
         SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y);
@@ -718,7 +718,7 @@ void sub_80A438C(u8 bank, bool8 toBG_2, bool8 setSpriteInvisible)
         if (IsContest())
             bankIdentity = 0;
         else
-            bankIdentity = GetBankIdentity(bank);
+            bankIdentity = GetBattlerPosition(bank);
 
         sub_8118FBC(1, 0, 0, bankIdentity, unknownStruct.unk8, unknownStruct.unk0, unknownStruct.unk4, unknownStruct.unkA);
 
@@ -736,13 +736,13 @@ void sub_80A438C(u8 bank, bool8 toBG_2, bool8 setSpriteInvisible)
         SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1);
         SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0);
 
-        bankSpriteId = gBankSpriteIds[bank];
+        bankSpriteId = gBattlerSpriteIds[bank];
 
         gBattle_BG2_X =  -(gSprites[bankSpriteId].pos1.x + gSprites[bankSpriteId].pos2.x) + 0x20;
         gBattle_BG2_Y =  -(gSprites[bankSpriteId].pos1.y + gSprites[bankSpriteId].pos2.y) + 0x20;
 
         if (setSpriteInvisible)
-            gSprites[gBankSpriteIds[bank]].invisible = 1;
+            gSprites[gBattlerSpriteIds[bank]].invisible = 1;
 
         SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X);
         SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y);
@@ -750,7 +750,7 @@ void sub_80A438C(u8 bank, bool8 toBG_2, bool8 setSpriteInvisible)
         LoadPalette(&gPlttBufferUnfaded[0x100 + bank * 16], 0x90, 0x20);
         CpuCopy32(&gPlttBufferUnfaded[0x100 + bank * 16], (void*)(BG_PLTT + 0x120), 0x20);
 
-        sub_8118FBC(2, 0, 0, GetBankIdentity(bank), unknownStruct.unk8, unknownStruct.unk0 + 0x1000, unknownStruct.unk4 + 0x400, unknownStruct.unkA);
+        sub_8118FBC(2, 0, 0, GetBattlerPosition(bank), unknownStruct.unk8, unknownStruct.unk0 + 0x1000, unknownStruct.unk4 + 0x400, unknownStruct.unkA);
     }
 }
 
@@ -869,14 +869,14 @@ static void ScriptCmd_clearmonbg(void)
         animBankId = ANIM_DEF_PARTNER;
 
     if (animBankId == ANIM_ATTACKER || animBankId == ANIM_ATK_PARTNER)
-        bank = gAnimBankAttacker;
+        bank = gBattleAnimAttacker;
     else
-        bank = gAnimBankTarget;
+        bank = gBattleAnimTarget;
 
     if (sMonAnimTaskIdArray[0] != 0xFF)
-        gSprites[gBankSpriteIds[bank]].invisible = 0;
+        gSprites[gBattlerSpriteIds[bank]].invisible = 0;
     if (animBankId > 1 && sMonAnimTaskIdArray[1] != 0xFF)
-        gSprites[gBankSpriteIds[bank ^ BIT_MON]].invisible = 0;
+        gSprites[gBattlerSpriteIds[bank ^ BIT_FLANK]].invisible = 0;
     else
         animBankId = 0;
 
@@ -893,8 +893,8 @@ static void sub_80A4980(u8 taskId)
     if (gTasks[taskId].data[1] != 1)
     {
         u8 to_BG2;
-        u8 identity = GetBankIdentity(gTasks[taskId].data[2]);
-        if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+        u8 position = GetBattlerPosition(gTasks[taskId].data[2]);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
             to_BG2 = FALSE;
         else
             to_BG2 = TRUE;
@@ -931,14 +931,14 @@ static void ScriptCmd_monbg_22(void)
         animBankId = ANIM_DEF_PARTNER;
 
     if (animBankId == ANIM_ATTACKER || animBankId == ANIM_ATK_PARTNER)
-        bank = gAnimBankAttacker;
+        bank = gBattleAnimAttacker;
     else
-        bank = gAnimBankTarget;
+        bank = gBattleAnimTarget;
 
-    if (IsAnimBankSpriteVisible(bank))
+    if (IsBattlerSpriteVisible(bank))
     {
-        u8 identity = GetBankIdentity(bank);
-        if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+        u8 position = GetBattlerPosition(bank);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
             toBG_2 = FALSE;
         else
             toBG_2 = TRUE;
@@ -946,11 +946,11 @@ static void ScriptCmd_monbg_22(void)
         sub_80A438C(bank, toBG_2, FALSE);
     }
 
-    bank ^= BIT_MON;
-    if (animBankId > 1 && IsAnimBankSpriteVisible(bank))
+    bank ^= BIT_FLANK;
+    if (animBankId > 1 && IsBattlerSpriteVisible(bank))
     {
-        u8 identity = GetBankIdentity(bank);
-        if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+        u8 position = GetBattlerPosition(bank);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
             toBG_2 = FALSE;
         else
             toBG_2 = TRUE;
@@ -976,14 +976,14 @@ static void ScriptCmd_clearmonbg_23(void)
         animBankId = ANIM_DEF_PARTNER;
 
     if (animBankId == ANIM_ATTACKER || animBankId == ANIM_ATK_PARTNER)
-        bank = gAnimBankAttacker;
+        bank = gBattleAnimAttacker;
     else
-        bank = gAnimBankTarget;
+        bank = gBattleAnimTarget;
 
-    if (IsAnimBankSpriteVisible(bank))
-        gSprites[gBankSpriteIds[bank]].invisible = 0;
-    if (animBankId > 1 && IsAnimBankSpriteVisible(bank ^ BIT_MON))
-        gSprites[gBankSpriteIds[bank ^ BIT_MON]].invisible = 0;
+    if (IsBattlerSpriteVisible(bank))
+        gSprites[gBattlerSpriteIds[bank]].invisible = 0;
+    if (animBankId > 1 && IsBattlerSpriteVisible(bank ^ BIT_FLANK))
+        gSprites[gBattlerSpriteIds[bank ^ BIT_FLANK]].invisible = 0;
     else
         animBankId = 0;
 
@@ -1001,15 +1001,15 @@ static void sub_80A4BB0(u8 taskId)
     {
         bool8 toBG_2;
         u8 bank = gTasks[taskId].data[2];
-        u8 identity = GetBankIdentity(bank);
-        if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+        u8 position = GetBattlerPosition(bank);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
             toBG_2 = FALSE;
         else
             toBG_2 = TRUE;
 
-        if (IsAnimBankSpriteVisible(bank))
+        if (IsBattlerSpriteVisible(bank))
             sub_80A477C(toBG_2);
-        if (gTasks[taskId].data[0] > 1 && IsAnimBankSpriteVisible(bank ^ BIT_MON))
+        if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(bank ^ BIT_FLANK))
             sub_80A477C(toBG_2 ^ 1);
 
         DestroyTask(taskId);
@@ -1145,7 +1145,7 @@ static void ScriptCmd_fadetobgfromset(void)
 
     if (IsContest())
         gTasks[taskId].tBackgroundId = bg3;
-    else if (GetBankSide(gAnimBankTarget) == SIDE_PLAYER)
+    else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER)
         gTasks[taskId].tBackgroundId = bg2;
     else
         gTasks[taskId].tBackgroundId = bg1;
@@ -1270,21 +1270,21 @@ static void ScriptCmd_changebg(void)
 
 s8 BattleAnimAdjustPanning(s8 pan)
 {
-    if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].statusAnimActive)
+    if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive)
     {
-        if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER)
+        if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
             pan = PAN_SIDE_OPPONENT;
         else
             pan = PAN_SIDE_PLAYER;
     }
     else if (IsContest())
     {
-        if (gAnimBankAttacker != gAnimBankTarget || gAnimBankAttacker != 2 || pan != PAN_SIDE_OPPONENT)
+        if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != PAN_SIDE_OPPONENT)
             pan *= -1;
     }
-    else if (GetBankSide(gAnimBankAttacker) == SIDE_PLAYER)
+    else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER)
     {
-        if (GetBankSide(gAnimBankTarget) == SIDE_PLAYER)
+        if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER)
         {
             if (pan == PAN_SIDE_OPPONENT)
                 pan = PAN_SIDE_PLAYER;
@@ -1292,7 +1292,7 @@ s8 BattleAnimAdjustPanning(s8 pan)
                 pan *= -1;
         }
     }
-    else if (GetBankSide(gAnimBankTarget) == SIDE_OPPONENT)
+    else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT)
     {
         if (pan == PAN_SIDE_PLAYER)
             pan = PAN_SIDE_OPPONENT;
@@ -1312,16 +1312,16 @@ s8 BattleAnimAdjustPanning(s8 pan)
 
 s8 BattleAnimAdjustPanning2(s8 pan)
 {
-    if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].statusAnimActive)
+    if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive)
     {
-        if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER)
+        if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
             pan = PAN_SIDE_OPPONENT;
         else
             pan = PAN_SIDE_PLAYER;
     }
     else
     {
-        if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER || IsContest())
+        if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER || IsContest())
             pan = -pan;
     }
     return pan;
@@ -1701,12 +1701,12 @@ static void ScriptCmd_monbgprio_28(void)
     sBattleAnimScriptPtr += 2;
 
     if (wantedBank != ANIM_ATTACKER)
-        bank = gAnimBankTarget;
+        bank = gBattleAnimTarget;
     else
-        bank = gAnimBankAttacker;
+        bank = gBattleAnimAttacker;
 
-    bankIdentity = GetBankIdentity(bank);
-    if (!IsContest() && (bankIdentity == IDENTITY_PLAYER_MON1 || bankIdentity == IDENTITY_OPPONENT_MON2))
+    bankIdentity = GetBattlerPosition(bank);
+    if (!IsContest() && (bankIdentity == B_POSITION_PLAYER_LEFT || bankIdentity == B_POSITION_OPPONENT_RIGHT))
     {
         SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
         SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
@@ -1731,15 +1731,15 @@ static void ScriptCmd_monbgprio_2A(void)
 
     wantedBank = sBattleAnimScriptPtr[1];
     sBattleAnimScriptPtr += 2;
-    if (GetBankSide(gAnimBankAttacker) != GetBankSide(gAnimBankTarget))
+    if (GetBattlerSide(gBattleAnimAttacker) != GetBattlerSide(gBattleAnimTarget))
     {
         if (wantedBank != ANIM_ATTACKER)
-            bank = gAnimBankTarget;
+            bank = gBattleAnimTarget;
         else
-            bank = gAnimBankAttacker;
+            bank = gBattleAnimAttacker;
 
-        bankIdentity = GetBankIdentity(bank);
-        if (!IsContest() && (bankIdentity == IDENTITY_PLAYER_MON1 || bankIdentity == IDENTITY_OPPONENT_MON2))
+        bankIdentity = GetBattlerPosition(bank);
+        if (!IsContest() && (bankIdentity == B_POSITION_PLAYER_LEFT || bankIdentity == B_POSITION_OPPONENT_RIGHT))
         {
             SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
             SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
@@ -1751,7 +1751,7 @@ static void ScriptCmd_invisible(void)
 {
     u8 spriteId;
 
-    spriteId = GetAnimBankSpriteId(sBattleAnimScriptPtr[1]);
+    spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]);
     if (spriteId != 0xFF)
         gSprites[spriteId].invisible = 1;
 
@@ -1762,7 +1762,7 @@ static void ScriptCmd_visible(void)
 {
     u8 spriteId;
 
-    spriteId = GetAnimBankSpriteId(sBattleAnimScriptPtr[1]);
+    spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]);
     if (spriteId != 0xFF)
         gSprites[spriteId].invisible = 0;
 
@@ -1778,17 +1778,17 @@ static void ScriptCmd_doublebattle_2D(void)
     wantedBank = sBattleAnimScriptPtr[1];
     sBattleAnimScriptPtr += 2;
     if (!IsContest() && IsDoubleBattle()
-     && GetBankSide(gAnimBankAttacker) == GetBankSide(gAnimBankTarget))
+     && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget))
     {
         if (wantedBank == ANIM_ATTACKER)
         {
-            r4 = sub_80A8364(gAnimBankAttacker);
-            spriteId = GetAnimBankSpriteId(ANIM_ATTACKER);
+            r4 = sub_80A8364(gBattleAnimAttacker);
+            spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER);
         }
         else
         {
-            r4 = sub_80A8364(gAnimBankTarget);
-            spriteId = GetAnimBankSpriteId(ANIM_TARGET);
+            r4 = sub_80A8364(gBattleAnimTarget);
+            spriteId = GetAnimBattlerSpriteId(ANIM_TARGET);
         }
         if (spriteId != 0xFF)
         {
@@ -1813,17 +1813,17 @@ static void ScriptCmd_doublebattle_2E(void)
     wantedBank = sBattleAnimScriptPtr[1];
     sBattleAnimScriptPtr += 2;
     if (!IsContest() && IsDoubleBattle()
-     && GetBankSide(gAnimBankAttacker) == GetBankSide(gAnimBankTarget))
+     && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget))
     {
         if (wantedBank == ANIM_ATTACKER)
         {
-            r4 = sub_80A8364(gAnimBankAttacker);
-            spriteId = GetAnimBankSpriteId(ANIM_ATTACKER);
+            r4 = sub_80A8364(gBattleAnimAttacker);
+            spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER);
         }
         else
         {
-            r4 = sub_80A8364(gAnimBankTarget);
-            spriteId = GetAnimBankSpriteId(ANIM_TARGET);
+            r4 = sub_80A8364(gBattleAnimTarget);
+            spriteId = GetAnimBattlerSpriteId(ANIM_TARGET);
         }
 
         if (spriteId != 0xFF && r4 == 2)

src/battle_bg.c

@@ -273,13 +273,13 @@ static void sub_8035AE4(u8 taskId, u8 bank, u8 bgId, u8 destX, u8 destY)
 
 static void sub_8035C4C(void)
 {
-    if (gBattleOutcome == BATTLE_DREW)
+    if (gBattleOutcome == B_OUTCOME_DREW)
     {
         BattleHandleAddTextPrinter(gText_Draw, 0x15);
     }
     else if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
     {
-        if (gBattleOutcome == BATTLE_WON)
+        if (gBattleOutcome == B_OUTCOME_WON)
         {
             switch (gLinkPlayers[gBattleScripting.multiplayerId].lp_field_18)
             {
@@ -324,7 +324,7 @@ static void sub_8035C4C(void)
             }
         }
     }
-    else if (gBattleOutcome == BATTLE_WON)
+    else if (gBattleOutcome == B_OUTCOME_WON)
     {
         if (gLinkPlayers[gBattleScripting.multiplayerId].lp_field_18 != 0)
         {
@@ -363,7 +363,7 @@ void sub_8035D74(u8 taskId)
     case 0:
         if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
         {
-            for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+            for (i = 0; i < MAX_BATTLERS_COUNT; i++)
             {
                 name = gLinkPlayers[i].name;
                 linkPlayer = &gLinkPlayers[i];

src/battle_controller_safari.c

@@ -22,21 +22,21 @@
 #include "data2.h"
 #include "pokeblock.h"
 
-extern u32 gBattleExecBuffer;
-extern u8 gActiveBank;
-extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT];
-extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT];
-extern u8 gNoOfAllBanks;
+extern u32 gBattleControllerExecFlags;
+extern u8 gActiveBattler;
+extern u8 gBattlerSpriteIds[MAX_BATTLERS_COUNT];
+extern u8 gActionSelectionCursor[MAX_BATTLERS_COUNT];
+extern u8 gBattlersCount;
 extern bool8 gDoingBattleAnim;
-extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void);
+extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(void);
 extern void (*gPreBattleCallback1)(void);
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200];
-extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200];
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern u8 gBattleBufferA[MAX_BATTLERS_COUNT][0x200];
+extern u8 gBattleBufferB[MAX_BATTLERS_COUNT][0x200];
+extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
 extern struct SpriteTemplate gUnknown_0202499C;
 extern u16 gSpecialVar_ItemId;
-extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT];
+extern u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT];
 extern u8 gBattleOutcome;
 extern u16 gBattle_BG0_X;
 extern u16 gBattle_BG0_Y;
@@ -180,15 +180,15 @@ static void nullsub_114(void)
 
 void SetControllerToSafari(void)
 {
-    gBattleBankFunc[gActiveBank] = SafariBufferRunCommand;
+    gBattlerControllerFuncs[gActiveBattler] = SafariBufferRunCommand;
 }
 
 static void SafariBufferRunCommand(void)
 {
-    if (gBattleExecBuffer & gBitTable[gActiveBank])
+    if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
     {
-        if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sSafariBufferCommands))
-            sSafariBufferCommands[gBattleBufferA[gActiveBank][0]]();
+        if (gBattleBufferA[gActiveBattler][0] < ARRAY_COUNT(sSafariBufferCommands))
+            sSafariBufferCommands[gBattleBufferA[gActiveBattler][0]]();
         else
             SafariBufferExecCompleted();
     }
@@ -200,68 +200,68 @@ static void HandleInputChooseAction(void)
     {
         PlaySE(SE_SELECT);
 
-        switch (gActionSelectionCursor[gActiveBank])
+        switch (gActionSelectionCursor[gActiveBattler])
         {
         case 0:
-            EmitTwoReturnValues(1, ACTION_SAFARI_ZONE_BALL, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_BALL, 0);
             break;
         case 1:
-            EmitTwoReturnValues(1, ACTION_POKEBLOCK_CASE, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_POKEBLOCK, 0);
             break;
         case 2:
-            EmitTwoReturnValues(1, ACTION_GO_NEAR, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_GO_NEAR, 0);
             break;
         case 3:
-            EmitTwoReturnValues(1, ACTION_SAFARI_ZONE_RUN, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_RUN, 0);
             break;
         }
         SafariBufferExecCompleted();
     }
     else if (gMain.newKeys & DPAD_LEFT)
     {
-        if (gActionSelectionCursor[gActiveBank] & 1)
+        if (gActionSelectionCursor[gActiveBattler] & 1)
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
-            gActionSelectionCursor[gActiveBank] ^= 1;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
+            gActionSelectionCursor[gActiveBattler] ^= 1;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
         }
     }
     else if (gMain.newKeys & DPAD_RIGHT)
     {
-        if (!(gActionSelectionCursor[gActiveBank] & 1))
+        if (!(gActionSelectionCursor[gActiveBattler] & 1))
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
-            gActionSelectionCursor[gActiveBank] ^= 1;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
+            gActionSelectionCursor[gActiveBattler] ^= 1;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
         }
     }
     else if (gMain.newKeys & DPAD_UP)
     {
-        if (gActionSelectionCursor[gActiveBank] & 2)
+        if (gActionSelectionCursor[gActiveBattler] & 2)
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
-            gActionSelectionCursor[gActiveBank] ^= 2;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
+            gActionSelectionCursor[gActiveBattler] ^= 2;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
         }
     }
     else if (gMain.newKeys & DPAD_DOWN)
     {
-        if (!(gActionSelectionCursor[gActiveBank] & 2))
+        if (!(gActionSelectionCursor[gActiveBattler] & 2))
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
-            gActionSelectionCursor[gActiveBank] ^= 2;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
+            gActionSelectionCursor[gActiveBattler] ^= 2;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
         }
     }
 }
 
 static void CompleteOnBankSpriteCallbackDummy(void)
 {
-    if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy)
+    if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
         SafariBufferExecCompleted();
 }
 
@@ -273,7 +273,7 @@ static void CompleteOnInactiveTextPrinter(void)
 
 static void CompleteOnHealthboxSpriteCallbackDummy(void)
 {
-    if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy)
+    if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
         SafariBufferExecCompleted();
 }
 
@@ -289,7 +289,7 @@ static void sub_81595E4(void)
 
 static void CompleteOnSpecialAnimDone(void)
 {
-    if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive)
+    if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
         SafariBufferExecCompleted();
 }
 
@@ -297,7 +297,7 @@ static void SafariOpenPokeblockCase(void)
 {
     if (!gPaletteFade.active)
     {
-        gBattleBankFunc[gActiveBank] = CompleteWhenChosePokeblock;
+        gBattlerControllerFuncs[gActiveBattler] = CompleteWhenChosePokeblock;
         FreeAllWindowBuffers();
         OpenPokeblockCaseInBattle();
     }
@@ -307,36 +307,36 @@ static void CompleteWhenChosePokeblock(void)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
-        EmitOneReturnValue(1, gSpecialVar_ItemId);
+        BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
         SafariBufferExecCompleted();
     }
 }
 
 static void CompleteOnFinishedBattleAnimation(void)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive)
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
         SafariBufferExecCompleted();
 }
 
 static void SafariBufferExecCompleted(void)
 {
-    gBattleBankFunc[gActiveBank] = SafariBufferRunCommand;
+    gBattlerControllerFuncs[gActiveBattler] = SafariBufferRunCommand;
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
     {
         u8 playerId = GetMultiplayerId();
 
         PrepareBufferDataTransferLink(2, 4, &playerId);
-        gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP;
+        gBattleBufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP;
     }
     else
     {
-        gBattleExecBuffer &= ~gBitTable[gActiveBank];
+        gBattleControllerExecFlags &= ~gBitTable[gActiveBattler];
     }
 }
 
 static void CompleteOnFinishedStatusAnimation(void)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive)
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
         SafariBufferExecCompleted();
 }
 
@@ -377,18 +377,18 @@ static void SafariHandleReturnMonToBall(void)
 
 static void SafariHandleDrawTrainerPic(void)
 {
-    DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, gActiveBank);
-    sub_806A12C(gSaveBlock2Ptr->playerGender, GetBankIdentity(gActiveBank));
-    gBankSpriteIds[gActiveBank] = CreateSprite(
+    DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, gActiveBattler);
+    sub_806A12C(gSaveBlock2Ptr->playerGender, GetBattlerPosition(gActiveBattler));
+    gBattlerSpriteIds[gActiveBattler] = CreateSprite(
       &gUnknown_0202499C,
       80,
       (8 - gTrainerBackPicCoords[gSaveBlock2Ptr->playerGender].coords) * 4 + 80,
       30);
-    gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank;
-    gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240;
-    gSprites[gBankSpriteIds[gActiveBank]].data[0] = -2;
-    gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC;
-    gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy;
+    gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler;
+    gSprites[gBattlerSpriteIds[gActiveBattler]].pos2.x = 240;
+    gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = -2;
+    gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_805D7AC;
+    gBattlerControllerFuncs[gActiveBattler] = CompleteOnBankSpriteCallbackDummy;
 }
 
 static void SafariHandleTrainerSlide(void)
@@ -415,18 +415,18 @@ static void SafariHandleSuccessBallThrowAnim(void)
 {
     gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS;
     gDoingBattleAnim = TRUE;
-    InitAndLaunchSpecialAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_SAFARI_BALL_THROW);
-    gBattleBankFunc[gActiveBank] = CompleteOnSpecialAnimDone;
+    InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_SAFARI_BALL_THROW);
+    gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
 static void SafariHandleBallThrowAnim(void)
 {
-    u8 ballThrowCaseId = gBattleBufferA[gActiveBank][1];
+    u8 ballThrowCaseId = gBattleBufferA[gActiveBattler][1];
 
     gBattleSpritesDataPtr->animationData->ballThrowCaseId = ballThrowCaseId;
     gDoingBattleAnim = TRUE;
-    InitAndLaunchSpecialAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_SAFARI_BALL_THROW);
-    gBattleBankFunc[gActiveBank] = CompleteOnSpecialAnimDone;
+    InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_SAFARI_BALL_THROW);
+    gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
 static void SafariHandlePause(void)
@@ -445,15 +445,15 @@ static void SafariHandlePrintString(void)
 
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
-    stringId = (u16*)(&gBattleBufferA[gActiveBank][2]);
+    stringId = (u16*)(&gBattleBufferA[gActiveBattler][2]);
     BufferStringBattle(*stringId);
     BattleHandleAddTextPrinter(gDisplayedStringBattle, 0);
-    gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter;
+    gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter;
 }
 
 static void SafariHandlePrintSelectionString(void)
 {
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         SafariHandlePrintString();
     else
         SafariBufferExecCompleted();
@@ -465,7 +465,7 @@ static void HandleChooseActionAfterDma3(void)
     {
         gBattle_BG0_X = 0;
         gBattle_BG0_Y = 160;
-        gBattleBankFunc[gActiveBank] = HandleInputChooseAction;
+        gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseAction;
     }
 }
 
@@ -473,13 +473,13 @@ static void SafariHandleChooseAction(void)
 {
     s32 i;
 
-    gBattleBankFunc[gActiveBank] = HandleChooseActionAfterDma3;
+    gBattlerControllerFuncs[gActiveBattler] = HandleChooseActionAfterDma3;
     BattleHandleAddTextPrinter(gText_SafariZoneMenu, 2);
 
     for (i = 0; i < 4; i++)
         ActionSelectionDestroyCursorAt(i);
 
-    ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+    ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
     BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo2);
     BattleHandleAddTextPrinter(gDisplayedStringBattle, 1);
 }
@@ -499,8 +499,8 @@ static void SafariHandleChooseItem(void)
     s32 i;
 
     BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
-    gBattleBankFunc[gActiveBank] = SafariOpenPokeblockCase;
-    gBankInMenu = gActiveBank;
+    gBattlerControllerFuncs[gActiveBattler] = SafariOpenPokeblockCase;
+    gBankInMenu = gActiveBattler;
 }
 
 static void SafariHandleChoosePokemon(void)
@@ -525,7 +525,7 @@ static void SafariHandleExpUpdate(void)
 
 static void SafariHandleStatusIconUpdate(void)
 {
-    UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_SAFARI_BALLS_TEXT);
+    UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_SAFARI_BALLS_TEXT);
     SafariBufferExecCompleted();
 }
 
@@ -613,25 +613,25 @@ static void SafariHandlePlaySE(void)
 {
     s8 pan;
 
-    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         pan = PAN_SIDE_PLAYER;
     else
         pan = PAN_SIDE_OPPONENT;
 
-    PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan);
+    PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     SafariBufferExecCompleted();
 }
 
 static void SafariHandlePlayFanfareOrBGM(void)
 {
-    if (gBattleBufferA[gActiveBank][3])
+    if (gBattleBufferA[gActiveBattler][3])
     {
         BattleStopLowHpSound();
-        PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8));
+        PlayBGM(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
     }
     else
     {
-        PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8));
+        PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
     }
 
     SafariBufferExecCompleted();
@@ -639,7 +639,7 @@ static void SafariHandlePlayFanfareOrBGM(void)
 
 static void SafariHandleFaintingCry(void)
 {
-    u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES);
+    u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
 
     PlayCry1(species, 25);
     SafariBufferExecCompleted();
@@ -647,17 +647,17 @@ static void SafariHandleFaintingCry(void)
 
 static void SafariHandleIntroSlide(void)
 {
-    HandleIntroSlide(gBattleBufferA[gActiveBank][1]);
+    HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
     gUnknown_020243FC |= 1;
     SafariBufferExecCompleted();
 }
 
 static void SafariHandleIntroTrainerBallThrow(void)
 {
-    UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_SAFARI_ALL_TEXT);
-    sub_8076918(gActiveBank);
-    SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]);
-    gBattleBankFunc[gActiveBank] = CompleteOnHealthboxSpriteCallbackDummy;
+    UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_SAFARI_ALL_TEXT);
+    sub_8076918(gActiveBattler);
+    SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]);
+    gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthboxSpriteCallbackDummy;
 }
 
 static void SafariHandleDrawPartyStatusSummary(void)
@@ -682,13 +682,13 @@ static void SafariHandleSpriteInvisibility(void)
 
 static void SafariHandleBattleAnimation(void)
 {
-    u8 animationId = gBattleBufferA[gActiveBank][1];
-    u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8);
+    u8 animationId = gBattleBufferA[gActiveBattler][1];
+    u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
 
-    if (TryHandleLaunchBattleTableAnimation(gActiveBank, gActiveBank, gActiveBank, animationId, argument))
+    if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
         SafariBufferExecCompleted();
     else
-        gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation;
+        gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
 }
 
 static void SafariHandleLinkStandbyMsg(void)
@@ -703,12 +703,12 @@ static void SafariHandleResetActionMoveSelection(void)
 
 static void SafariHandleCmd55(void)
 {
-    gBattleOutcome = gBattleBufferA[gActiveBank][1];
+    gBattleOutcome = gBattleBufferA[gActiveBattler][1];
     FadeOutMapMusic(5);
     BeginFastPaletteFade(3);
     SafariBufferExecCompleted();
     if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_WILD))
-        gBattleBankFunc[gActiveBank] = sub_81595E4;
+        gBattlerControllerFuncs[gActiveBattler] = sub_81595E4;
 }
 
 static void nullsub_115(void)

src/battle_gfx_sfx_util.c

@@ -23,17 +23,17 @@
 #include "contest.h"
 #include "constants/songs.h"
 
-extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200];
-extern u8 gActiveBank;
-extern u8 gNoOfAllBanks;
+extern u8 gBattleBufferA[MAX_BATTLERS_COUNT][0x200];
+extern u8 gActiveBattler;
+extern u8 gBattlersCount;
 extern u16 gUnknown_020243FC;
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
-extern u8 gBanksByIdentity[BATTLE_BANKS_COUNT];
-extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT];
-extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT];
-extern u8 gBattleMonForms[BATTLE_BANKS_COUNT];
-extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
+extern u8 gBattlerPositions[MAX_BATTLERS_COUNT];
+extern u8 gBattlerSpriteIds[MAX_BATTLERS_COUNT];
+extern u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT];
+extern u8 gBattleMonForms[MAX_BATTLERS_COUNT];
+extern u32 gTransformedPersonalities[MAX_BATTLERS_COUNT];
 extern struct MusicPlayerInfo gMPlayInfo_SE1;
 extern struct MusicPlayerInfo gMPlayInfo_SE2;
 extern struct MusicPlayerInfo gMPlayInfo_BGM;
@@ -109,7 +109,7 @@ static const struct CompressedSpriteSheet gUnknown_0832C100 =
     gUnknown_08C1F8E8, 0x1000, TAG_HEALTHBOX_SAFARI_TILE
 };
 
-static const struct CompressedSpriteSheet gUnknown_0832C108[BATTLE_BANKS_COUNT] =
+static const struct CompressedSpriteSheet gUnknown_0832C108[MAX_BATTLERS_COUNT] =
 {
     {gBlankGfxCompressed, 0x0100, 0xd704},
     {gBlankGfxCompressed, 0x0120, 0xd705},
@@ -127,10 +127,10 @@ static const struct SpritePalette gUnknown_0832C128[2] =
 void AllocateBattleSpritesData(void)
 {
     gBattleSpritesDataPtr = AllocZeroed(sizeof(struct BattleSpriteData));
-    gBattleSpritesDataPtr->bankData = AllocZeroed(sizeof(struct BattleSpriteInfo) * BATTLE_BANKS_COUNT);
-    gBattleSpritesDataPtr->healthBoxesData = AllocZeroed(sizeof(struct BattleHealthboxInfo) * BATTLE_BANKS_COUNT);
+    gBattleSpritesDataPtr->battlerData = AllocZeroed(sizeof(struct BattleSpriteInfo) * MAX_BATTLERS_COUNT);
+    gBattleSpritesDataPtr->healthBoxesData = AllocZeroed(sizeof(struct BattleHealthboxInfo) * MAX_BATTLERS_COUNT);
     gBattleSpritesDataPtr->animationData = AllocZeroed(sizeof(struct BattleAnimationInfo));
-    gBattleSpritesDataPtr->battleBars = AllocZeroed(sizeof(struct BattleBarInfo) * BATTLE_BANKS_COUNT);
+    gBattleSpritesDataPtr->battleBars = AllocZeroed(sizeof(struct BattleBarInfo) * MAX_BATTLERS_COUNT);
 }
 
 void FreeBattleSpritesData(void)
@@ -141,7 +141,7 @@ void FreeBattleSpritesData(void)
     FREE_AND_SET_NULL(gBattleSpritesDataPtr->battleBars);
     FREE_AND_SET_NULL(gBattleSpritesDataPtr->animationData);
     FREE_AND_SET_NULL(gBattleSpritesDataPtr->healthBoxesData);
-    FREE_AND_SET_NULL(gBattleSpritesDataPtr->bankData);
+    FREE_AND_SET_NULL(gBattleSpritesDataPtr->battlerData);
     FREE_AND_SET_NULL(gBattleSpritesDataPtr);
 }
 
@@ -149,17 +149,17 @@ u16 ChooseMoveAndTargetInBattlePalace(void)
 {
     s32 i, var1, var2;
     s32 chosenMoveId = -1;
-    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]);
-    u8 unusableMovesBits = CheckMoveLimitations(gActiveBank, 0, 0xFF);
+    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBattler][4]);
+    u8 unusableMovesBits = CheckMoveLimitations(gActiveBattler, 0, 0xFF);
     s32 percent = Random() % 100;
 
-    i = (gBattleStruct->field_92 & gBitTable[gActiveBank]) ? 2 : 0;
+    i = (gBattleStruct->field_92 & gBitTable[gActiveBattler]) ? 2 : 0;
     var2 = i;
     var1 = i + 2;
 
     for (; i < var1; i++)
     {
-        if (gUnknown_0831C494[GetNatureFromPersonality(gBattleMons[gActiveBank].personality)][i] > percent)
+        if (gUnknown_0831C494[GetNatureFromPersonality(gBattleMons[gActiveBattler].personality)][i] > percent)
             break;
     }
 
@@ -234,13 +234,13 @@ u16 ChooseMoveAndTargetInBattlePalace(void)
 
             if (Random() % 100 > 49)
             {
-                gProtectStructs[gActiveBank].flag_x10 = 1;
+                gProtectStructs[gActiveBattler].flag_x10 = 1;
                 return 0;
             }
         }
         else
         {
-            gProtectStructs[gActiveBank].flag_x10 = 1;
+            gProtectStructs[gActiveBattler].flag_x10 = 1;
             return 0;
         }
     }
@@ -258,11 +258,11 @@ u16 ChooseMoveAndTargetInBattlePalace(void)
     }
 
     if (var1 & MOVE_TARGET_x10)
-        chosenMoveId |= (gActiveBank << 8);
+        chosenMoveId |= (gActiveBattler << 8);
     else if (var1 == MOVE_TARGET_SELECTED)
         chosenMoveId |= (BattlePalaceGetTargetRetValue());
     else
-        chosenMoveId |= (GetBankByIdentity((GetBankIdentity(gActiveBank) & BIT_SIDE) ^ BIT_SIDE) << 8);
+        chosenMoveId |= (GetBattlerAtPosition((GetBattlerPosition(gActiveBattler) & BIT_SIDE) ^ BIT_SIDE) << 8);
 
     return chosenMoveId;
 }
@@ -297,21 +297,21 @@ static u16 BattlePalaceGetTargetRetValue(void)
     {
         u8 opposing1, opposing2;
 
-        if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         {
-            opposing1 = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
-            opposing2 = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
+            opposing1 = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
+            opposing2 = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
         }
         else
         {
-            opposing1 = GetBankByIdentity(IDENTITY_PLAYER_MON1);
-            opposing2 = GetBankByIdentity(IDENTITY_PLAYER_MON2);
+            opposing1 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
+            opposing2 = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
         }
 
         if (gBattleMons[opposing1].hp == gBattleMons[opposing2].hp)
-            return (((gActiveBank & BIT_SIDE) ^ BIT_SIDE) + (Random() & 2)) << 8;
+            return (((gActiveBattler & BIT_SIDE) ^ BIT_SIDE) + (Random() & 2)) << 8;
 
-        switch (gUnknown_0831C604[GetNatureFromPersonality(gBattleMons[gActiveBank].personality)])
+        switch (gUnknown_0831C604[GetNatureFromPersonality(gBattleMons[gActiveBattler].personality)])
         {
         case 0:
             if (gBattleMons[opposing1].hp > gBattleMons[opposing2].hp)
@@ -324,11 +324,11 @@ static u16 BattlePalaceGetTargetRetValue(void)
             else
                 return opposing2 << 8;
         case 2:
-            return (((gActiveBank & BIT_SIDE) ^ BIT_SIDE) + (Random() & 2)) << 8;
+            return (((gActiveBattler & BIT_SIDE) ^ BIT_SIDE) + (Random() & 2)) << 8;
         }
     }
 
-    return (gActiveBank ^ BIT_SIDE) << 8;
+    return (gActiveBattler ^ BIT_SIDE) << 8;
 }
 
 void sub_805D714(struct Sprite *sprite)
@@ -388,36 +388,36 @@ static void sub_805D7EC(struct Sprite *sprite)
 
 void InitAndLaunchChosenStatusAnimation(bool8 isStatus2, u32 status)
 {
-    gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive = 1;
+    gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive = 1;
     if (!isStatus2)
     {
-        if (status == STATUS_FREEZE)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_FRZ);
-        else if (status == STATUS_POISON || status & STATUS_TOXIC_POISON)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_PSN);
-        else if (status == STATUS_BURN)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_BRN);
-        else if (status & STATUS_SLEEP)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_SLP);
-        else if (status == STATUS_PARALYSIS)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_PRZ);
+        if (status == STATUS1_FREEZE)
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_FRZ);
+        else if (status == STATUS1_POISON || status & STATUS1_TOXIC_POISON)
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_PSN);
+        else if (status == STATUS1_BURN)
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_BRN);
+        else if (status & STATUS1_SLEEP)
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_SLP);
+        else if (status == STATUS1_PARALYSIS)
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_PRZ);
         else // no animation
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive = 0;
+            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive = 0;
     }
     else
     {
         if (status & STATUS2_INFATUATION)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_INFATUATION);
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_INFATUATION);
         else if (status & STATUS2_CONFUSION)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_CONFUSION);
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_CONFUSION);
         else if (status & STATUS2_CURSED)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_CURSED);
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_CURSED);
         else if (status & STATUS2_NIGHTMARE)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_NIGHTMARE);
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_NIGHTMARE);
         else if (status & STATUS2_WRAPPED)
-            LaunchStatusAnimation(gActiveBank, B_ANIM_STATUS_WRAPPED); // this animation doesn't actually exist
+            LaunchStatusAnimation(gActiveBattler, B_ANIM_STATUS_WRAPPED); // this animation doesn't actually exist
         else // no animation
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive = 0;
+            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive = 0;
     }
 }
 
@@ -432,22 +432,22 @@ bool8 TryHandleLaunchBattleTableAnimation(u8 activeBank, u8 atkBank, u8 defBank,
         gBattleMonForms[activeBank] = (argument & ~(0x80));
         return TRUE;
     }
-    if (gBattleSpritesDataPtr->bankData[activeBank].behindSubstitute
+    if (gBattleSpritesDataPtr->battlerData[activeBank].behindSubstitute
         && !ShouldAnimBeDoneRegardlessOfSubsitute(tableId))
     {
         return TRUE;
     }
-    if (gBattleSpritesDataPtr->bankData[activeBank].behindSubstitute
+    if (gBattleSpritesDataPtr->battlerData[activeBank].behindSubstitute
         && tableId == B_ANIM_SUBSTITUTE_FADE
-        && gSprites[gBankSpriteIds[activeBank]].invisible)
+        && gSprites[gBattlerSpriteIds[activeBank]].invisible)
     {
-        LoadBattleMonGfxAndAnimate(activeBank, TRUE, gBankSpriteIds[activeBank]);
+        LoadBattleMonGfxAndAnimate(activeBank, TRUE, gBattlerSpriteIds[activeBank]);
         ClearBehindSubstituteBit(activeBank);
         return TRUE;
     }
 
-    gAnimBankAttacker = atkBank;
-    gAnimBankTarget = defBank;
+    gBattleAnimAttacker = atkBank;
+    gBattleAnimTarget = defBank;
     gBattleSpritesDataPtr->animationData->animArg = argument;
     LaunchBattleAnimation(gBattleAnims_VariousTable, tableId, FALSE);
     taskId = CreateTask(Task_ClearBitWhenBattleTableAnimDone, 10);
@@ -491,8 +491,8 @@ void InitAndLaunchSpecialAnimation(u8 activeBank, u8 atkBank, u8 defBank, u8 tab
 {
     u8 taskId;
 
-    gAnimBankAttacker = atkBank;
-    gAnimBankTarget = defBank;
+    gBattleAnimAttacker = atkBank;
+    gBattleAnimTarget = defBank;
     LaunchBattleAnimation(gBattleAnims_Special, tableId, FALSE);
     taskId = CreateTask(Task_ClearBitWhenSpecialAnimDone, 10);
     gTasks[taskId].tBank = activeBank;
@@ -524,7 +524,7 @@ bool8 mplay_80342A4(u8 bank)
     if (IsSEPlaying())
     {
         gBattleSpritesDataPtr->healthBoxesData[bank].field_8++;
-        if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_8 < 30)
+        if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_8 < 30)
             return TRUE;
 
         m4aMPlayStop(&gMPlayInfo_SE1);
@@ -543,32 +543,32 @@ void BattleLoadOpponentMonSpriteGfx(struct Pokemon *mon, u8 bank)
 {
     u32 monsPersonality, currentPersonality, otId;
     u16 species;
-    u8 identity;
+    u8 position;
     u16 paletteOffset;
     const void *lzPaletteData;
 
     monsPersonality = GetMonData(mon, MON_DATA_PERSONALITY);
 
-    if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_NONE)
+    if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies == SPECIES_NONE)
     {
         species = GetMonData(mon, MON_DATA_SPECIES);
         currentPersonality = monsPersonality;
     }
     else
     {
-        species = gBattleSpritesDataPtr->bankData[bank].transformSpecies;
+        species = gBattleSpritesDataPtr->battlerData[bank].transformSpecies;
         currentPersonality = gTransformedPersonalities[bank];
     }
 
     otId = GetMonData(mon, MON_DATA_OT_ID);
-    identity = GetBankIdentity(bank);
+    position = GetBattlerPosition(bank);
     HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species],
-                                              gMonSpritesGfxPtr->sprites[identity],
+                                              gMonSpritesGfxPtr->sprites[position],
                                               species, currentPersonality);
 
     paletteOffset = 0x100 + bank * 16;
 
-    if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_NONE)
+    if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies == SPECIES_NONE)
         lzPaletteData = GetMonFrontSpritePal(mon);
     else
         lzPaletteData = GetFrontSpritePalFromSpeciesAndPersonality(species, otId, monsPersonality);
@@ -585,7 +585,7 @@ void BattleLoadOpponentMonSpriteGfx(struct Pokemon *mon, u8 bank)
     }
 
     // transform's pink color
-    if (gBattleSpritesDataPtr->bankData[bank].transformSpecies != SPECIES_NONE)
+    if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies != SPECIES_NONE)
     {
         BlendPalette(paletteOffset, 16, 6, 0x7FFF);
         CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32);
@@ -596,42 +596,42 @@ void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 bank)
 {
     u32 monsPersonality, currentPersonality, otId;
     u16 species;
-    u8 identity;
+    u8 position;
     u16 paletteOffset;
     const void *lzPaletteData;
 
     monsPersonality = GetMonData(mon, MON_DATA_PERSONALITY);
 
-    if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_NONE)
+    if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies == SPECIES_NONE)
     {
         species = GetMonData(mon, MON_DATA_SPECIES);
         currentPersonality = monsPersonality;
     }
     else
     {
-        species = gBattleSpritesDataPtr->bankData[bank].transformSpecies;
+        species = gBattleSpritesDataPtr->battlerData[bank].transformSpecies;
         currentPersonality = gTransformedPersonalities[bank];
     }
 
     otId = GetMonData(mon, MON_DATA_OT_ID);
-    identity = GetBankIdentity(bank);
+    position = GetBattlerPosition(bank);
 
-    if (sub_80688F8(1, bank) == 1 || gBattleSpritesDataPtr->bankData[bank].transformSpecies != SPECIES_NONE)
+    if (sub_80688F8(1, bank) == 1 || gBattleSpritesDataPtr->battlerData[bank].transformSpecies != SPECIES_NONE)
     {
         HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[species],
-                                                  gMonSpritesGfxPtr->sprites[identity],
+                                                  gMonSpritesGfxPtr->sprites[position],
                                                   species, currentPersonality);
     }
     else
     {
         HandleLoadSpecialPokePic(&gMonBackPicTable[species],
-                                gMonSpritesGfxPtr->sprites[identity],
+                                gMonSpritesGfxPtr->sprites[position],
                                 species, currentPersonality);
     }
 
     paletteOffset = 0x100 + bank * 16;
 
-    if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_NONE)
+    if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies == SPECIES_NONE)
         lzPaletteData = GetMonFrontSpritePal(mon);
     else
         lzPaletteData = GetFrontSpritePalFromSpeciesAndPersonality(species, otId, monsPersonality);
@@ -648,7 +648,7 @@ void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 bank)
     }
 
     // transform's pink color
-    if (gBattleSpritesDataPtr->bankData[bank].transformSpecies != SPECIES_NONE)
+    if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies != SPECIES_NONE)
     {
         BlendPalette(paletteOffset, 16, 6, 0x7FFF);
         CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32);
@@ -665,18 +665,18 @@ void nullsub_24(u16 species)
 
 void DecompressTrainerFrontPic(u16 frontPicId, u8 bank)
 {
-    u8 identity = GetBankIdentity(bank);
+    u8 position = GetBattlerPosition(bank);
     DecompressPicFromTable_2(&gTrainerFrontPicTable[frontPicId],
-                             gMonSpritesGfxPtr->sprites[identity],
+                             gMonSpritesGfxPtr->sprites[position],
                              SPECIES_NONE);
     LoadCompressedObjectPalette(&gTrainerFrontPicPaletteTable[frontPicId]);
 }
 
 void DecompressTrainerBackPic(u16 backPicId, u8 bank)
 {
-    u8 identity = GetBankIdentity(bank);
+    u8 position = GetBattlerPosition(bank);
     DecompressPicFromTable_2(&gTrainerBackPicTable[backPicId],
-                             gMonSpritesGfxPtr->sprites[identity],
+                             gMonSpritesGfxPtr->sprites[position],
                              SPECIES_NONE);
     LoadCompressedPalette(gTrainerBackPicPaletteTable[backPicId].data,
                           0x100 + 16 * bank, 0x20);
@@ -713,7 +713,7 @@ void sub_805DFFC(void)
         numberOfBanks = 4;
     }
     for (i = 0; i < numberOfBanks; i++)
-        LoadCompressedObjectPic(&gUnknown_0832C108[gBanksByIdentity[i]]);
+        LoadCompressedObjectPic(&gUnknown_0832C108[gBattlerPositions[i]]);
 }
 
 bool8 BattleLoadAllHealthBoxesGfx(u8 state)
@@ -739,9 +739,9 @@ bool8 BattleLoadAllHealthBoxesGfx(u8 state)
             else if (state == 3)
                 LoadCompressedObjectPic(&gUnknown_0832C0D8);
             else if (state == 4)
-                LoadCompressedObjectPic(&gUnknown_0832C108[gBanksByIdentity[0]]);
+                LoadCompressedObjectPic(&gUnknown_0832C108[gBattlerPositions[0]]);
             else if (state == 5)
-                LoadCompressedObjectPic(&gUnknown_0832C108[gBanksByIdentity[1]]);
+                LoadCompressedObjectPic(&gUnknown_0832C108[gBattlerPositions[1]]);
             else
                 retVal = TRUE;
         }
@@ -756,13 +756,13 @@ bool8 BattleLoadAllHealthBoxesGfx(u8 state)
             else if (state == 5)
                 LoadCompressedObjectPic(&gUnknown_0832C0F0[1]);
             else if (state == 6)
-                LoadCompressedObjectPic(&gUnknown_0832C108[gBanksByIdentity[0]]);
+                LoadCompressedObjectPic(&gUnknown_0832C108[gBattlerPositions[0]]);
             else if (state == 7)
-                LoadCompressedObjectPic(&gUnknown_0832C108[gBanksByIdentity[1]]);
+                LoadCompressedObjectPic(&gUnknown_0832C108[gBattlerPositions[1]]);
             else if (state == 8)
-                LoadCompressedObjectPic(&gUnknown_0832C108[gBanksByIdentity[2]]);
+                LoadCompressedObjectPic(&gUnknown_0832C108[gBattlerPositions[2]]);
             else if (state == 9)
-                LoadCompressedObjectPic(&gUnknown_0832C108[gBanksByIdentity[3]]);
+                LoadCompressedObjectPic(&gUnknown_0832C108[gBattlerPositions[3]]);
             else
                 retVal = TRUE;
         }
@@ -802,44 +802,44 @@ bool8 BattleInitAllSprites(u8 *state1, u8 *bank)
         break;
     case 3:
         if ((gBattleTypeFlags & BATTLE_TYPE_SAFARI) && *bank == 0)
-            gHealthBoxesIds[*bank] = CreateSafariPlayerHealthboxSprites();
+            gHealthboxSpriteIds[*bank] = CreateSafariPlayerHealthboxSprites();
         else
-            gHealthBoxesIds[*bank] = CreateBankHealthboxSprites(*bank);
+            gHealthboxSpriteIds[*bank] = CreateBattlerHealthboxSprites(*bank);
 
         (*bank)++;
-        if (*bank == gNoOfAllBanks)
+        if (*bank == gBattlersCount)
         {
             *bank = 0;
             (*state1)++;
         }
         break;
     case 4:
-        SetBankHealthboxSpritePos(*bank);
-        if (gBanksByIdentity[*bank] <= 1)
-            DummyBattleInterfaceFunc(gHealthBoxesIds[*bank], FALSE);
+        InitBattlerHealthboxCoords(*bank);
+        if (gBattlerPositions[*bank] <= 1)
+            DummyBattleInterfaceFunc(gHealthboxSpriteIds[*bank], FALSE);
         else
-            DummyBattleInterfaceFunc(gHealthBoxesIds[*bank], TRUE);
+            DummyBattleInterfaceFunc(gHealthboxSpriteIds[*bank], TRUE);
 
         (*bank)++;
-        if (*bank == gNoOfAllBanks)
+        if (*bank == gBattlersCount)
         {
             *bank = 0;
             (*state1)++;
         }
         break;
     case 5:
-        if (GetBankSide(*bank) == SIDE_PLAYER)
+        if (GetBattlerSide(*bank) == B_SIDE_PLAYER)
         {
             if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI))
-                UpdateHealthboxAttribute(gHealthBoxesIds[*bank], &gPlayerParty[gBattlePartyID[*bank]], HEALTHBOX_ALL);
+                UpdateHealthboxAttribute(gHealthboxSpriteIds[*bank], &gPlayerParty[gBattlerPartyIndexes[*bank]], HEALTHBOX_ALL);
         }
         else
         {
-            UpdateHealthboxAttribute(gHealthBoxesIds[*bank], &gEnemyParty[gBattlePartyID[*bank]], HEALTHBOX_ALL);
+            UpdateHealthboxAttribute(gHealthboxSpriteIds[*bank], &gEnemyParty[gBattlerPartyIndexes[*bank]], HEALTHBOX_ALL);
         }
-        SetHealthboxSpriteInvisible(gHealthBoxesIds[*bank]);
+        SetHealthboxSpriteInvisible(gHealthboxSpriteIds[*bank]);
         (*bank)++;
-        if (*bank == gNoOfAllBanks)
+        if (*bank == gBattlersCount)
         {
             *bank = 0;
             (*state1)++;
@@ -857,27 +857,27 @@ bool8 BattleInitAllSprites(u8 *state1, u8 *bank)
 
 void ClearSpritesHealthboxAnimData(void)
 {
-    memset(gBattleSpritesDataPtr->healthBoxesData, 0, sizeof(struct BattleHealthboxInfo) * BATTLE_BANKS_COUNT);
+    memset(gBattleSpritesDataPtr->healthBoxesData, 0, sizeof(struct BattleHealthboxInfo) * MAX_BATTLERS_COUNT);
     memset(gBattleSpritesDataPtr->animationData, 0, sizeof(struct BattleAnimationInfo));
 }
 
 static void ClearSpritesBankHealthboxAnimData(void)
 {
     ClearSpritesHealthboxAnimData();
-    memset(gBattleSpritesDataPtr->bankData, 0, sizeof(struct BattleSpriteInfo) * BATTLE_BANKS_COUNT);
+    memset(gBattleSpritesDataPtr->battlerData, 0, sizeof(struct BattleSpriteInfo) * MAX_BATTLERS_COUNT);
 }
 
 void CopyAllBattleSpritesInvisibilities(void)
 {
     s32 i;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
-        gBattleSpritesDataPtr->bankData[i].invisible = gSprites[gBankSpriteIds[i]].invisible;
+    for (i = 0; i < gBattlersCount; i++)
+        gBattleSpritesDataPtr->battlerData[i].invisible = gSprites[gBattlerSpriteIds[i]].invisible;
 }
 
 void CopyBattleSpriteInvisibility(u8 bank)
 {
-    gBattleSpritesDataPtr->bankData[bank].invisible = gSprites[gBankSpriteIds[bank]].invisible;
+    gBattleSpritesDataPtr->battlerData[bank].invisible = gSprites[gBattlerSpriteIds[bank]].invisible;
 }
 
 void HandleSpeciesGfxDataChange(u8 bankAtk, u8 bankDef, bool8 notTransform)
@@ -885,21 +885,21 @@ void HandleSpeciesGfxDataChange(u8 bankAtk, u8 bankDef, bool8 notTransform)
     u16 paletteOffset;
     u32 personalityValue;
     u32 otId;
-    u8 identity;
+    u8 position;
     const u8 *lzPaletteData;
 
     if (notTransform)
     {
-        StartSpriteAnim(&gSprites[gBankSpriteIds[bankAtk]], gBattleSpritesDataPtr->animationData->animArg);
+        StartSpriteAnim(&gSprites[gBattlerSpriteIds[bankAtk]], gBattleSpritesDataPtr->animationData->animArg);
         paletteOffset = 0x100 + bankAtk * 16;
         LoadPalette(gBattleStruct->castformPalette[gBattleSpritesDataPtr->animationData->animArg], paletteOffset, 32);
         gBattleMonForms[bankAtk] = gBattleSpritesDataPtr->animationData->animArg;
-        if (gBattleSpritesDataPtr->bankData[bankAtk].transformSpecies != SPECIES_NONE)
+        if (gBattleSpritesDataPtr->battlerData[bankAtk].transformSpecies != SPECIES_NONE)
         {
             BlendPalette(paletteOffset, 16, 6, 0x7FFF);
             CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32);
         }
-        gSprites[gBankSpriteIds[bankAtk]].pos1.y = GetBankSpriteDefault_Y(bankAtk);
+        gSprites[gBattlerSpriteIds[bankAtk]].pos1.y = GetBattlerSpriteDefault_Y(bankAtk);
     }
     else
     {
@@ -909,7 +909,7 @@ void HandleSpeciesGfxDataChange(u8 bankAtk, u8 bankDef, bool8 notTransform)
 
         if (IsContest())
         {
-            identity = 0;
+            position = 0;
             targetSpecies = gContestResources->field_18->field_2;
             personalityValue = gContestResources->field_18->field_8;
             otId = gContestResources->field_18->field_C;
@@ -921,37 +921,37 @@ void HandleSpeciesGfxDataChange(u8 bankAtk, u8 bankDef, bool8 notTransform)
         }
         else
         {
-            identity = GetBankIdentity(bankAtk);
+            position = GetBattlerPosition(bankAtk);
 
-            if (GetBankSide(bankDef) == SIDE_OPPONENT)
-                targetSpecies = GetMonData(&gEnemyParty[gBattlePartyID[bankDef]], MON_DATA_SPECIES);
+            if (GetBattlerSide(bankDef) == B_SIDE_OPPONENT)
+                targetSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[bankDef]], MON_DATA_SPECIES);
             else
-                targetSpecies = GetMonData(&gPlayerParty[gBattlePartyID[bankDef]], MON_DATA_SPECIES);
+                targetSpecies = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bankDef]], MON_DATA_SPECIES);
 
-            if (GetBankSide(bankAtk) == SIDE_PLAYER)
+            if (GetBattlerSide(bankAtk) == B_SIDE_PLAYER)
             {
-                personalityValue = GetMonData(&gPlayerParty[gBattlePartyID[bankAtk]], MON_DATA_PERSONALITY);
-                otId = GetMonData(&gPlayerParty[gBattlePartyID[bankAtk]], MON_DATA_OT_ID);
+                personalityValue = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bankAtk]], MON_DATA_PERSONALITY);
+                otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bankAtk]], MON_DATA_OT_ID);
 
                 HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[targetSpecies],
-                                                          gMonSpritesGfxPtr->sprites[identity],
+                                                          gMonSpritesGfxPtr->sprites[position],
                                                           targetSpecies,
                                                           gTransformedPersonalities[bankAtk]);
             }
             else
             {
-                personalityValue = GetMonData(&gEnemyParty[gBattlePartyID[bankAtk]], MON_DATA_PERSONALITY);
-                otId = GetMonData(&gEnemyParty[gBattlePartyID[bankAtk]], MON_DATA_OT_ID);
+                personalityValue = GetMonData(&gEnemyParty[gBattlerPartyIndexes[bankAtk]], MON_DATA_PERSONALITY);
+                otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[bankAtk]], MON_DATA_OT_ID);
 
                 HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[targetSpecies],
-                                                          gMonSpritesGfxPtr->sprites[identity],
+                                                          gMonSpritesGfxPtr->sprites[position],
                                                           targetSpecies,
                                                           gTransformedPersonalities[bankAtk]);
             }
         }
 
-        src = gMonSpritesGfxPtr->sprites[identity];
-        dst = (void *)(VRAM + 0x10000 + gSprites[gBankSpriteIds[bankAtk]].oam.tileNum * 32);
+        src = gMonSpritesGfxPtr->sprites[position];
+        dst = (void *)(VRAM + 0x10000 + gSprites[gBattlerSpriteIds[bankAtk]].oam.tileNum * 32);
         DmaCopy32(3, src, dst, 0x800);
         paletteOffset = 0x100 + bankAtk * 16;
         lzPaletteData = GetFrontSpritePalFromSpeciesAndPersonality(targetSpecies, otId, personalityValue);
@@ -960,7 +960,7 @@ void HandleSpeciesGfxDataChange(u8 bankAtk, u8 bankDef, bool8 notTransform)
 
         if (targetSpecies == SPECIES_CASTFORM)
         {
-            gSprites[gBankSpriteIds[bankAtk]].anims = gMonAnimationsSpriteAnimsPtrTable[targetSpecies];
+            gSprites[gBattlerSpriteIds[bankAtk]].anims = gMonAnimationsSpriteAnimsPtrTable[targetSpecies];
             LZDecompressWram(lzPaletteData, gBattleStruct->castformPalette[0]);
             LoadPalette(gBattleStruct->castformPalette[0] + gBattleMonForms[bankDef] * 16, paletteOffset, 32);
         }
@@ -970,18 +970,18 @@ void HandleSpeciesGfxDataChange(u8 bankAtk, u8 bankDef, bool8 notTransform)
 
         if (!IsContest())
         {
-            gBattleSpritesDataPtr->bankData[bankAtk].transformSpecies = targetSpecies;
+            gBattleSpritesDataPtr->battlerData[bankAtk].transformSpecies = targetSpecies;
             gBattleMonForms[bankAtk] = gBattleMonForms[bankDef];
         }
 
-        gSprites[gBankSpriteIds[bankAtk]].pos1.y = GetBankSpriteDefault_Y(bankAtk);
-        StartSpriteAnim(&gSprites[gBankSpriteIds[bankAtk]], gBattleMonForms[bankAtk]);
+        gSprites[gBattlerSpriteIds[bankAtk]].pos1.y = GetBattlerSpriteDefault_Y(bankAtk);
+        StartSpriteAnim(&gSprites[gBattlerSpriteIds[bankAtk]], gBattleMonForms[bankAtk]);
     }
 }
 
 void BattleLoadSubstituteOrMonSpriteGfx(u8 bank, bool8 loadMonSprite)
 {
-    u8 identity;
+    u8 position;
     s32 i;
     u32 var;
     const void *substitutePal;
@@ -989,23 +989,23 @@ void BattleLoadSubstituteOrMonSpriteGfx(u8 bank, bool8 loadMonSprite)
     if (!loadMonSprite)
     {
         if (IsContest())
-            identity = 0;
+            position = 0;
         else
-            identity = GetBankIdentity(bank);
+            position = GetBattlerPosition(bank);
 
         if (IsContest())
-            LZDecompressVram(gSubstituteDollTilemap, gMonSpritesGfxPtr->sprites[identity]);
-        else if (GetBankSide(bank) != SIDE_PLAYER)
-            LZDecompressVram(gSubstituteDollGfx, gMonSpritesGfxPtr->sprites[identity]);
+            LZDecompressVram(gSubstituteDollTilemap, gMonSpritesGfxPtr->sprites[position]);
+        else if (GetBattlerSide(bank) != B_SIDE_PLAYER)
+            LZDecompressVram(gSubstituteDollGfx, gMonSpritesGfxPtr->sprites[position]);
         else
-            LZDecompressVram(gSubstituteDollTilemap, gMonSpritesGfxPtr->sprites[identity]);
+            LZDecompressVram(gSubstituteDollTilemap, gMonSpritesGfxPtr->sprites[position]);
 
         i = 1;
         var = bank * 16;
         substitutePal = gSubstituteDollPal;
         for (; i < 4; i++)
         {
-            register void *dmaSrc asm("r0") = gMonSpritesGfxPtr->sprites[identity];
+            register void *dmaSrc asm("r0") = gMonSpritesGfxPtr->sprites[position];
             void *dmaDst = (i * 0x800) + dmaSrc;
             u32 dmaSize = 0x800;
             DmaCopy32(3, dmaSrc, dmaDst, dmaSize);
@@ -1018,10 +1018,10 @@ void BattleLoadSubstituteOrMonSpriteGfx(u8 bank, bool8 loadMonSprite)
     {
         if (!IsContest())
         {
-            if (GetBankSide(bank) != SIDE_PLAYER)
-                BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[bank]], bank);
+            if (GetBattlerSide(bank) != B_SIDE_PLAYER)
+                BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[bank]], bank);
             else
-                BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[bank]], bank);
+                BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[bank]], bank);
         }
     }
 }
@@ -1034,18 +1034,18 @@ void LoadBattleMonGfxAndAnimate(u8 bank, bool8 loadMonSprite, u8 spriteId)
     if (!loadMonSprite)
         gSprites[spriteId].pos1.y = GetSubstituteSpriteDefault_Y(bank);
     else
-        gSprites[spriteId].pos1.y = GetBankSpriteDefault_Y(bank);
+        gSprites[spriteId].pos1.y = GetBattlerSpriteDefault_Y(bank);
 }
 
 void TrySetBehindSubstituteSpriteBit(u8 bank, u16 move)
 {
     if (move == MOVE_SUBSTITUTE)
-        gBattleSpritesDataPtr->bankData[bank].behindSubstitute = 1;
+        gBattleSpritesDataPtr->battlerData[bank].behindSubstitute = 1;
 }
 
 void ClearBehindSubstituteBit(u8 bank)
 {
-    gBattleSpritesDataPtr->bankData[bank].behindSubstitute = 0;
+    gBattleSpritesDataPtr->battlerData[bank].behindSubstitute = 0;
 }
 
 void HandleLowHpMusicChange(struct Pokemon *mon, u8 bank)
@@ -1055,22 +1055,22 @@ void HandleLowHpMusicChange(struct Pokemon *mon, u8 bank)
 
     if (GetHPBarLevel(hp, maxHP) == HP_BAR_RED)
     {
-        if (!gBattleSpritesDataPtr->bankData[bank].lowHpSong)
+        if (!gBattleSpritesDataPtr->battlerData[bank].lowHpSong)
         {
-            if (!gBattleSpritesDataPtr->bankData[bank ^ BIT_MON].lowHpSong)
+            if (!gBattleSpritesDataPtr->battlerData[bank ^ BIT_FLANK].lowHpSong)
                 PlaySE(SE_HINSI);
-            gBattleSpritesDataPtr->bankData[bank].lowHpSong = 1;
+            gBattleSpritesDataPtr->battlerData[bank].lowHpSong = 1;
         }
     }
     else
     {
-        gBattleSpritesDataPtr->bankData[bank].lowHpSong = 0;
+        gBattleSpritesDataPtr->battlerData[bank].lowHpSong = 0;
         if (!IsDoubleBattle())
         {
             m4aSongNumStop(SE_HINSI);
             return;
         }
-        if (IsDoubleBattle() && !gBattleSpritesDataPtr->bankData[bank ^ BIT_MON].lowHpSong)
+        if (IsDoubleBattle() && !gBattleSpritesDataPtr->battlerData[bank ^ BIT_FLANK].lowHpSong)
         {
             m4aSongNumStop(SE_HINSI);
             return;
@@ -1080,11 +1080,11 @@ void HandleLowHpMusicChange(struct Pokemon *mon, u8 bank)
 
 void BattleStopLowHpSound(void)
 {
-    u8 playerBank = GetBankByIdentity(IDENTITY_PLAYER_MON1);
+    u8 playerBank = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
 
-    gBattleSpritesDataPtr->bankData[playerBank].lowHpSong = 0;
+    gBattleSpritesDataPtr->battlerData[playerBank].lowHpSong = 0;
     if (IsDoubleBattle())
-        gBattleSpritesDataPtr->bankData[playerBank ^ BIT_MON].lowHpSong = 0;
+        gBattleSpritesDataPtr->battlerData[playerBank ^ BIT_FLANK].lowHpSong = 0;
 
     m4aSongNumStop(SE_HINSI);
 }
@@ -1101,10 +1101,10 @@ void sub_805EAE8(void)
 {
     if (gMain.inBattle)
     {
-        u8 playerBank1 = GetBankByIdentity(IDENTITY_PLAYER_MON1);
-        u8 playerBank2 = GetBankByIdentity(IDENTITY_PLAYER_MON2);
-        u8 bank1PartyId = pokemon_order_func(gBattlePartyID[playerBank1]);
-        u8 bank2PartyId = pokemon_order_func(gBattlePartyID[playerBank2]);
+        u8 playerBank1 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
+        u8 playerBank2 = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
+        u8 bank1PartyId = pokemon_order_func(gBattlerPartyIndexes[playerBank1]);
+        u8 bank2PartyId = pokemon_order_func(gBattlerPartyIndexes[playerBank2]);
 
         if (GetMonData(&gPlayerParty[bank1PartyId], MON_DATA_HP) != 0)
             HandleLowHpMusicChange(&gPlayerParty[bank1PartyId], playerBank1);
@@ -1117,19 +1117,19 @@ void sub_805EB9C(u8 affineMode)
 {
     s32 i;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
-        if (IsBankSpritePresent(i))
+        if (IsBattlerSpritePresent(i))
         {
-            gSprites[gBankSpriteIds[i]].oam.affineMode = affineMode;
+            gSprites[gBattlerSpriteIds[i]].oam.affineMode = affineMode;
             if (affineMode == 0)
             {
-                gBattleSpritesDataPtr->healthBoxesData[i].field_6 = gSprites[gBankSpriteIds[i]].oam.matrixNum;
-                gSprites[gBankSpriteIds[i]].oam.matrixNum = 0;
+                gBattleSpritesDataPtr->healthBoxesData[i].field_6 = gSprites[gBattlerSpriteIds[i]].oam.matrixNum;
+                gSprites[gBattlerSpriteIds[i]].oam.matrixNum = 0;
             }
             else
             {
-                gSprites[gBankSpriteIds[i]].oam.matrixNum = gBattleSpritesDataPtr->healthBoxesData[i].field_6;
+                gSprites[gBattlerSpriteIds[i]].oam.matrixNum = gBattleSpritesDataPtr->healthBoxesData[i].field_6;
             }
         }
     }
@@ -1143,14 +1143,14 @@ void LoadAndCreateEnemyShadowSprites(void)
 
     LoadCompressedObjectPic(&gSpriteSheet_EnemyShadow);
 
-    bank = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
-    gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow, GetBankPosition(bank, 0), GetBankPosition(bank, 1) + 29, 0xC8);
+    bank = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
+    gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow, GetBattlerSpriteCoord(bank, 0), GetBattlerSpriteCoord(bank, 1) + 29, 0xC8);
     gSprites[gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId].data[0] = bank;
 
     if (IsDoubleBattle())
     {
-        bank = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
-        gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow, GetBankPosition(bank, 0), GetBankPosition(bank, 1) + 29, 0xC8);
+        bank = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
+        gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow, GetBattlerSpriteCoord(bank, 0), GetBattlerSpriteCoord(bank, 1) + 29, 0xC8);
         gSprites[gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId].data[0] = bank;
     }
 }
@@ -1159,20 +1159,20 @@ void SpriteCB_EnemyShadow(struct Sprite *shadowSprite)
 {
     bool8 invisible = FALSE;
     u8 bank = shadowSprite->tBank;
-    struct Sprite *bankSprite = &gSprites[gBankSpriteIds[bank]];
+    struct Sprite *bankSprite = &gSprites[gBattlerSpriteIds[bank]];
 
-    if (!bankSprite->inUse || !IsBankSpritePresent(bank))
+    if (!bankSprite->inUse || !IsBattlerSpritePresent(bank))
     {
         shadowSprite->callback = SpriteCB_SetInvisible;
         return;
     }
     if (gAnimScriptActive || bankSprite->invisible)
         invisible = TRUE;
-    else if (gBattleSpritesDataPtr->bankData[bank].transformSpecies != SPECIES_NONE
-             && gEnemyMonElevation[gBattleSpritesDataPtr->bankData[bank].transformSpecies] == 0)
+    else if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies != SPECIES_NONE
+             && gEnemyMonElevation[gBattleSpritesDataPtr->battlerData[bank].transformSpecies] == 0)
         invisible = TRUE;
 
-    if (gBattleSpritesDataPtr->bankData[bank].behindSubstitute)
+    if (gBattleSpritesDataPtr->battlerData[bank].behindSubstitute)
         invisible = TRUE;
 
     shadowSprite->pos1.x = bankSprite->pos1.x;
@@ -1187,13 +1187,14 @@ void SpriteCB_SetInvisible(struct Sprite *sprite)
     sprite->invisible = 1;
 }
 
-void SetBankEnemyShadowSpriteCallback(u8 bank, u16 species)
+void SetBattlerShadowSpriteCallback(u8 bank, u16 species)
 {
-    if (GetBankSide(bank) == SIDE_PLAYER)
+    // The player's shadow is never seen
+    if (GetBattlerSide(bank) == B_SIDE_PLAYER)
         return;
 
-    if (gBattleSpritesDataPtr->bankData[bank].transformSpecies != SPECIES_NONE)
-        species = gBattleSpritesDataPtr->bankData[bank].transformSpecies;
+    if (gBattleSpritesDataPtr->battlerData[bank].transformSpecies != SPECIES_NONE)
+        species = gBattleSpritesDataPtr->battlerData[bank].transformSpecies;
 
     if (gEnemyMonElevation[species] != 0)
         gSprites[gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId].callback = SpriteCB_EnemyShadow;
@@ -1201,7 +1202,7 @@ void SetBankEnemyShadowSpriteCallback(u8 bank, u16 species)
         gSprites[gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId].callback = SpriteCB_SetInvisible;
 }
 
-void EnemyShadowCallbackToSetInvisible(u8 bank)
+void HideBattlerShadowSprite(u8 bank)
 {
     gSprites[gBattleSpritesDataPtr->healthBoxesData[bank].shadowSpriteId].callback = SpriteCB_SetInvisible;
 }
@@ -1231,7 +1232,7 @@ void sub_805EF14(void)
 
 void ClearTemporarySpeciesSpriteData(u8 bank, bool8 dontClearSubstitute)
 {
-    gBattleSpritesDataPtr->bankData[bank].transformSpecies = SPECIES_NONE;
+    gBattleSpritesDataPtr->battlerData[bank].transformSpecies = SPECIES_NONE;
     gBattleMonForms[bank] = 0;
     if (!dontClearSubstitute)
         ClearBehindSubstituteBit(bank);
@@ -1245,7 +1246,7 @@ void AllocateMonSpritesGfx(void)
     gMonSpritesGfxPtr = AllocZeroed(sizeof(*gMonSpritesGfxPtr));
     gMonSpritesGfxPtr->firstDecompressed = AllocZeroed(0x8000);
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
         gMonSpritesGfxPtr->sprites[i] = gMonSpritesGfxPtr->firstDecompressed + (i * 0x2000);
         *(gMonSpritesGfxPtr->templates + i) = gUnknown_08329D98[i];
@@ -1286,7 +1287,7 @@ bool32 ShouldPlayNormalPokeCry(struct Pokemon *mon)
     s16 hp, maxHP;
     s32 barLevel;
 
-    if (GetMonData(mon, MON_DATA_STATUS) & (STATUS_ANY | STATUS_TOXIC_COUNTER))
+    if (GetMonData(mon, MON_DATA_STATUS) & (STATUS1_ANY | STATUS1_TOXIC_COUNTER))
         return FALSE;
 
     hp = GetMonData(mon, MON_DATA_HP);

src/battle_interface.c

@@ -20,6 +20,7 @@
 #include "international_string_util.h"
 #include "safari_zone.h"
 #include "battle_anim.h"
+#include "constants/rgb.h"
 
 struct TestingBar
 {
@@ -152,10 +153,10 @@ enum
     HEALTHBOX_GFX_117,
 };
 
-extern u8 gBanksByIdentity[BATTLE_BANKS_COUNT];
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern u8 gNoOfAllBanks;
-extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT];
+extern u8 gBattlerPositions[MAX_BATTLERS_COUNT];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern u8 gBattlersCount;
+extern u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT];
 
 extern const u8 * const gNatureNamePointers[];
 extern const u8 gSpeciesNames[][POKEMON_NAME_LENGTH + 1];
@@ -555,13 +556,13 @@ enum
     PAL_STATUS_BRN
 };
 
-static const u16 sStatusIconPalettes[] =
+static const u16 sStatusIconColors[] =
 {
-    0x6198, // PAL_STATUS_PSN
-    0xEF7, // PAL_STATUS_PAR
-    0x4694, // PAL_STATUS_SLP
-    0x72D1, // PAL_STATUS_FRZ
-    0x29DC // PAL_STATUS_BRN
+    RGB(24, 12, 24), // PAL_STATUS_PSN
+    RGB(23, 23, 3), // PAL_STATUS_PAR
+    RGB(20, 20, 17), // PAL_STATUS_SLP
+    RGB(17, 22, 28), // PAL_STATUS_FRZ
+    RGB(28, 14, 10) // PAL_STATUS_BRN
 };
 
 static const struct WindowTemplate sHealthboxWindowTemplate = {0, 0, 0, 8, 2, 0, 0}; // width = 8, height = 2
@@ -897,7 +898,7 @@ void sub_80724A8(s16 arg0, s16 arg1, u16 *arg2)
 // healthboxSpriteId_2 refers to the other part
 // there's also one other sprite that appears to be a black square? dont fully understand its role
 
-u8 CreateBankHealthboxSprites(u8 bank)
+u8 CreateBattlerHealthboxSprites(u8 battler)
 {
     s16 data6 = 0;
     u8 healthboxSpriteId_1, healthboxSpriteId_2;
@@ -906,7 +907,7 @@ u8 CreateBankHealthboxSprites(u8 bank)
 
     if (!IsDoubleBattle())
     {
-        if (GetBankSide(bank) == SIDE_PLAYER)
+        if (GetBattlerSide(battler) == B_SIDE_PLAYER)
         {
             healthboxSpriteId_1 = CreateSprite(&sHealthboxPlayerSpriteTemplates[0], 240, 160, 1);
             healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[0], 240, 160, 1);
@@ -931,10 +932,10 @@ u8 CreateBankHealthboxSprites(u8 bank)
     }
     else
     {
-        if (GetBankSide(bank) == SIDE_PLAYER)
+        if (GetBattlerSide(battler) == B_SIDE_PLAYER)
         {
-            healthboxSpriteId_1 = CreateSprite(&sHealthboxPlayerSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
-            healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
+            healthboxSpriteId_1 = CreateSprite(&sHealthboxPlayerSpriteTemplates[GetBattlerPosition(battler) / 2], 240, 160, 1);
+            healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[GetBattlerPosition(battler) / 2], 240, 160, 1);
 
             gSprites[healthboxSpriteId_1].oam.affineParam = healthboxSpriteId_2;
 
@@ -946,8 +947,8 @@ u8 CreateBankHealthboxSprites(u8 bank)
         }
         else
         {
-            healthboxSpriteId_1 = CreateSprite(&sHealthboxOpponentSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
-            healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxOpponentSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
+            healthboxSpriteId_1 = CreateSprite(&sHealthboxOpponentSpriteTemplates[GetBattlerPosition(battler) / 2], 240, 160, 1);
+            healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxOpponentSpriteTemplates[GetBattlerPosition(battler) / 2], 240, 160, 1);
 
             gSprites[healthboxSpriteId_1].oam.affineParam = healthboxSpriteId_2;
 
@@ -959,16 +960,16 @@ u8 CreateBankHealthboxSprites(u8 bank)
         }
     }
 
-    unkSpriteId = CreateSpriteAtEnd(&sUnknown_0832C1C0[gBanksByIdentity[bank]], 140, 60, 0);
+    unkSpriteId = CreateSpriteAtEnd(&sUnknown_0832C1C0[gBattlerPositions[battler]], 140, 60, 0);
     unkSpritePtr = &gSprites[unkSpriteId];
-    SetSubspriteTables(unkSpritePtr, &sUnknown_0832C28C[GetBankSide(bank)]);
+    SetSubspriteTables(unkSpritePtr, &sUnknown_0832C28C[GetBattlerSide(battler)]);
     unkSpritePtr->subspriteMode = 2;
     unkSpritePtr->oam.priority = 1;
 
     CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_1), (void*)(OBJ_VRAM0 + unkSpritePtr->oam.tileNum * 32), 64);
 
     gSprites[healthboxSpriteId_1].data[5] = unkSpriteId;
-    gSprites[healthboxSpriteId_1].data[6] = bank;
+    gSprites[healthboxSpriteId_1].data[6] = battler;
     gSprites[healthboxSpriteId_1].invisible = 1;
 
     gSprites[healthboxSpriteId_2].invisible = 1;
@@ -1086,11 +1087,11 @@ void UpdateOamPriorityInAllHealthboxes(u8 priority)
 {
     s32 i;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
-        u8 healthboxSpriteId_1 = gHealthBoxesIds[i];
-        u8 healthboxSpriteId_2 = gSprites[gHealthBoxesIds[i]].oam.affineParam;
-        u8 healthboxSpriteId_3 = gSprites[gHealthBoxesIds[i]].data[5];
+        u8 healthboxSpriteId_1 = gHealthboxSpriteIds[i];
+        u8 healthboxSpriteId_2 = gSprites[gHealthboxSpriteIds[i]].oam.affineParam;
+        u8 healthboxSpriteId_3 = gSprites[gHealthboxSpriteIds[i]].data[5];
 
         gSprites[healthboxSpriteId_1].oam.priority = priority;
         gSprites[healthboxSpriteId_2].oam.priority = priority;
@@ -1098,37 +1099,37 @@ void UpdateOamPriorityInAllHealthboxes(u8 priority)
     }
 }
 
-void SetBankHealthboxSpritePos(u8 bank)
+void InitBattlerHealthboxCoords(u8 battler)
 {
     s16 x = 0, y = 0;
 
     if (!IsDoubleBattle())
     {
-        if (GetBankSide(bank) != SIDE_PLAYER)
+        if (GetBattlerSide(battler) != B_SIDE_PLAYER)
             x = 44, y = 30;
         else
             x = 158, y = 88;
     }
     else
     {
-        switch (GetBankIdentity(bank))
+        switch (GetBattlerPosition(battler))
         {
-        case IDENTITY_PLAYER_MON1:
+        case B_POSITION_PLAYER_LEFT:
             x = 159, y = 76;
             break;
-        case IDENTITY_PLAYER_MON2:
+        case B_POSITION_PLAYER_RIGHT:
             x = 171, y = 101;
             break;
-        case IDENTITY_OPPONENT_MON1:
+        case B_POSITION_OPPONENT_LEFT:
             x = 44, y = 19;
             break;
-        case IDENTITY_OPPONENT_MON2:
+        case B_POSITION_OPPONENT_RIGHT:
             x = 32, y = 44;
             break;
         }
     }
 
-    UpdateSpritePos(gHealthBoxesIds[bank], x, y);
+    UpdateSpritePos(gHealthboxSpriteIds[battler], x, y);
 }
 
 static void UpdateLvlInHealthbox(u8 healthboxSpriteId, u8 lvl)
@@ -1155,7 +1156,7 @@ static void UpdateLvlInHealthbox(u8 healthboxSpriteId, u8 lvl)
     windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(text, xPos, 3, 2, &windowId);
     spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
 
-    if (GetBankSide(gSprites[healthboxSpriteId].data[6]) == SIDE_PLAYER)
+    if (GetBattlerSide(gSprites[healthboxSpriteId].data[6]) == B_SIDE_PLAYER)
     {
         objVram = (void*)(OBJ_VRAM0);
         if (!IsDoubleBattle())
@@ -1179,7 +1180,7 @@ void UpdateHpTextInHealthbox(u8 healthboxSpriteId, s16 value, u8 maxOrCurrent)
     u8 text[32];
     void *objVram;
 
-    if (GetBankSide(gSprites[healthboxSpriteId].data[6]) == SIDE_PLAYER && !IsDoubleBattle())
+    if (GetBattlerSide(gSprites[healthboxSpriteId].data[6]) == B_SIDE_PLAYER && !IsDoubleBattle())
     {
         spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
         if (maxOrCurrent != HP_CURRENT) // singles, max
@@ -1209,11 +1210,11 @@ void UpdateHpTextInHealthbox(u8 healthboxSpriteId, s16 value, u8 maxOrCurrent)
     }
     else
     {
-        u8 bank;
+        u8 battler;
 
         memcpy(text, sUnknown_0832C3C4, sizeof(sUnknown_0832C3C4));
-        bank = gSprites[healthboxSpriteId].data[6];
-        if (IsDoubleBattle() == TRUE || GetBankSide(bank) == SIDE_OPPONENT)
+        battler = gSprites[healthboxSpriteId].data[6];
+        if (IsDoubleBattle() == TRUE || GetBattlerSide(battler) == B_SIDE_OPPONENT)
         {
             UpdateHpTextInHealthboxInDoubles(healthboxSpriteId, value, maxOrCurrent);
         }
@@ -1222,7 +1223,7 @@ void UpdateHpTextInHealthbox(u8 healthboxSpriteId, s16 value, u8 maxOrCurrent)
             u32 var;
             u8 i;
 
-            if (GetBankSide(gSprites[healthboxSpriteId].data[6]) == SIDE_PLAYER)
+            if (GetBattlerSide(gSprites[healthboxSpriteId].data[6]) == B_SIDE_PLAYER)
             {
                 if (maxOrCurrent == HP_CURRENT)
                     var = 29;
@@ -1257,9 +1258,9 @@ static void UpdateHpTextInHealthboxInDoubles(u8 healthboxSpriteId, s16 value, u8
     u8 text[32];
     void *objVram;
 
-    if (GetBankSide(gSprites[healthboxSpriteId].data[6]) == SIDE_PLAYER)
+    if (GetBattlerSide(gSprites[healthboxSpriteId].data[6]) == B_SIDE_PLAYER)
     {
-        if (gBattleSpritesDataPtr->bankData[gSprites[healthboxSpriteId].data[6]].hpNumbersNoBars) // don't print text if only bars are visible
+        if (gBattleSpritesDataPtr->battlerData[gSprites[healthboxSpriteId].data[6]].hpNumbersNoBars) // don't print text if only bars are visible
         {
             spriteTileNum = gSprites[gSprites[healthboxSpriteId].data[5]].oam.tileNum * 32;
             objVram = (void*)(OBJ_VRAM0) + spriteTileNum;
@@ -1293,7 +1294,7 @@ static void UpdateHpTextInHealthboxInDoubles(u8 healthboxSpriteId, s16 value, u8
         memcpy(text, sUnknown_0832C3D8, sizeof(sUnknown_0832C3D8));
         bank = gSprites[healthboxSpriteId].data[6];
 
-        if (gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars) // don't print text if only bars are visible
+        if (gBattleSpritesDataPtr->battlerData[bank].hpNumbersNoBars) // don't print text if only bars are visible
         {
             u8 var = 4;
             u8 r7;
@@ -1334,7 +1335,7 @@ static void UpdateHpTextInHealthboxInDoubles(u8 healthboxSpriteId, s16 value, u8
             }
             else
             {
-                if (GetBankSide(bank) == SIDE_PLAYER) // impossible to reach part, because the bank is from the opponent's side
+                if (GetBattlerSide(bank) == B_SIDE_PLAYER) // impossible to reach part, because the bank is from the opponent's side
                 {
                     CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_116),
                           (void*)(OBJ_VRAM0) + ((gSprites[healthboxSpriteId].oam.tileNum + 52) * 32),
@@ -1353,7 +1354,7 @@ static void sub_80730D4(u8 healthboxSpriteId, struct Pokemon *mon)
     u8 i, var, nature, healthboxSpriteId_2;
 
     memcpy(text, sUnknown_0832C3C4, sizeof(sUnknown_0832C3C4));
-    barFontGfx = &gMonSpritesGfxPtr->barFontGfx[0x520 + (GetBankIdentity(gSprites[healthboxSpriteId].data[6]) * 384)];
+    barFontGfx = &gMonSpritesGfxPtr->barFontGfx[0x520 + (GetBattlerPosition(gSprites[healthboxSpriteId].data[6]) * 384)];
     var = 5;
     nature = GetNature(mon);
     StringCopy(text + 6, gNatureNamePointers[nature]);
@@ -1414,17 +1415,17 @@ void SwapHpBarsWithHpText(void)
     s32 i;
     u8 spriteId;
 
-    for (i = 0; i < gNoOfAllBanks; i++)
+    for (i = 0; i < gBattlersCount; i++)
     {
-        if (gSprites[gHealthBoxesIds[i]].callback == SpriteCallbackDummy
-         && GetBankSide(i) != SIDE_OPPONENT
-         && (IsDoubleBattle() || GetBankSide(i) != SIDE_PLAYER))
+        if (gSprites[gHealthboxSpriteIds[i]].callback == SpriteCallbackDummy
+         && GetBattlerSide(i) != B_SIDE_OPPONENT
+         && (IsDoubleBattle() || GetBattlerSide(i) != B_SIDE_PLAYER))
         {
             bool8 noBars;
 
-            gBattleSpritesDataPtr->bankData[i].hpNumbersNoBars ^= 1;
-            noBars = gBattleSpritesDataPtr->bankData[i].hpNumbersNoBars;
-            if (GetBankSide(i) == SIDE_PLAYER)
+            gBattleSpritesDataPtr->battlerData[i].hpNumbersNoBars ^= 1;
+            noBars = gBattleSpritesDataPtr->battlerData[i].hpNumbersNoBars;
+            if (GetBattlerSide(i) == B_SIDE_PLAYER)
             {
                 if (!IsDoubleBattle())
                     continue;
@@ -1433,17 +1434,17 @@ void SwapHpBarsWithHpText(void)
 
                 if (noBars == TRUE) // bars to text
                 {
-                    spriteId = gSprites[gHealthBoxesIds[i]].data[5];
+                    spriteId = gSprites[gHealthboxSpriteIds[i]].data[5];
 
                     CpuFill32(0, (void*)(OBJ_VRAM0 + gSprites[spriteId].oam.tileNum * 32), 0x100);
-                    UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gPlayerParty[gBattlePartyID[i]], MON_DATA_HP), HP_CURRENT);
-                    UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gPlayerParty[gBattlePartyID[i]], MON_DATA_MAX_HP), HP_MAX);
+                    UpdateHpTextInHealthboxInDoubles(gHealthboxSpriteIds[i], GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_HP), HP_CURRENT);
+                    UpdateHpTextInHealthboxInDoubles(gHealthboxSpriteIds[i], GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_MAX_HP), HP_MAX);
                 }
                 else // text to bars
                 {
-                    UpdateStatusIconInHealthbox(gHealthBoxesIds[i]);
-                    UpdateHealthboxAttribute(gHealthBoxesIds[i], &gPlayerParty[gBattlePartyID[i]], HEALTHBOX_HEALTH_BAR);
-                    CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_117), (void*)(OBJ_VRAM0 + 0x680 + gSprites[gHealthBoxesIds[i]].oam.tileNum * 32), 32);
+                    UpdateStatusIconInHealthbox(gHealthboxSpriteIds[i]);
+                    UpdateHealthboxAttribute(gHealthboxSpriteIds[i], &gPlayerParty[gBattlerPartyIndexes[i]], HEALTHBOX_HEALTH_BAR);
+                    CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_117), (void*)(OBJ_VRAM0 + 0x680 + gSprites[gHealthboxSpriteIds[i]].oam.tileNum * 32), 32);
                 }
             }
             else
@@ -1452,26 +1453,26 @@ void SwapHpBarsWithHpText(void)
                 {
                     if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
                     {
-                        sub_80730D4(gHealthBoxesIds[i], &gEnemyParty[gBattlePartyID[i]]);
+                        sub_80730D4(gHealthboxSpriteIds[i], &gEnemyParty[gBattlerPartyIndexes[i]]);
                     }
                     else
                     {
-                        spriteId = gSprites[gHealthBoxesIds[i]].data[5];
+                        spriteId = gSprites[gHealthboxSpriteIds[i]].data[5];
 
                         CpuFill32(0, (void *)(OBJ_VRAM0 + gSprites[spriteId].oam.tileNum * 32), 0x100);
-                        UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gEnemyParty[gBattlePartyID[i]], MON_DATA_HP), HP_CURRENT);
-                        UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gEnemyParty[gBattlePartyID[i]], MON_DATA_MAX_HP), HP_MAX);
+                        UpdateHpTextInHealthboxInDoubles(gHealthboxSpriteIds[i], GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_HP), HP_CURRENT);
+                        UpdateHpTextInHealthboxInDoubles(gHealthboxSpriteIds[i], GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_MAX_HP), HP_MAX);
                     }
                 }
                 else // text to bars
                 {
-                    UpdateStatusIconInHealthbox(gHealthBoxesIds[i]);
-                    UpdateHealthboxAttribute(gHealthBoxesIds[i], &gEnemyParty[gBattlePartyID[i]], HEALTHBOX_HEALTH_BAR);
+                    UpdateStatusIconInHealthbox(gHealthboxSpriteIds[i]);
+                    UpdateHealthboxAttribute(gHealthboxSpriteIds[i], &gEnemyParty[gBattlerPartyIndexes[i]], HEALTHBOX_HEALTH_BAR);
                     if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
-                        UpdateHealthboxAttribute(gHealthBoxesIds[i], &gEnemyParty[gBattlePartyID[i]], HEALTHBOX_NICK);
+                        UpdateHealthboxAttribute(gHealthboxSpriteIds[i], &gEnemyParty[gBattlerPartyIndexes[i]], HEALTHBOX_NICK);
                 }
             }
-            gSprites[gHealthBoxesIds[i]].data[7] ^= 1;
+            gSprites[gHealthboxSpriteIds[i]].data[7] ^= 1;
         }
     }
 }
@@ -1485,9 +1486,9 @@ u8 CreatePartyStatusSummarySprites(u8 bank, struct HpAndStatus *partyInfo, u8 ar
     u8 ballIconSpritesIds[6];
     u8 taskId;
 
-    if (!arg2 || GetBankIdentity(bank) != IDENTITY_OPPONENT_MON2)
+    if (!arg2 || GetBattlerPosition(bank) != B_POSITION_OPPONENT_RIGHT)
     {
-        if (GetBankSide(bank) == SIDE_PLAYER)
+        if (GetBattlerSide(bank) == B_SIDE_PLAYER)
         {
             isOpponent = FALSE;
             bar_X = 136, bar_Y = 96;
@@ -1566,7 +1567,7 @@ u8 CreatePartyStatusSummarySprites(u8 bank, struct HpAndStatus *partyInfo, u8 ar
         gSprites[ballIconSpritesIds[i]].data[2] = isOpponent;
     }
 
-    if (GetBankSide(bank) == SIDE_PLAYER)
+    if (GetBattlerSide(bank) == B_SIDE_PLAYER)
     {
         if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
         {
@@ -1711,7 +1712,7 @@ void sub_8073C30(u8 taskId)
     {
         for (i = 0; i < 6; i++)
         {
-            if (GetBankSide(bank) != SIDE_PLAYER)
+            if (GetBattlerSide(bank) != B_SIDE_PLAYER)
             {
                 gSprites[sp[5 - i]].data[1] = 7 * i;
                 gSprites[sp[5 - i]].data[3] = 0;
@@ -1963,7 +1964,7 @@ static void UpdateNickInHealthbox(u8 healthboxSpriteId, struct Pokemon *mon)
 
     spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
 
-    if (GetBankSide(gSprites[healthboxSpriteId].data[6]) == SIDE_PLAYER)
+    if (GetBattlerSide(gSprites[healthboxSpriteId].data[6]) == B_SIDE_PLAYER)
     {
         sub_8075198((void*)(0x6010040 + spriteTileNum), windowTileData, 6);
         ptr = (void*)(OBJ_VRAM0);
@@ -1991,9 +1992,9 @@ static void TryAddPokeballIconToHealthbox(u8 healthboxSpriteId, bool8 noStatus)
         return;
 
     bank = gSprites[healthboxSpriteId].data[6];
-    if (GetBankSide(bank) == SIDE_PLAYER)
+    if (GetBattlerSide(bank) == B_SIDE_PLAYER)
         return;
-    if (!GetSetPokedexFlag(SpeciesToNationalPokedexNum(GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES)), FLAG_GET_CAUGHT))
+    if (!GetSetPokedexFlag(SpeciesToNationalPokedexNum(GetMonData(&gEnemyParty[gBattlerPartyIndexes[bank]], MON_DATA_SPECIES)), FLAG_GET_CAUGHT))
         return;
 
     healthboxSpriteId_2 = gSprites[healthboxSpriteId].data[5];
@@ -2015,9 +2016,9 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
 
     bank = gSprites[healthboxSpriteId].data[6];
     healthboxSpriteId_2 = gSprites[healthboxSpriteId].data[5];
-    if (GetBankSide(bank) == SIDE_PLAYER)
+    if (GetBattlerSide(bank) == B_SIDE_PLAYER)
     {
-        status = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_STATUS);
+        status = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_STATUS);
         if (!IsDoubleBattle())
             tileNumAdder = 0x1A;
         else
@@ -2025,31 +2026,31 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
     }
     else
     {
-        status = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_STATUS);
+        status = GetMonData(&gEnemyParty[gBattlerPartyIndexes[bank]], MON_DATA_STATUS);
         tileNumAdder = 0x11;
     }
 
-    if (status & STATUS_SLEEP)
+    if (status & STATUS1_SLEEP)
     {
         statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_SLP_BANK0, bank));
         statusPalId = PAL_STATUS_SLP;
     }
-    else if (status & STATUS_PSN_ANY)
+    else if (status & STATUS1_PSN_ANY)
     {
         statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_PSN_BANK0, bank));
         statusPalId = PAL_STATUS_PSN;
     }
-    else if (status & STATUS_BURN)
+    else if (status & STATUS1_BURN)
     {
         statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_BRN_BANK0, bank));
         statusPalId = PAL_STATUS_BRN;
     }
-    else if (status & STATUS_FREEZE)
+    else if (status & STATUS1_FREEZE)
     {
         statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_FRZ_BANK0, bank));
         statusPalId = PAL_STATUS_FRZ;
     }
-    else if (status & STATUS_PARALYSIS)
+    else if (status & STATUS1_PARALYSIS)
     {
         statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_PRZ_BANK0, bank));
         statusPalId = PAL_STATUS_PAR;
@@ -2061,7 +2062,7 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
         for (i = 0; i < 3; i++)
             CpuCopy32(statusGfxPtr, (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId].oam.tileNum + tileNumAdder + i) * 32), 32);
 
-        if (!gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars)
+        if (!gBattleSpritesDataPtr->battlerData[bank].hpNumbersNoBars)
             CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_1), (void *)(OBJ_VRAM0 + gSprites[healthboxSpriteId_2].oam.tileNum * 32), 64);
 
         TryAddPokeballIconToHealthbox(healthboxSpriteId, TRUE);
@@ -2071,12 +2072,12 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
     pltAdder = gSprites[healthboxSpriteId].oam.paletteNum * 16;
     pltAdder += bank + 12;
 
-    FillPalette(sStatusIconPalettes[statusPalId], pltAdder + 0x100, 2);
+    FillPalette(sStatusIconColors[statusPalId], pltAdder + 0x100, 2);
     CpuCopy16(gPlttBufferUnfaded + 0x100 + pltAdder, (void*)(OBJ_PLTT + pltAdder * 2), 2);
     CpuCopy32(statusGfxPtr, (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId].oam.tileNum + tileNumAdder) * 32), 96);
-    if (IsDoubleBattle() == TRUE || GetBankSide(bank) == SIDE_OPPONENT)
+    if (IsDoubleBattle() == TRUE || GetBattlerSide(bank) == B_SIDE_OPPONENT)
     {
-        if (!gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars)
+        if (!gBattleSpritesDataPtr->battlerData[bank].hpNumbersNoBars)
         {
             CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_0), (void*)(OBJ_VRAM0 + gSprites[healthboxSpriteId_2].oam.tileNum * 32), 32);
             CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_65), (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId_2].oam.tileNum + 1) * 32), 32);
@@ -2180,9 +2181,9 @@ void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elem
     u8 bank = gSprites[healthboxSpriteId].data[6];
 
     if (elementId == HEALTHBOX_ALL && !IsDoubleBattle())
-        GetBankSide(bank); // pointless function call
+        GetBattlerSide(bank); // pointless function call
 
-    if (GetBankSide(gSprites[healthboxSpriteId].data[6]) == SIDE_PLAYER)
+    if (GetBattlerSide(gSprites[healthboxSpriteId].data[6]) == B_SIDE_PLAYER)
     {
         u8 isDoubles;
 
@@ -2274,7 +2275,7 @@ s32 sub_8074AA0(u8 bank, u8 healthboxSpriteId, u8 whichBar, u8 arg3)
                     8, expFraction);
     }
 
-    if (whichBar == EXP_BAR || (whichBar == HEALTH_BAR && !gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars))
+    if (whichBar == EXP_BAR || (whichBar == HEALTH_BAR && !gBattleSpritesDataPtr->battlerData[bank].hpNumbersNoBars))
         sub_8074B9C(bank, whichBar);
 
     if (var == -1)
@@ -2322,7 +2323,7 @@ static void sub_8074B9C(u8 bank, u8 whichBar)
                     gBattleSpritesDataPtr->battleBars[bank].receivedValue,
                     &gBattleSpritesDataPtr->battleBars[bank].field_10,
                     array, 8);
-        level = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_LEVEL);
+        level = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_LEVEL);
         if (level == MAX_MON_LEVEL)
         {
             for (i = 0; i < 8; i++)

src/battle_message.c

@@ -16,20 +16,20 @@
 
 extern u16 gLastUsedItem;
 extern u8 gLastUsedAbility;
-extern u8 gActiveBank;
-extern u8 gBankAttacker;
-extern u8 gBankTarget;
-extern u8 gStringBank;
+extern u8 gActiveBattler;
+extern u8 gBattlerAttacker;
+extern u8 gBattlerTarget;
+extern u8 gStringBattler;
 extern u8 gEffectBank;
-extern u8 gAbilitiesPerBank[BATTLE_BANKS_COUNT];
+extern u8 gBattlerAbilities[MAX_BATTLERS_COUNT];
 extern u32 gBattleTypeFlags;
 extern u16 gTrainerBattleOpponent_A;
 extern u16 gTrainerBattleOpponent_B;
 extern u16 gPartnerTrainerId;
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern struct BattleEnigmaBerry gEnigmaBerries[BATTLE_BANKS_COUNT];
-extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200];
-extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern struct BattleEnigmaBerry gEnigmaBerries[MAX_BATTLERS_COUNT];
+extern u8 gBattleBufferA[MAX_BATTLERS_COUNT][0x200];
+extern u8 gMoveSelectionCursor[MAX_BATTLERS_COUNT];
 extern u8 gUnknown_0203C7B4;
 extern struct StringInfoBattle *gStringInfo;
 
@@ -1430,18 +1430,18 @@ void BufferStringBattle(u16 stringID)
     s32 i;
     const u8* stringPtr = NULL;
 
-    gStringInfo = (struct StringInfoBattle*)(&gBattleBufferA[gActiveBank][4]);
+    gStringInfo = (struct StringInfoBattle*)(&gBattleBufferA[gActiveBattler][4]);
     gLastUsedItem = gStringInfo->lastItem;
     gLastUsedAbility = gStringInfo->lastAbility;
-    gBattleScripting.bank = gStringInfo->scrActive;
+    gBattleScripting.battler = gStringInfo->scrActive;
     *(&gBattleStruct->field_52) = gStringInfo->unk1605E;
     *(&gBattleStruct->hpScale) = gStringInfo->hpScale;
-    gStringBank = gStringInfo->StringBank;
+    gStringBattler = gStringInfo->StringBank;
     *(&gBattleStruct->stringMoveType) = gStringInfo->moveType;
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
-        gAbilitiesPerBank[i] = gStringInfo->abilities[i];
+        gBattlerAbilities[i] = gStringInfo->abilities[i];
     }
     for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; i++)
     {
@@ -1501,7 +1501,7 @@ void BufferStringBattle(u16 stringID)
         }
         break;
     case STRINGID_INTROSENDOUT: // poke first send-out
-        if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         {
             if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
             {
@@ -1546,7 +1546,7 @@ void BufferStringBattle(u16 stringID)
         }
         break;
     case STRINGID_RETURNMON: // sending poke to ball msg
-        if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
         {
             if (*(&gBattleStruct->hpScale) == 0)
                 stringPtr = gText_PkmnThatsEnough;
@@ -1573,7 +1573,7 @@ void BufferStringBattle(u16 stringID)
         }
         break;
     case STRINGID_SWITCHINMON: // switch-in msg
-        if (GetBankSide(gBattleScripting.bank) == SIDE_PLAYER)
+        if (GetBattlerSide(gBattleScripting.battler) == B_SIDE_PLAYER)
         {
             if (*(&gBattleStruct->hpScale) == 0 || gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
                 stringPtr = gText_GoPkmn2;
@@ -1590,7 +1590,7 @@ void BufferStringBattle(u16 stringID)
             {
                 if (gBattleTypeFlags & BATTLE_TYPE_x800000)
                 {
-                    if (gBattleScripting.bank == 1)
+                    if (gBattleScripting.battler == 1)
                         stringPtr = gText_Trainer1SentOutPkmn2;
                     else
                         stringPtr = gText_Trainer2SentOutPkmn;
@@ -1609,7 +1609,7 @@ void BufferStringBattle(u16 stringID)
             {
                 if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)
                 {
-                    if (gBattleScripting.bank == 1)
+                    if (gBattleScripting.battler == 1)
                         stringPtr = gText_Trainer1SentOutPkmn2;
                     else
                         stringPtr = gText_Trainer2SentOutPkmn;
@@ -1633,13 +1633,13 @@ void BufferStringBattle(u16 stringID)
         stringPtr = gText_AttackerUsedX;
         break;
     case STRINGID_BATTLEEND: // battle end
-        if (gBattleTextBuff1[0] & OUTCOME_LINK_BATTLE_RUN)
+        if (gBattleTextBuff1[0] & B_OUTCOME_LINK_BATTLE_RAN)
         {
-            gBattleTextBuff1[0] &= ~(OUTCOME_LINK_BATTLE_RUN);
-            if (GetBankSide(gActiveBank) == SIDE_OPPONENT && gBattleTextBuff1[0] != BATTLE_DREW)
-                gBattleTextBuff1[0] ^= (BATTLE_LOST | BATTLE_WON);
+            gBattleTextBuff1[0] &= ~(B_OUTCOME_LINK_BATTLE_RAN);
+            if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT && gBattleTextBuff1[0] != B_OUTCOME_DREW)
+                gBattleTextBuff1[0] ^= (B_OUTCOME_LOST | B_OUTCOME_WON);
 
-            if (gBattleTextBuff1[0] == BATTLE_LOST || gBattleTextBuff1[0] == BATTLE_DREW)
+            if (gBattleTextBuff1[0] == B_OUTCOME_LOST || gBattleTextBuff1[0] == B_OUTCOME_DREW)
                 stringPtr = gText_GotAwaySafely;
             else if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
                 stringPtr = gText_TwoWildFled;
@@ -1648,23 +1648,23 @@ void BufferStringBattle(u16 stringID)
         }
         else
         {
-            if (GetBankSide(gActiveBank) == SIDE_OPPONENT && gBattleTextBuff1[0] != BATTLE_DREW)
-                gBattleTextBuff1[0] ^= (BATTLE_LOST | BATTLE_WON);
+            if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT && gBattleTextBuff1[0] != B_OUTCOME_DREW)
+                gBattleTextBuff1[0] ^= (B_OUTCOME_LOST | B_OUTCOME_WON);
 
             if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
             {
                 switch (gBattleTextBuff1[0])
                 {
-                case BATTLE_WON:
+                case B_OUTCOME_WON:
                     if (gBattleTypeFlags & BATTLE_TYPE_x800000)
                         stringPtr = gText_TwoInGameTrainersDefeated;
                     else
                         stringPtr = gText_TwoLinkTrainersDefeated;
                     break;
-                case BATTLE_LOST:
+                case B_OUTCOME_LOST:
                     stringPtr = gText_PlayerLostToTwo;
                     break;
-                case BATTLE_DREW:
+                case B_OUTCOME_DREW:
                     stringPtr = gText_PlayerBattledToDrawVsTwo;
                     break;
                 }
@@ -1673,13 +1673,13 @@ void BufferStringBattle(u16 stringID)
             {
                 switch (gBattleTextBuff1[0])
                 {
-                case BATTLE_WON:
+                case B_OUTCOME_WON:
                     stringPtr = gText_PlayerDefeatedLinkTrainerTrainer1;
                     break;
-                case BATTLE_LOST:
+                case B_OUTCOME_LOST:
                     stringPtr = gText_PlayerLostAgainstTrainer1;
                     break;
-                case BATTLE_DREW:
+                case B_OUTCOME_DREW:
                     stringPtr = gText_PlayerBattledToDrawTrainer1;
                     break;
                 }
@@ -1688,13 +1688,13 @@ void BufferStringBattle(u16 stringID)
             {
                 switch (gBattleTextBuff1[0])
                 {
-                case BATTLE_WON:
+                case B_OUTCOME_WON:
                     stringPtr = gText_PlayerDefeatedLinkTrainer;
                     break;
-                case BATTLE_LOST:
+                case B_OUTCOME_LOST:
                     stringPtr = gText_PlayerLostAgainstLinkTrainer;
                     break;
-                case BATTLE_DREW:
+                case B_OUTCOME_DREW:
                     stringPtr = gText_PlayerBattledToDrawLinkTrainer;
                     break;
                 }
@@ -1754,7 +1754,7 @@ static const u8* TryGetStatusString(u8* src)
 }
 
 #define HANDLE_NICKNAME_STRING_CASE(bank, monIndex)                     \
-    if (GetBankSide(bank) != SIDE_PLAYER)                               \
+    if (GetBattlerSide(bank) != B_SIDE_PLAYER)                               \
     {                                                                   \
         if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)                     \
             toCpy = gText_FoePkmnPrefix;                                \
@@ -1836,80 +1836,80 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst)
                 toCpy = gStringVar3;
                 break;
             case B_TXT_PLAYER_MON1_NAME: // first player poke name
-                GetMonData(&gPlayerParty[gBattlePartyID[GetBankByIdentity(IDENTITY_PLAYER_MON1)]],
+                GetMonData(&gPlayerParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_OPPONENT_MON1_NAME: // first enemy poke name
-                GetMonData(&gEnemyParty[gBattlePartyID[GetBankByIdentity(IDENTITY_OPPONENT_MON1)]],
+                GetMonData(&gEnemyParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_PLAYER_MON2_NAME: // second player poke name
-                GetMonData(&gPlayerParty[gBattlePartyID[GetBankByIdentity(IDENTITY_PLAYER_MON2)]],
+                GetMonData(&gPlayerParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT)]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_OPPONENT_MON2_NAME: // second enemy poke name
-                GetMonData(&gEnemyParty[gBattlePartyID[GetBankByIdentity(IDENTITY_OPPONENT_MON2)]],
+                GetMonData(&gEnemyParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT)]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_LINK_PLAYER_MON1_NAME: // link first player poke name
-                GetMonData(&gPlayerParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18]],
+                GetMonData(&gPlayerParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerID].lp_field_18]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_LINK_OPPONENT_MON1_NAME: // link first opponent poke name
-                GetMonData(&gEnemyParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18 ^ 1]],
+                GetMonData(&gEnemyParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerID].lp_field_18 ^ 1]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_LINK_PLAYER_MON2_NAME: // link second player poke name
-                GetMonData(&gPlayerParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18 ^ 2]],
+                GetMonData(&gPlayerParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerID].lp_field_18 ^ 2]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_LINK_OPPONENT_MON2_NAME: // link second opponent poke name
-                GetMonData(&gEnemyParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18 ^ 3]],
+                GetMonData(&gEnemyParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerID].lp_field_18 ^ 3]],
                            MON_DATA_NICKNAME, text);
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_ATK_NAME_WITH_PREFIX_MON1: // attacker name with prefix, only bank 0/1
-                HANDLE_NICKNAME_STRING_CASE(gBankAttacker,
-                                            gBattlePartyID[GetBankByIdentity(GET_BANK_SIDE(gBankAttacker))])
+                HANDLE_NICKNAME_STRING_CASE(gBattlerAttacker,
+                                            gBattlerPartyIndexes[GetBattlerAtPosition(GET_BATTLER_SIDE(gBattlerAttacker))])
                 break;
             case B_TXT_ATK_PARTNER_NAME: // attacker partner name
-                if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
-                    GetMonData(&gPlayerParty[gBattlePartyID[GetBankByIdentity(GET_BANK_SIDE(gBankAttacker)) + 2]], MON_DATA_NICKNAME, text);
+                if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
+                    GetMonData(&gPlayerParty[gBattlerPartyIndexes[GetBattlerAtPosition(GET_BATTLER_SIDE(gBattlerAttacker)) + 2]], MON_DATA_NICKNAME, text);
                 else
-                    GetMonData(&gEnemyParty[gBattlePartyID[GetBankByIdentity(GET_BANK_SIDE(gBankAttacker)) + 2]], MON_DATA_NICKNAME, text);
+                    GetMonData(&gEnemyParty[gBattlerPartyIndexes[GetBattlerAtPosition(GET_BATTLER_SIDE(gBattlerAttacker)) + 2]], MON_DATA_NICKNAME, text);
 
                 StringGetEnd10(text);
                 toCpy = text;
                 break;
             case B_TXT_ATK_NAME_WITH_PREFIX: // attacker name with prefix
-                HANDLE_NICKNAME_STRING_CASE(gBankAttacker, gBattlePartyID[gBankAttacker])
+                HANDLE_NICKNAME_STRING_CASE(gBattlerAttacker, gBattlerPartyIndexes[gBattlerAttacker])
                 break;
             case B_TXT_DEF_NAME_WITH_PREFIX: // target name with prefix
-                HANDLE_NICKNAME_STRING_CASE(gBankTarget, gBattlePartyID[gBankTarget])
+                HANDLE_NICKNAME_STRING_CASE(gBattlerTarget, gBattlerPartyIndexes[gBattlerTarget])
                 break;
             case B_TXT_EFF_NAME_WITH_PREFIX: // effect bank name with prefix
-                HANDLE_NICKNAME_STRING_CASE(gEffectBank, gBattlePartyID[gEffectBank])
+                HANDLE_NICKNAME_STRING_CASE(gEffectBank, gBattlerPartyIndexes[gEffectBank])
                 break;
             case B_TXT_ACTIVE_NAME_WITH_PREFIX: // active bank name with prefix
-                HANDLE_NICKNAME_STRING_CASE(gActiveBank, gBattlePartyID[gActiveBank])
+                HANDLE_NICKNAME_STRING_CASE(gActiveBattler, gBattlerPartyIndexes[gActiveBattler])
                 break;
             case B_TXT_SCR_ACTIVE_NAME_WITH_PREFIX: // scripting active bank name with prefix
-                HANDLE_NICKNAME_STRING_CASE(gBattleScripting.bank, gBattlePartyID[gBattleScripting.bank])
+                HANDLE_NICKNAME_STRING_CASE(gBattleScripting.battler, gBattlerPartyIndexes[gBattleScripting.battler])
                 break;
             case B_TXT_CURRENT_MOVE: // current move name
                 if (gStringInfo->currentMove > LAST_MOVE_INDEX)
@@ -1930,10 +1930,10 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst)
                     {
                         if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
                         {
-                            if ((gBattleScripting.multiplayerId != 0 && (gStringBank & BIT_SIDE))
-                                || (gBattleScripting.multiplayerId == 0 && !(gStringBank & BIT_SIDE)))
+                            if ((gBattleScripting.multiplayerId != 0 && (gStringBattler & BIT_SIDE))
+                                || (gBattleScripting.multiplayerId == 0 && !(gStringBattler & BIT_SIDE)))
                             {
-                                StringCopy(text, gEnigmaBerries[gStringBank].name);
+                                StringCopy(text, gEnigmaBerries[gStringBattler].name);
                                 StringAppend(text, gText_BerrySuffix);
                                 toCpy = text;
                             }
@@ -1944,9 +1944,9 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst)
                         }
                         else
                         {
-                            if (gLinkPlayers[gBattleScripting.multiplayerId].lp_field_18 == gStringBank)
+                            if (gLinkPlayers[gBattleScripting.multiplayerId].lp_field_18 == gStringBattler)
                             {
-                                StringCopy(text, gEnigmaBerries[gStringBank].name);
+                                StringCopy(text, gEnigmaBerries[gStringBattler].name);
                                 StringAppend(text, gText_BerrySuffix);
                                 toCpy = text;
                             }
@@ -1970,16 +1970,16 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst)
                 toCpy = gAbilityNames[gLastUsedAbility];
                 break;
             case B_TXT_ATK_ABILITY: // attacker ability
-                toCpy = gAbilityNames[gAbilitiesPerBank[gBankAttacker]];
+                toCpy = gAbilityNames[gBattlerAbilities[gBattlerAttacker]];
                 break;
             case B_TXT_DEF_ABILITY: // target ability
-                toCpy = gAbilityNames[gAbilitiesPerBank[gBankTarget]];
+                toCpy = gAbilityNames[gBattlerAbilities[gBattlerTarget]];
                 break;
             case B_TXT_SCR_ACTIVE_ABILITY: // scripting active ability
-                toCpy = gAbilityNames[gAbilitiesPerBank[gBattleScripting.bank]];
+                toCpy = gAbilityNames[gBattlerAbilities[gBattleScripting.battler]];
                 break;
             case B_TXT_EFF_ABILITY: // effect bank ability
-                toCpy = gAbilityNames[gAbilitiesPerBank[gEffectBank]];
+                toCpy = gAbilityNames[gBattlerAbilities[gEffectBank]];
                 break;
             case B_TXT_TRAINER1_CLASS: // trainer class name
                 if (gBattleTypeFlags & BATTLE_TYPE_SECRET_BASE)
@@ -2039,16 +2039,16 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst)
                 toCpy = gLinkPlayers[multiplayerID].name;
                 break;
             case B_TXT_1F: // link partner name?
-                toCpy = gLinkPlayers[GetBankMultiplayerId(2 ^ gLinkPlayers[multiplayerID].lp_field_18)].name;
+                toCpy = gLinkPlayers[GetBattlerMultiplayerId(2 ^ gLinkPlayers[multiplayerID].lp_field_18)].name;
                 break;
             case B_TXT_20: // link opponent 1 name?
-                toCpy = gLinkPlayers[GetBankMultiplayerId(1 ^ gLinkPlayers[multiplayerID].lp_field_18)].name;
+                toCpy = gLinkPlayers[GetBattlerMultiplayerId(1 ^ gLinkPlayers[multiplayerID].lp_field_18)].name;
                 break;
             case B_TXT_21: // link opponent 2 name?
-                toCpy = gLinkPlayers[GetBankMultiplayerId(3 ^ gLinkPlayers[multiplayerID].lp_field_18)].name;
+                toCpy = gLinkPlayers[GetBattlerMultiplayerId(3 ^ gLinkPlayers[multiplayerID].lp_field_18)].name;
                 break;
             case B_TXT_22: // link scripting active name
-                toCpy = gLinkPlayers[GetBankMultiplayerId(gBattleScripting.bank)].name;
+                toCpy = gLinkPlayers[GetBattlerMultiplayerId(gBattleScripting.battler)].name;
                 break;
             case B_TXT_PLAYER_NAME: // player name
                 if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
@@ -2085,7 +2085,7 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst)
                 }
                 break;
             case B_TXT_26: // ?
-                HANDLE_NICKNAME_STRING_CASE(gBattleScripting.bank, *(&gBattleStruct->field_52))
+                HANDLE_NICKNAME_STRING_CASE(gBattleScripting.battler, *(&gBattleStruct->field_52))
                 break;
             case B_TXT_PC_CREATOR_NAME: // lanette pc
                 if (FlagGet(FLAG_SYS_PC_LANETTE))
@@ -2094,37 +2094,37 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst)
                     toCpy = gText_Someones;
                 break;
             case B_TXT_ATK_PREFIX2:
-                if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
+                if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
                     toCpy = gText_AllyPkmnPrefix2;
                 else
                     toCpy = gText_FoePkmnPrefix3;
                 break;
             case B_TXT_DEF_PREFIX2:
-                if (GetBankSide(gBankTarget) == SIDE_PLAYER)
+                if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER)
                     toCpy = gText_AllyPkmnPrefix2;
                 else
                     toCpy = gText_FoePkmnPrefix3;
                 break;
             case B_TXT_ATK_PREFIX1:
-                if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
+                if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
                     toCpy = gText_AllyPkmnPrefix;
                 else
                     toCpy = gText_FoePkmnPrefix2;
                 break;
             case B_TXT_DEF_PREFIX1:
-                if (GetBankSide(gBankTarget) == SIDE_PLAYER)
+                if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER)
                     toCpy = gText_AllyPkmnPrefix;
                 else
                     toCpy = gText_FoePkmnPrefix2;
                 break;
             case B_TXT_ATK_PREFIX3:
-                if (GetBankSide(gBankAttacker) == SIDE_PLAYER)
+                if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER)
                     toCpy = gText_AllyPkmnPrefix3;
                 else
                     toCpy = gText_FoePkmnPrefix4;
                 break;
             case B_TXT_DEF_PREFIX3:
-                if (GetBankSide(gBankTarget) == SIDE_PLAYER)
+                if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER)
                     toCpy = gText_AllyPkmnPrefix3;
                 else
                     toCpy = gText_FoePkmnPrefix4;
@@ -2266,7 +2266,7 @@ static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst)
             srcID += 2;
             break;
         case B_BUFF_MON_NICK_WITH_PREFIX: // poke nick with prefix
-            if (GetBankSide(src[srcID + 1]) == SIDE_PLAYER)
+            if (GetBattlerSide(src[srcID + 1]) == B_SIDE_PLAYER)
             {
                 GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, text);
             }
@@ -2292,7 +2292,7 @@ static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst)
             srcID += 3;
             break;
         case B_BUFF_MON_NICK: // poke nick without prefix
-            if (GetBankSide(src[srcID + 1]) == SIDE_PLAYER)
+            if (GetBattlerSide(src[srcID + 1]) == B_SIDE_PLAYER)
                 GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, dst);
             else
                 GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, dst);
@@ -2313,9 +2313,9 @@ static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst)
             {
                 if (hword == ITEM_ENIGMA_BERRY)
                 {
-                    if (gLinkPlayers[gBattleScripting.multiplayerId].lp_field_18 == gStringBank)
+                    if (gLinkPlayers[gBattleScripting.multiplayerId].lp_field_18 == gStringBattler)
                     {
-                        StringCopy(dst, gEnigmaBerries[gStringBank].name);
+                        StringCopy(dst, gEnigmaBerries[gStringBattler].name);
                         StringAppend(dst, gText_BerrySuffix);
                     }
                     else
@@ -2490,10 +2490,10 @@ void BattleHandleAddTextPrinter(const u8 *text, u8 arg1)
 
 void SetPpNumbersPaletteInMoveSelection(void)
 {
-    struct ChooseMoveStruct *chooseMoveStruct = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]);
+    struct ChooseMoveStruct *chooseMoveStruct = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBattler][4]);
     const u16 *palPtr = gUnknown_08D85620;
-    u8 var = GetCurrentPpToMaxPpState(chooseMoveStruct->currentPp[gMoveSelectionCursor[gActiveBank]],
-                         chooseMoveStruct->maxPp[gMoveSelectionCursor[gActiveBank]]);
+    u8 var = GetCurrentPpToMaxPpState(chooseMoveStruct->currentPp[gMoveSelectionCursor[gActiveBattler]],
+                         chooseMoveStruct->maxPp[gMoveSelectionCursor[gActiveBattler]]);
 
     gPlttBufferUnfaded[92] = palPtr[(var * 2) + 0];
     gPlttBufferUnfaded[91] = palPtr[(var * 2) + 1];

src/battle_setup.c

@@ -990,14 +990,14 @@ static bool32 IsPlayerDefeated(u32 battleOutcome)
 {
     switch (battleOutcome)
     {
-    case BATTLE_LOST:
-    case BATTLE_DREW:
+    case B_OUTCOME_LOST:
+    case B_OUTCOME_DREW:
         return TRUE;
-    case BATTLE_WON:
-    case BATTLE_RAN:
-    case BATTLE_PLAYER_TELEPORTED:
-    case BATTLE_POKE_FLED:
-    case BATTLE_CAUGHT:
+    case B_OUTCOME_WON:
+    case B_OUTCOME_RAN:
+    case B_OUTCOME_PLAYER_TELEPORTED:
+    case B_OUTCOME_POKE_FLED:
+    case B_OUTCOME_CAUGHT_POKE:
         return FALSE;
     default:
         return FALSE;

src/battle_transition.c

@@ -14,7 +14,7 @@
 #include "constants/songs.h"
 #include "constants/trainers.h"
 #include "field_camera.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "malloc.h"
 #include "gpu_regs.h"
 #include "decompress.h"
@@ -56,8 +56,6 @@ struct StructRectangularSpiral
 typedef bool8 (*TransitionStateFunc)(struct Task *task);
 typedef bool8 (*TransitionSpriteCallback)(struct Sprite *sprite);
 
-extern u16 gUnknown_020393A8[];
-extern u16 gUnknown_02038C28[][0x3C0];
 extern u16 gBattle_BG0_X;
 extern u16 gBattle_BG0_Y;
 
@@ -65,7 +63,7 @@ extern const struct OamData gFieldObjectBaseOam_32x32;
 
 extern void c2_exit_to_overworld_2_switch(void);
 extern void sub_80AC3D0(void);
-extern void dp12_8087EA4(void);
+extern void ScanlineEffect_Clear(void);
 
 // this file's functions
 static void LaunchBattleTransitionTask(u8 transitionId);
@@ -1110,9 +1108,9 @@ static void Phase2Task_Swirl(u8 taskId)
 static bool8 Phase2_Swirl_Func1(struct Task *task)
 {
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
     BeginNormalPaletteFade(-1, 4, 0, 0x10, 0);
-    sub_8149F98(gUnknown_020393A8, sTransitionStructPtr->field_14, 0, 2, 0, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[1], sTransitionStructPtr->field_14, 0, 2, 0, 160);
 
     SetVBlankCallback(VBlankCB_Phase2_Swirl);
     SetHBlankCallback(HBlankCB_Phase2_Swirl);
@@ -1129,7 +1127,7 @@ static bool8 Phase2_Swirl_Func2(struct Task *task)
     task->tData1 += 4;
     task->tData2 += 8;
 
-    sub_8149F98(gUnknown_02038C28[0], sTransitionStructPtr->field_14, task->tData1, 2, task->tData2, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], sTransitionStructPtr->field_14, task->tData1, 2, task->tData2, 160);
 
     if (!gPaletteFade.active)
     {
@@ -1145,12 +1143,12 @@ static void VBlankCB_Phase2_Swirl(void)
 {
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
 }
 
 static void HBlankCB_Phase2_Swirl(void)
 {
-    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    u16 var = gScanlineEffectRegBuffers[1][REG_VCOUNT];
     REG_BG1HOFS = var;
     REG_BG2HOFS = var;
     REG_BG3HOFS = var;
@@ -1164,10 +1162,10 @@ static void Phase2Task_Shuffle(u8 taskId)
 static bool8 Phase2_Shuffle_Func1(struct Task *task)
 {
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     BeginNormalPaletteFade(-1, 4, 0, 0x10, 0);
-    memset(gUnknown_020393A8, sTransitionStructPtr->field_16, 0x140);
+    memset(gScanlineEffectRegBuffers[1], sTransitionStructPtr->field_16, 0x140);
 
     SetVBlankCallback(VBlankCB_Phase2_Shuffle);
     SetHBlankCallback(HBlankCB_Phase2_Shuffle);
@@ -1192,7 +1190,7 @@ static bool8 Phase2_Shuffle_Func2(struct Task *task)
     for (i = 0; i < 160; i++, r4 += 4224)
     {
         u16 var = r4 / 256;
-        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3);
+        gScanlineEffectRegBuffers[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3);
     }
 
     if (!gPaletteFade.active)
@@ -1206,12 +1204,12 @@ static void VBlankCB_Phase2_Shuffle(void)
 {
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
 }
 
 static void HBlankCB_Phase2_Shuffle(void)
 {
-    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    u16 var = gScanlineEffectRegBuffers[1][REG_VCOUNT];
     REG_BG1VOFS = var;
     REG_BG2VOFS = var;
     REG_BG3VOFS = var;
@@ -1257,7 +1255,7 @@ static void sub_814669C(struct Task *task)
     s32 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     task->tData1 = 16;
     task->tData2 = 0;
@@ -1272,7 +1270,7 @@ static void sub_814669C(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[1][i] = 240;
+        gScanlineEffectRegBuffers[1][i] = 240;
     }
 
     SetVBlankCallback(VBlankCB0_Phase2_BigPokeball);
@@ -1351,7 +1349,7 @@ static bool8 Phase2_BigPokeball_Func2(struct Task *task)
             dst1[i * 32 + j] = *BigPokeballMap | 0xF000;
         }
     }
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5, 160);
 
     task->tState++;
     return TRUE;
@@ -1363,7 +1361,7 @@ static bool8 Phase2_Aqua_Func2(struct Task *task)
 
     sub_8149F58(&dst1, &dst2);
     LZ77UnCompVram(sTeamAqua_Tilemap, dst1);
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5, 160);
 
     task->tState++;
     return FALSE;
@@ -1375,7 +1373,7 @@ static bool8 Phase2_Magma_Func2(struct Task *task)
 
     sub_8149F58(&dst1, &dst2);
     LZ77UnCompVram(sTeamMagma_Tilemap, dst1);
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5, 160);
 
     task->tState++;
     return FALSE;
@@ -1388,7 +1386,7 @@ static bool8 Phase2_Regice_Func2(struct Task *task)
     sub_8149F58(&dst1, &dst2);
     LoadPalette(gUnknown_085BC2B4, 0xF0, 0x20);
     CpuCopy16(gUnknown_085BC314, dst1, 0x500);
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5, 160);
 
     task->tState++;
     return FALSE;
@@ -1401,7 +1399,7 @@ static bool8 Phase2_Registeel_Func2(struct Task *task)
     sub_8149F58(&dst1, &dst2);
     LoadPalette(gUnknown_085BC2D4, 0xF0, 0x20);
     CpuCopy16(gUnknown_085BCB14, dst1, 0x500);
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5, 160);
 
     task->tState++;
     return FALSE;
@@ -1414,7 +1412,7 @@ static bool8 Phase2_Regirock_Func2(struct Task *task)
     sub_8149F58(&dst1, &dst2);
     LoadPalette(gUnknown_085BC2F4, 0xF0, 0x20);
     CpuCopy16(gUnknown_085BD314, dst1, 0x500);
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5, 160);
 
     task->tState++;
     return FALSE;
@@ -1499,7 +1497,7 @@ static bool8 Phase2_BigPokeball_Func3(struct Task *task)
     task->tData4 += 8;
     task->tData5 -= 256;
 
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
 
     sTransitionStructPtr->VBlank_DMA++;
     return FALSE;
@@ -1519,7 +1517,7 @@ static bool8 Phase2_BigPokeball_Func4(struct Task *task)
     task->tData4 += 8;
     task->tData5 -= 256;
 
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
 
     sTransitionStructPtr->VBlank_DMA++;
     return FALSE;
@@ -1531,7 +1529,7 @@ static bool8 Phase2_BigPokeball_Func5(struct Task *task)
     task->tData4 += 8;
     task->tData5 -= 256;
 
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
 
     if (task->tData5 <= 0)
     {
@@ -1577,7 +1575,7 @@ static bool8 Phase2_BigPokeball_Func6(struct Task *task)
         if (task->tData1 < 0)
             task->tData1 = 0;
     }
-    sub_814A014(gUnknown_02038C28[0], 120, 80, task->tData1);
+    sub_814A014(gScanlineEffectRegBuffers[0], 120, 80, task->tData1);
     if (task->tData1 == 0)
     {
         SetVBlankCallback(NULL);
@@ -1604,7 +1602,7 @@ static void Transition_BigPokeball_Vblank(void)
     DmaStop(0);
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
     REG_WININ = sTransitionStructPtr->WININ;
     REG_WINOUT = sTransitionStructPtr->WINOUT;
     REG_WIN0V = sTransitionStructPtr->WIN0V;
@@ -1615,13 +1613,13 @@ static void Transition_BigPokeball_Vblank(void)
 static void VBlankCB0_Phase2_BigPokeball(void)
 {
     Transition_BigPokeball_Vblank();
-    DmaSet(0, gUnknown_020393A8, &REG_BG0HOFS, 0xA2400001);
+    DmaSet(0, gScanlineEffectRegBuffers[1], &REG_BG0HOFS, 0xA2400001);
 }
 
 static void VBlankCB1_Phase2_BigPokeball(void)
 {
     Transition_BigPokeball_Vblank();
-    DmaSet(0, gUnknown_020393A8, &REG_WIN0H, 0xA2400001);
+    DmaSet(0, gScanlineEffectRegBuffers[1], &REG_WIN0H, 0xA2400001);
 }
 
 static void Phase2Task_PokeballsTrail(u8 taskId)
@@ -1741,7 +1739,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task)
     u16 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     sTransitionStructPtr->WININ = 0;
     sTransitionStructPtr->WINOUT = 63;
@@ -1750,7 +1748,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_020393A8[i] = 0xF3F4;
+        gScanlineEffectRegBuffers[1][i] = 0xF3F4;
     }
 
     SetVBlankCallback(VBlankCB_Phase2_Clockwise_BlackFade);
@@ -1767,7 +1765,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task)
     sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], -1, 1, 1);
     do
     {
-        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] + 1) | 0x7800;
+        gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] + 1) | 0x7800;
     } while (!sub_814A228(sTransitionStructPtr->data, 1, 1));
 
     sTransitionStructPtr->data[4] += 16;
@@ -1795,7 +1793,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task)
         r1 = 120, r3 = sTransitionStructPtr->data[2] + 1;
         if (sTransitionStructPtr->data[5] >= 80)
             r1 = sTransitionStructPtr->data[2], r3 = 240;
-        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r3) | (r1 << 8);
+        gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] = (r3) | (r1 << 8);
         if (var != 0)
             break;
         var = sub_814A228(sTransitionStructPtr->data, 1, 1);
@@ -1811,7 +1809,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task)
     {
         while (sTransitionStructPtr->data[3] < sTransitionStructPtr->data[5])
         {
-            gUnknown_02038C28[0][++sTransitionStructPtr->data[3]] = (r3) | (r1 << 8);
+            gScanlineEffectRegBuffers[0][++sTransitionStructPtr->data[3]] = (r3) | (r1 << 8);
         }
     }
 
@@ -1826,7 +1824,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task)
     sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], 160, 1, 1);
     do
     {
-        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] << 8) | 0xF0;
+        gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] << 8) | 0xF0;
     } while (!sub_814A228(sTransitionStructPtr->data, 1, 1));
 
     sTransitionStructPtr->data[4] -= 16;
@@ -1851,12 +1849,12 @@ static bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task)
 
     while (1)
     {
-        r1 = (gUnknown_02038C28[0][sTransitionStructPtr->data[3]]) & 0xFF;
+        r1 = (gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]]) & 0xFF;
         r2 = sTransitionStructPtr->data[2];
         if (sTransitionStructPtr->data[5] <= 80)
             r2 = 120, r1 = sTransitionStructPtr->data[2];
         var4 = (r1) | (r2 << 8);
-        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = var4;
+        gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] = var4;
         if (var != 0)
             break;
         var = sub_814A228(sTransitionStructPtr->data, 1, 1);
@@ -1872,7 +1870,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task)
     {
         while (sTransitionStructPtr->data[3] > sTransitionStructPtr->data[5])
         {
-            gUnknown_02038C28[0][--sTransitionStructPtr->data[3]] = (r1) | (r2 << 8);
+            gScanlineEffectRegBuffers[0][--sTransitionStructPtr->data[3]] = (r1) | (r2 << 8);
         }
     }
 
@@ -1892,7 +1890,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task)
         r2 = 120, r3 = sTransitionStructPtr->data[2];
         if (sTransitionStructPtr->data[2] >= 120)
             r2 = 0, r3 = 240;
-        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r3) | (r2 << 8);
+        gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] = (r3) | (r2 << 8);
 
     } while (!sub_814A228(sTransitionStructPtr->data, 1, 1));
 
@@ -1917,12 +1915,12 @@ static void VBlankCB_Phase2_Clockwise_BlackFade(void)
     DmaStop(0);
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA != 0)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
     REG_WININ = sTransitionStructPtr->WININ;
     REG_WINOUT = sTransitionStructPtr->WINOUT;
     REG_WIN0V = sTransitionStructPtr->WIN0V;
-    REG_WIN0H = gUnknown_02038C28[1][0];
-    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+    REG_WIN0H = gScanlineEffectRegBuffers[1][0];
+    DmaSet(0, gScanlineEffectRegBuffers[1], &REG_WIN0H, 0xA2400001);
 }
 
 static void Phase2Task_Ripple(u8 taskId)
@@ -1935,11 +1933,11 @@ static bool8 Phase2_Ripple_Func1(struct Task *task)
     u8 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_020393A8[i] = sTransitionStructPtr->field_16;
+        gScanlineEffectRegBuffers[1][i] = sTransitionStructPtr->field_16;
     }
 
     SetVBlankCallback(VBlankCB_Phase2_Ripple);
@@ -1971,7 +1969,7 @@ static bool8 Phase2_Ripple_Func2(struct Task *task)
         // todo: fix the asm
         s16 var = r4 >> 8;
         asm("");
-        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3);
+        gScanlineEffectRegBuffers[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3);
     }
 
     if (++task->tData3 == 81)
@@ -1991,12 +1989,12 @@ static void VBlankCB_Phase2_Ripple(void)
 {
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
 }
 
 static void HBlankCB_Phase2_Ripple(void)
 {
-    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    u16 var = gScanlineEffectRegBuffers[1][REG_VCOUNT];
     REG_BG1VOFS = var;
     REG_BG2VOFS = var;
     REG_BG3VOFS = var;
@@ -2012,7 +2010,7 @@ static bool8 Phase2_Wave_Func1(struct Task *task)
     u8 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     sTransitionStructPtr->WININ = 63;
     sTransitionStructPtr->WINOUT = 0;
@@ -2021,7 +2019,7 @@ static bool8 Phase2_Wave_Func1(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[1][i] = 242;
+        gScanlineEffectRegBuffers[1][i] = 242;
     }
 
     SetVBlankCallback(VBlankCB_Phase2_Wave);
@@ -2037,7 +2035,7 @@ static bool8 Phase2_Wave_Func2(struct Task *task)
     bool8 nextFunc;
 
     sTransitionStructPtr->VBlank_DMA = FALSE;
-    toStore = gUnknown_02038C28[0];
+    toStore = gScanlineEffectRegBuffers[0];
     r5 = task->tData2;
     task->tData2 += 16;
     task->tData1 += 8;
@@ -2073,11 +2071,11 @@ static void VBlankCB_Phase2_Wave(void)
     DmaStop(0);
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA != 0)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
     REG_WININ = sTransitionStructPtr->WININ;
     REG_WINOUT = sTransitionStructPtr->WINOUT;
     REG_WIN0V = sTransitionStructPtr->WIN0V;
-    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+    DmaSet(0, gScanlineEffectRegBuffers[1], &REG_WIN0H, 0xA2400001);
 }
 
 static void Phase2Task_Sydney(u8 taskId)
@@ -2120,7 +2118,7 @@ static bool8 Phase2_Mugshot_Func1(struct Task *task)
     u8 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
     Mugshots_CreateOpponentPlayerSprites(task);
 
     task->tData1 = 0;
@@ -2132,7 +2130,7 @@ static bool8 Phase2_Mugshot_Func1(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[1][i] = 0xF0F1;
+        gScanlineEffectRegBuffers[1][i] = 0xF0F1;
     }
 
     SetVBlankCallback(VBlankCB0_Phase2_Mugshots);
@@ -2177,7 +2175,7 @@ static bool8 Phase2_Mugshot_Func3(struct Task *task)
 
     sTransitionStructPtr->VBlank_DMA = FALSE;
 
-    toStore = gUnknown_02038C28[0];
+    toStore = gScanlineEffectRegBuffers[0];
     r5 = task->tData1;
     task->tData1 += 0x10;
 
@@ -2223,7 +2221,7 @@ static bool8 Phase2_Mugshot_Func4(struct Task *task)
 
     sTransitionStructPtr->VBlank_DMA = FALSE;
 
-    for (i = 0, toStore = gUnknown_02038C28[0]; i < 160; i++, toStore++)
+    for (i = 0, toStore = gScanlineEffectRegBuffers[0]; i < 160; i++, toStore++)
     {
         *toStore = 0xF0;
     }
@@ -2266,8 +2264,8 @@ static bool8 Phase2_Mugshot_Func6(struct Task *task)
         sTransitionStructPtr->VBlank_DMA = FALSE;
         SetVBlankCallback(NULL);
         DmaStop(0);
-        memset(gUnknown_02038C28[0], 0, 0x140);
-        memset(gUnknown_02038C28[1], 0, 0x140);
+        memset(gScanlineEffectRegBuffers[0], 0, 0x140);
+        memset(gScanlineEffectRegBuffers[1], 0, 0x140);
         SetGpuReg(REG_OFFSET_WIN0H, 0xF0);
         SetGpuReg(REG_OFFSET_BLDY, 0);
         task->tState++;
@@ -2300,15 +2298,15 @@ static bool8 Phase2_Mugshot_Func7(struct Task *task)
         {
             s16 index1 = 0x50 - i;
             s16 index2 = 0x50 + i;
-            if (gUnknown_02038C28[0][index1] <= 15)
+            if (gScanlineEffectRegBuffers[0][index1] <= 15)
             {
                 r6 = TRUE;
-                gUnknown_02038C28[0][index1]++;
+                gScanlineEffectRegBuffers[0][index1]++;
             }
-            if (gUnknown_02038C28[0][index2] <= 15)
+            if (gScanlineEffectRegBuffers[0][index2] <= 15)
             {
                 r6 = TRUE;
-                gUnknown_02038C28[0][index2]++;
+                gScanlineEffectRegBuffers[0][index2]++;
             }
         }
     }
@@ -2336,7 +2334,7 @@ static bool8 Phase2_Mugshot_Func9(struct Task *task)
     sTransitionStructPtr->VBlank_DMA = FALSE;
 
     task->tData3++;
-    memset(gUnknown_02038C28[0], task->tData3, 0x140);
+    memset(gScanlineEffectRegBuffers[0], task->tData3, 0x140);
     if (task->tData3 > 15)
         task->tState++;
 
@@ -2357,12 +2355,12 @@ static void VBlankCB0_Phase2_Mugshots(void)
     DmaStop(0);
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA != 0)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
     REG_BG0VOFS = sTransitionStructPtr->BG0VOFS;
     REG_WININ = sTransitionStructPtr->WININ;
     REG_WINOUT = sTransitionStructPtr->WINOUT;
     REG_WIN0V = sTransitionStructPtr->WIN0V;
-    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+    DmaSet(0, gScanlineEffectRegBuffers[1], &REG_WIN0H, 0xA2400001);
 }
 
 static void VBlankCB1_Phase2_Mugshots(void)
@@ -2370,9 +2368,9 @@ static void VBlankCB1_Phase2_Mugshots(void)
     DmaStop(0);
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA != 0)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
     REG_BLDCNT = sTransitionStructPtr->BLDCNT;
-    DmaSet(0, gUnknown_02038C28[1], &REG_BLDY, 0xA2400001);
+    DmaSet(0, gScanlineEffectRegBuffers[1], &REG_BLDY, 0xA2400001);
 }
 
 static void HBlankCB_Phase2_Mugshots(void)
@@ -2500,7 +2498,7 @@ static bool8 Phase2_Slice_Func1(struct Task *task)
     u16 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     task->tData2 = 256;
     task->tData3 = 1;
@@ -2511,8 +2509,8 @@ static bool8 Phase2_Slice_Func1(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[1][i] = sTransitionStructPtr->field_14;
-        gUnknown_02038C28[1][160 + i] = 0xF0;
+        gScanlineEffectRegBuffers[1][i] = sTransitionStructPtr->field_14;
+        gScanlineEffectRegBuffers[1][160 + i] = 0xF0;
     }
 
     EnableInterrupts(INTR_FLAG_HBLANK);
@@ -2541,8 +2539,8 @@ static bool8 Phase2_Slice_Func2(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        u16 *storeLoc1 = &gUnknown_02038C28[0][i];
-        u16 *storeLoc2 = &gUnknown_02038C28[0][i + 160];
+        u16 *storeLoc1 = &gScanlineEffectRegBuffers[0][i];
+        u16 *storeLoc2 = &gScanlineEffectRegBuffers[0][i + 160];
         if (i & 1)
         {
             *storeLoc1 = sTransitionStructPtr->field_14 + task->tData1;
@@ -2578,15 +2576,15 @@ static void VBlankCB_Phase2_Slice(void)
     REG_WINOUT = sTransitionStructPtr->WINOUT;
     REG_WIN0V = sTransitionStructPtr->WIN0V;
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 640);
-    DmaSet(0, &gUnknown_02038C28[1][160], &REG_WIN0H, 0xA2400001);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 640);
+    DmaSet(0, &gScanlineEffectRegBuffers[1][160], &REG_WIN0H, 0xA2400001);
 }
 
 static void HBlankCB_Phase2_Slice(void)
 {
     if (REG_VCOUNT < 160)
     {
-        u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+        u16 var = gScanlineEffectRegBuffers[1][REG_VCOUNT];
         REG_BG1HOFS = var;
         REG_BG2HOFS = var;
         REG_BG3HOFS = var;
@@ -2603,7 +2601,7 @@ static bool8 Phase2_ShredSplit_Func1(struct Task *task)
     u16 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     sTransitionStructPtr->WININ = 63;
     sTransitionStructPtr->WINOUT = 0;
@@ -2611,13 +2609,13 @@ static bool8 Phase2_ShredSplit_Func1(struct Task *task)
 
     for (i = 0; i < 0xA0; i++)
     {
-        gUnknown_02038C28[1][i] = sTransitionStructPtr->field_14;
-        gUnknown_02038C28[1][0xA0 + i] = 0xF0;
-        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_14;
-        gUnknown_02038C28[0][0xA0 + i] = 0xF0;
-        gUnknown_02038C28[0][0x140 + i] = 0;
-        gUnknown_02038C28[0][0x1E0 + i] = 0x100;
-        gUnknown_02038C28[0][0x280 + i] = 1;
+        gScanlineEffectRegBuffers[1][i] = sTransitionStructPtr->field_14;
+        gScanlineEffectRegBuffers[1][0xA0 + i] = 0xF0;
+        gScanlineEffectRegBuffers[0][i] = sTransitionStructPtr->field_14;
+        gScanlineEffectRegBuffers[0][0xA0 + i] = 0xF0;
+        gScanlineEffectRegBuffers[0][0x140 + i] = 0;
+        gScanlineEffectRegBuffers[0][0x1E0 + i] = 0x100;
+        gScanlineEffectRegBuffers[0][0x280 + i] = 1;
     }
 
     task->tData4 = 0;
@@ -2657,9 +2655,9 @@ static bool8 Phase2_ShredSplit_Func2(struct Task *task)
                 unkVar = (arr1[j]) + (arr2[k] * -(i) * 2);
                 if (unkVar >= 0 && (unkVar != 79 || j != 1))
                 {
-                    ptr4 = &gUnknown_02038C28[0][unkVar + 320];
-                    ptr3 = &gUnknown_02038C28[0][unkVar + 480];
-                    ptr1 = &gUnknown_02038C28[0][unkVar + 640];
+                    ptr4 = &gScanlineEffectRegBuffers[0][unkVar + 320];
+                    ptr3 = &gScanlineEffectRegBuffers[0][unkVar + 480];
+                    ptr1 = &gScanlineEffectRegBuffers[0][unkVar + 640];
                     if (*ptr4 > 0xEF)
                     {
                         *ptr4 = 0xF0;
@@ -2673,8 +2671,8 @@ static bool8 Phase2_ShredSplit_Func2(struct Task *task)
                         if (*ptr3 <= 0xFFF)
                             *ptr3 += *ptr1;
                     }
-                    ptr2 = &gUnknown_02038C28[0][unkVar];
-                    ptr3 = &gUnknown_02038C28[0][unkVar + 160];
+                    ptr2 = &gScanlineEffectRegBuffers[0][unkVar];
+                    ptr3 = &gScanlineEffectRegBuffers[0][unkVar + 160];
                     *ptr2 = sTransitionStructPtr->field_14 + *ptr4;
                     *ptr3 = 0xF0 - *ptr4;
 
@@ -2691,9 +2689,9 @@ static bool8 Phase2_ShredSplit_Func2(struct Task *task)
                 unkVar = (arr1[j] + 1) + (arr2[k] * -(i) * 2);
                 if (unkVar <= 160 && (unkVar != 80 || j != 1))
                 {
-                    ptr4 = &gUnknown_02038C28[0][unkVar + 320];
-                    ptr3 = &gUnknown_02038C28[0][unkVar + 480];
-                    ptr1 = &gUnknown_02038C28[0][unkVar + 640];
+                    ptr4 = &gScanlineEffectRegBuffers[0][unkVar + 320];
+                    ptr3 = &gScanlineEffectRegBuffers[0][unkVar + 480];
+                    ptr1 = &gScanlineEffectRegBuffers[0][unkVar + 640];
                     if (*ptr4 > 0xEF)
                     {
                         *ptr4 = 0xF0;
@@ -2707,8 +2705,8 @@ static bool8 Phase2_ShredSplit_Func2(struct Task *task)
                         if (*ptr3 <= 0xFFF)
                             *ptr3 += *ptr1;
                     }
-                    ptr2 = &gUnknown_02038C28[0][unkVar];
-                    ptr3 = &gUnknown_02038C28[0][unkVar + 160];
+                    ptr2 = &gScanlineEffectRegBuffers[0][unkVar];
+                    ptr3 = &gScanlineEffectRegBuffers[0][unkVar + 160];
                     *ptr2 = sTransitionStructPtr->field_14 - *ptr4;
                     *ptr3 = (*ptr4 << 8) | (0xF1);
 
@@ -2732,7 +2730,7 @@ static bool8 Phase2_ShredSplit_Func2(struct Task *task)
 
 // This function never increments the state counter, because the loop condition
 // is always false, resulting in the game being stuck in an infinite loop.
-// It's possible this transition is only partially 
+// It's possible this transition is only partially
 // done and the second part was left out.
 static bool8 Phase2_ShredSplit_Func3(struct Task *task)
 {
@@ -2742,7 +2740,7 @@ static bool8 Phase2_ShredSplit_Func3(struct Task *task)
 
     for (i = 0; i < 0xA0; i++)
     {
-        if (gUnknown_02038C28[1][i] != 0xF0 && gUnknown_02038C28[1][i] != checkVar2)
+        if (gScanlineEffectRegBuffers[1][i] != 0xF0 && gScanlineEffectRegBuffers[1][i] != checkVar2)
             done = FALSE; // a break statement should be put here
     }
 
@@ -2775,7 +2773,7 @@ static bool8 Phase2_Blackhole_Func1(struct Task *task)
     s32 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     sTransitionStructPtr->WININ = 0;
     sTransitionStructPtr->WINOUT = 63;
@@ -2784,7 +2782,7 @@ static bool8 Phase2_Blackhole_Func1(struct Task *task)
 
     for (i = 0; i < 0xA0; i++)
     {
-        gUnknown_02038C28[1][i] = 0;
+        gScanlineEffectRegBuffers[1][i] = 0;
     }
 
     SetVBlankCallback(VBlankCB1_Phase2_BigPokeball);
@@ -2814,7 +2812,7 @@ static bool8 Phase2_Blackhole1_Func3(struct Task *task)
             task->tData1 += (task->tData2 >> 8);
         if (task->tData1 > 0xA0)
             task->tData1 = 0xA0;
-        sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1);
+        sub_814A014(gScanlineEffectRegBuffers[0], 0x78, 0x50, task->tData1);
         if (task->tData1 == 0xA0)
         {
             task->tFuncState = 1;
@@ -2840,7 +2838,7 @@ static bool8 Phase2_Blackhole1_Func2(struct Task *task)
     }
     task->tData1 += gUnknown_085C8C80[task->tData6];
     task->tData6 = (task->tData6 + 1) % 2;
-    sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1);
+    sub_814A014(gScanlineEffectRegBuffers[0], 0x78, 0x50, task->tData1);
     if (task->tData1 < 9)
     {
         task->tState++;
@@ -2866,7 +2864,7 @@ static bool8 Phase2_Blackhole2_Func2(struct Task *task)
     if (task->tData1 > 0xA0)
         task->tData1 = 0xA0;
 
-    sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1);
+    sub_814A014(gScanlineEffectRegBuffers[0], 0x78, 0x50, task->tData1);
     if (task->tData1 == 0xA0)
     {
         DmaStop(0);
@@ -3113,7 +3111,7 @@ static bool8 Phase2_Rayquaza_Func3(struct Task *task)
     u16 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     SetGpuReg(REG_OFFSET_BG0CNT, 0x9A08);
     sub_8149F58(&dst1, &dst2);
@@ -3126,8 +3124,8 @@ static bool8 Phase2_Rayquaza_Func3(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[0][i] = 0;
-        gUnknown_02038C28[1][i] = 0x100;
+        gScanlineEffectRegBuffers[0][i] = 0;
+        gScanlineEffectRegBuffers[1][i] = 0x100;
     }
 
     SetVBlankCallback(VBlankCB_Phase2_Rayquaza);
@@ -3212,7 +3210,7 @@ static bool8 Phase2_Rayquaza_Func9(struct Task *task)
 
         for (i = 0; i < 160; i++)
         {
-            gUnknown_02038C28[1][i] = 0;
+            gScanlineEffectRegBuffers[1][i] = 0;
         }
 
         SetVBlankCallback(VBlankCB1_Phase2_BigPokeball);
@@ -3233,11 +3231,11 @@ static void VBlankCB_Phase2_Rayquaza(void)
     VBlankCB_BattleTransition();
 
     if (sTransitionStructPtr->field_20 == 0)
-        dmaSrc = gUnknown_02038C28[0];
+        dmaSrc = gScanlineEffectRegBuffers[0];
     else if (sTransitionStructPtr->field_20 == 1)
-        dmaSrc = gUnknown_02038C28[1];
+        dmaSrc = gScanlineEffectRegBuffers[1];
     else
-        dmaSrc = gUnknown_02038C28[0];
+        dmaSrc = gScanlineEffectRegBuffers[0];
 
     DmaSet(0, dmaSrc, &REG_BG0VOFS, 0xA2400001);
 }
@@ -3252,7 +3250,7 @@ static bool8 Phase2_WhiteFade_Func1(struct Task *task)
     u16 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     sTransitionStructPtr->BLDCNT = 0xBF;
     sTransitionStructPtr->BLDY = 0;
@@ -3262,8 +3260,8 @@ static bool8 Phase2_WhiteFade_Func1(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[1][i] = 0;
-        gUnknown_02038C28[1][i + 160] = 0xF0;
+        gScanlineEffectRegBuffers[1][i] = 0;
+        gScanlineEffectRegBuffers[1][i + 160] = 0xF0;
     }
 
     EnableInterrupts(INTR_FLAG_HBLANK);
@@ -3343,8 +3341,8 @@ static void VBlankCB0_Phase2_WhiteFade(void)
     REG_WINOUT = sTransitionStructPtr->WINOUT;
     REG_WIN0V = sTransitionStructPtr->WIN0V;
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 640);
-    DmaSet(0, &gUnknown_02038C28[1][160], &REG_WIN0H, 0xA2400001);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 640);
+    DmaSet(0, &gScanlineEffectRegBuffers[1][160], &REG_WIN0H, 0xA2400001);
 }
 
 static void VBlankCB1_Phase2_WhiteFade(void)
@@ -3360,7 +3358,7 @@ static void VBlankCB1_Phase2_WhiteFade(void)
 
 static void HBlankCB_Phase2_WhiteFade(void)
 {
-    REG_BLDY = gUnknown_02038C28[1][REG_VCOUNT];
+    REG_BLDY = gScanlineEffectRegBuffers[1][REG_VCOUNT];
 }
 
 static void sub_8149864(struct Sprite *sprite)
@@ -3374,8 +3372,8 @@ static void sub_8149864(struct Sprite *sprite)
     else
     {
         u16 i;
-        u16* ptr1 = &gUnknown_02038C28[0][sprite->pos1.y];
-        u16* ptr2 = &gUnknown_02038C28[0][sprite->pos1.y + 160];
+        u16* ptr1 = &gScanlineEffectRegBuffers[0][sprite->pos1.y];
+        u16* ptr2 = &gScanlineEffectRegBuffers[0][sprite->pos1.y + 160];
         for (i = 0; i < 20; i++)
         {
             ptr1[i] = sprite->data[0] >> 8;
@@ -3465,7 +3463,7 @@ static bool8 Phase2_Shards_Func1(struct Task *task)
     u16 i;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
 
     sTransitionStructPtr->WININ = 0x3F;
     sTransitionStructPtr->WINOUT = 0;
@@ -3473,10 +3471,10 @@ static bool8 Phase2_Shards_Func1(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[0][i] = 0xF0;
+        gScanlineEffectRegBuffers[0][i] = 0xF0;
     }
 
-    CpuSet(gUnknown_02038C28[0], gUnknown_02038C28[1], 0xA0);
+    CpuSet(gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 0xA0);
     SetVBlankCallback(VBlankCB_Phase2_Shards);
 
     task->tState++;
@@ -3505,8 +3503,8 @@ static bool8 Phase2_Shards_Func3(struct Task *task)
 
     for (i = 0, nextFunc = FALSE; i < 16; i++)
     {
-        s16 r3 = gUnknown_02038C28[0][sTransitionStructPtr->data[3]] >> 8;
-        s16 r4 = gUnknown_02038C28[0][sTransitionStructPtr->data[3]] & 0xFF;
+        s16 r3 = gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] >> 8;
+        s16 r4 = gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] & 0xFF;
         if (task->tData2 == 0)
         {
             if (r3 < sTransitionStructPtr->data[2])
@@ -3521,7 +3519,7 @@ static bool8 Phase2_Shards_Func3(struct Task *task)
             if (r4 <= r3)
                 r4 = r3;
         }
-        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r4) | (r3 << 8);
+        gScanlineEffectRegBuffers[0][sTransitionStructPtr->data[3]] = (r4) | (r3 << 8);
         if (nextFunc)
         {
             task->tState++;
@@ -3568,12 +3566,12 @@ static void VBlankCB_Phase2_Shards(void)
     DmaStop(0);
     VBlankCB_BattleTransition();
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
     REG_WININ = sTransitionStructPtr->WININ;
     REG_WINOUT = sTransitionStructPtr->WINOUT;
     REG_WIN0V = sTransitionStructPtr->WIN0V;
-    REG_WIN0H = gUnknown_02038C28[1][0];
-    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+    REG_WIN0H = gScanlineEffectRegBuffers[1][0];
+    DmaSet(0, gScanlineEffectRegBuffers[1], &REG_WIN0H, 0xA2400001);
 }
 
 // sub-task for phase2
@@ -3875,7 +3873,7 @@ static bool8 Phase2_29_Func2(struct Task *task)
 
     sub_8149F58(&dst1, &dst2);
     LZ77UnCompVram(gUnknown_085C828C, dst1);
-    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 0x84, task->tData5, 160);
+    sub_8149F98(gScanlineEffectRegBuffers[0], 0, task->tData4, 0x84, task->tData5, 160);
 
     task->tState++;
     return TRUE;
@@ -3896,7 +3894,7 @@ static bool8 Phase2_30_Func1(struct Task *task)
     u16 *dst1, *dst2;
 
     sub_8149F08();
-    dp12_8087EA4();
+    ScanlineEffect_Clear();
     ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON);
     task->tData2 = 0x2000;
     task->tData1 = 0x7FFF;
@@ -3934,7 +3932,7 @@ static bool8 Phase2_30_Func3(struct Task *task)
 
     for (i = 0; i < 160; i++)
     {
-        gUnknown_02038C28[1][i] = sTransitionStructPtr->field_16;
+        gScanlineEffectRegBuffers[1][i] = sTransitionStructPtr->field_16;
     }
 
     SetVBlankCallback(VBlankCB_Phase2_30);
@@ -3980,7 +3978,7 @@ static bool8 Phase2_30_Func4(struct Task *task)
     {
         s16 index = var6 / 256;
         asm("");
-        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(index, amplitude);
+        gScanlineEffectRegBuffers[0][i] = sTransitionStructPtr->field_16 + Sin(index, amplitude);
     }
 
     if (++task->tData3 == 101)
@@ -4004,12 +4002,12 @@ static void VBlankCB_Phase2_30(void)
     REG_BLDALPHA = sTransitionStructPtr->BLDALPHA;
 
     if (sTransitionStructPtr->VBlank_DMA)
-        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+        DmaCopy16(3, gScanlineEffectRegBuffers[0], gScanlineEffectRegBuffers[1], 320);
 }
 
 static void HBlankCB_Phase2_30(void)
 {
-    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    u16 var = gScanlineEffectRegBuffers[1][REG_VCOUNT];
     REG_BG0VOFS = var;
 }
 

src/battle_util2.c

@@ -8,12 +8,12 @@
 #include "random.h"
 #include "battle_scripts.h"
 
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
 extern u8 gUnknown_0203CF00[];
 extern const u8 *gBattlescriptCurrInstr;
 extern u8 gBattleCommunication[];
-extern u8 gActiveBank;
+extern u8 gActiveBattler;
 
 extern void sub_81D55D0(void);
 extern void sub_81D5694(void);
@@ -87,33 +87,33 @@ void AdjustFriendshipOnBattleFaint(u8 bank)
     {
         u8 opposingBank2;
 
-        opposingBank = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
-        opposingBank2 = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
+        opposingBank = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
+        opposingBank2 = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
 
         if (gBattleMons[opposingBank2].level > gBattleMons[opposingBank].level)
             opposingBank = opposingBank2;
     }
     else
     {
-        opposingBank = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
+        opposingBank = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
     }
 
     if (gBattleMons[opposingBank].level > gBattleMons[bank].level)
     {
         if (gBattleMons[opposingBank].level - gBattleMons[bank].level > 29)
-            AdjustFriendship(&gPlayerParty[gBattlePartyID[bank]], 8);
+            AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[bank]], 8);
         else
-            AdjustFriendship(&gPlayerParty[gBattlePartyID[bank]], 6);
+            AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[bank]], 6);
     }
     else
     {
-        AdjustFriendship(&gPlayerParty[gBattlePartyID[bank]], 6);
+        AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[bank]], 6);
     }
 }
 
 void sub_80571DC(u8 bank, u8 arg1)
 {
-    if (GetBankSide(bank) != SIDE_OPPONENT)
+    if (GetBattlerSide(bank) != B_SIDE_OPPONENT)
     {
         s32 i;
 
@@ -122,7 +122,7 @@ void sub_80571DC(u8 bank, u8 arg1)
         for (i = 0; i < 3; i++)
             gUnknown_0203CF00[i] = *(0 * 3 + i + (u8*)(gBattleStruct->field_60));
 
-        sub_81B8FB0(pokemon_order_func(gBattlePartyID[bank]), pokemon_order_func(arg1));
+        sub_81B8FB0(pokemon_order_func(gBattlerPartyIndexes[bank]), pokemon_order_func(arg1));
 
         for (i = 0; i < 3; i++)
             *(0 * 3 + i + (u8*)(gBattleStruct->field_60)) = gUnknown_0203CF00[i];
@@ -138,11 +138,11 @@ u32 sub_805725C(u8 bank)
         switch (gBattleCommunication[MULTIUSE_STATE])
         {
         case 0:
-            if (gBattleMons[bank].status1 & STATUS_SLEEP)
+            if (gBattleMons[bank].status1 & STATUS1_SLEEP)
             {
                 if (UproarWakeUpCheck(bank))
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_SLEEP);
+                    gBattleMons[bank].status1 &= ~(STATUS1_SLEEP);
                     gBattleMons[bank].status2 &= ~(STATUS2_NIGHTMARE);
                     BattleScriptPushCursor();
                     gBattleCommunication[MULTISTRING_CHOOSER] = 1;
@@ -158,12 +158,12 @@ u32 sub_805725C(u8 bank)
                     else
                         toSub = 1;
 
-                    if ((gBattleMons[bank].status1 & STATUS_SLEEP) < toSub)
-                        gBattleMons[bank].status1 &= ~(STATUS_SLEEP);
+                    if ((gBattleMons[bank].status1 & STATUS1_SLEEP) < toSub)
+                        gBattleMons[bank].status1 &= ~(STATUS1_SLEEP);
                     else
                         gBattleMons[bank].status1 -= toSub;
 
-                    if (gBattleMons[bank].status1 & STATUS_SLEEP)
+                    if (gBattleMons[bank].status1 & STATUS1_SLEEP)
                     {
                         gBattlescriptCurrInstr = BattleScript_MoveUsedIsAsleep;
                         effect = 2;
@@ -181,7 +181,7 @@ u32 sub_805725C(u8 bank)
             gBattleCommunication[MULTIUSE_STATE]++;
             break;
         case 1:
-            if (gBattleMons[bank].status1 & STATUS_FREEZE)
+            if (gBattleMons[bank].status1 & STATUS1_FREEZE)
             {
                 if (Random() % 5 != 0)
                 {
@@ -189,7 +189,7 @@ u32 sub_805725C(u8 bank)
                 }
                 else
                 {
-                    gBattleMons[bank].status1 &= ~(STATUS_FREEZE);
+                    gBattleMons[bank].status1 &= ~(STATUS1_FREEZE);
                     BattleScriptPushCursor();
                     gBattlescriptCurrInstr = BattleScript_MoveUsedUnfroze;
                     gBattleCommunication[MULTISTRING_CHOOSER] = 0;
@@ -206,9 +206,9 @@ u32 sub_805725C(u8 bank)
 
     if (effect == 2)
     {
-        gActiveBank = bank;
-        EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBank].status1);
-        MarkBufferBankForExecution(gActiveBank);
+        gActiveBattler = bank;
+        BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1);
+        MarkBattlerForControllerExec(gActiveBattler);
     }
 
     return effect;

src/berry_fix_program.c

@@ -6,7 +6,7 @@
 #include "main.h"
 #include "sprite.h"
 #include "task.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "window.h"
 #include "text.h"
 #include "menu.h"
@@ -133,7 +133,7 @@ extern const u8 gMultiBootProgram_BerryGlitchFix_End[];
 
 // .text
 
-void InitBerryFixProgram(void)
+void CB2_InitBerryFixProgram(void)
 {
     DisableInterrupts(0xFFFF);
     EnableInterrupts(0x0001);
@@ -217,10 +217,9 @@ static void berry_fix_main(void)
     }
 }
 
-#ifdef NONMATCHING
 static void berry_fix_gpu_set(void)
 {
-    s32 width;
+    s32 width, left;
 
     SetGpuReg(REG_OFFSET_BG0CNT, 0x0000);
     SetGpuReg(REG_OFFSET_BG1CNT, 0x0000);
@@ -249,230 +248,27 @@ static void berry_fix_gpu_set(void)
     FillWindowPixelBuffer(3, 0);
     FillWindowPixelBuffer(0, 0xAA);
 
-// This block is a meme among memes
-    width = (0x78 - GetStringWidth(0, sUnknown_08617E9B, 0)) / 2;
-    box_print(2, 0, width, 3, sUnknown_0861815B, -1, sUnknown_08617E9B);
-    width = (s32)(0x78 - GetStringWidth(0, sUnknown_08617E9B, 0)) / 2 + 0x78;
-    box_print(2, 0, width, 3, sUnknown_0861815B, -1, sUnknown_08617E8D);
-    width = (0x70 - GetStringWidth(0, sUnknown_08617E8D, 0)) / 2;
-    box_print(3, 0, width, 0, sUnknown_0861815B, -1, sUnknown_08617E8D);
-    width = (0xd0 - GetStringWidth(1, sUnknown_08617E78, 0)) / 2;
-    box_print(0, 1, width, 2, sUnknown_08618158, -1, sUnknown_08617E78);
+    width = GetStringWidth(0, sUnknown_08617E9B, 0);
+    left = (0x78 - width) / 2;
+    box_print(2, 0, left, 3, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E9B);
+
+    width = GetStringWidth(0, sUnknown_08617E8D, 0);
+    left = (0x78 - width) / 2 + 0x78;
+    box_print(2, 0, left, 3, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E8D);
+
+    width = GetStringWidth(0, sUnknown_08617E8D, 0);
+    left = (0x70 - width) / 2;
+    box_print(3, 0, left, 0, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E8D);
+
+    width = GetStringWidth(1, sUnknown_08617E78, 0);
+    left = (0xD0 - width) / 2;
+    box_print(0, 1, left, 2, sUnknown_08618158, TEXT_SPEED_FF, sUnknown_08617E78);
 
     CopyWindowToVram(2, 2);
     CopyWindowToVram(3, 2);
     CopyWindowToVram(0, 2);
 }
 
-#else
-__attribute__((naked)) static void berry_fix_gpu_set(void)
-{
-    asm(".syntax unified\n"
-        "\tpush {r4-r6,lr}\n"
-        "\tmov r6, r8\n"
-        "\tpush {r6}\n"
-        "\tsub sp, 0x10\n"
-        "\tmovs r0, 0x8\n"
-        "\tmovs r1, 0\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r0, 0xA\n"
-        "\tmovs r1, 0\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r0, 0x10\n"
-        "\tmovs r1, 0\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r0, 0x12\n"
-        "\tmovs r1, 0\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r0, 0x14\n"
-        "\tmovs r1, 0\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r0, 0x16\n"
-        "\tmovs r1, 0\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r0, 0x50\n"
-        "\tmovs r1, 0\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r1, 0\n"
-        "\tstr r1, [sp, 0xC]\n"
-        "\tldr r4, =0x040000d4\n"
-        "\tadd r0, sp, 0xC\n"
-        "\tstr r0, [r4]\n"
-        "\tmovs r0, 0xC0\n"
-        "\tlsls r0, 19\n"
-        "\tstr r0, [r4, 0x4]\n"
-        "\tldr r0, =0x85006000\n"
-        "\tstr r0, [r4, 0x8]\n"
-        "\tldr r0, [r4, 0x8]\n"
-        "\tstr r1, [sp, 0xC]\n"
-        "\tadd r0, sp, 0xC\n"
-        "\tstr r0, [r4]\n"
-        "\tmovs r0, 0xE0\n"
-        "\tlsls r0, 19\n"
-        "\tstr r0, [r4, 0x4]\n"
-        "\tldr r2, =0x85000100\n"
-        "\tstr r2, [r4, 0x8]\n"
-        "\tldr r0, [r4, 0x8]\n"
-        "\tstr r1, [sp, 0xC]\n"
-        "\tadd r0, sp, 0xC\n"
-        "\tstr r0, [r4]\n"
-        "\tmovs r0, 0xA0\n"
-        "\tlsls r0, 19\n"
-        "\tstr r0, [r4, 0x4]\n"
-        "\tstr r2, [r4, 0x8]\n"
-        "\tldr r0, [r4, 0x8]\n"
-        "\tmovs r0, 0\n"
-        "\tbl ResetBgsAndClearDma3BusyFlags\n"
-        "\tldr r1, =gUnknown_08618108\n"
-        "\tmovs r0, 0\n"
-        "\tmovs r2, 0x2\n"
-        "\tbl InitBgsFromTemplates\n"
-        "\tmovs r0, 0\n"
-        "\tmovs r1, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl ChangeBgX\n"
-        "\tmovs r0, 0\n"
-        "\tmovs r1, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl ChangeBgY\n"
-        "\tmovs r0, 0x1\n"
-        "\tmovs r1, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl ChangeBgX\n"
-        "\tmovs r0, 0x1\n"
-        "\tmovs r1, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl ChangeBgY\n"
-        "\tldr r0, =gUnknown_08618110\n"
-        "\tbl InitWindows\n"
-        "\tbl DeactivateAllTextPrinters\n"
-        "\tldr r0, =sUnknown_08618138\n"
-        "\tstr r0, [r4]\n"
-        "\tldr r0, =0x050001e0\n"
-        "\tstr r0, [r4, 0x4]\n"
-        "\tldr r0, =0x84000008\n"
-        "\tstr r0, [r4, 0x8]\n"
-        "\tldr r0, [r4, 0x8]\n"
-        "\tmovs r0, 0\n"
-        "\tmovs r1, 0x40\n"
-        "\tbl SetGpuReg\n"
-        "\tmovs r0, 0x2\n"
-        "\tmovs r1, 0\n"
-        "\tbl FillWindowPixelBuffer\n"
-        "\tmovs r0, 0x3\n"
-        "\tmovs r1, 0\n"
-        "\tbl FillWindowPixelBuffer\n"
-        "\tmovs r0, 0\n"
-        "\tmovs r1, 0xAA\n"
-        "\tbl FillWindowPixelBuffer\n"
-        "\tldr r5, =sUnknown_08617E9B\n"
-        "\tmovs r0, 0\n"
-        "\tadds r1, r5, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl GetStringWidth\n"
-        "\tadds r1, r0, 0\n"
-        "\tmovs r4, 0x78\n"
-        "\tsubs r0, r4, r1\n"
-        "\tlsrs r1, r0, 31\n"
-        "\tadds r0, r1\n"
-        "\tasrs r0, 1\n"
-        "\tlsls r2, r0, 24\n"
-        "\tlsrs r2, 24\n"
-        "\tldr r6, =sUnknown_0861815B\n"
-        "\tstr r6, [sp]\n"
-        "\tmovs r0, 0x1\n"
-        "\tnegs r0, r0\n"
-        "\tmov r8, r0\n"
-        "\tstr r0, [sp, 0x4]\n"
-        "\tstr r5, [sp, 0x8]\n"
-        "\tmovs r0, 0x2\n"
-        "\tmovs r1, 0\n"
-        "\tmovs r3, 0x3\n"
-        "\tbl box_print\n"
-        "\tldr r5, =sUnknown_08617E8D\n"
-        "\tmovs r0, 0\n"
-        "\tadds r1, r5, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl GetStringWidth\n"
-        "\tadds r1, r0, 0\n"
-        "\tsubs r4, r1\n"
-        "\tlsrs r0, r4, 31\n"
-        "\tadds r4, r0\n"
-        "\tasrs r4, 1\n"
-        "\tadds r0, r4, 0\n"
-        "\tadds r0, 0x78\n"
-        "\tlsls r2, r0, 24\n"
-        "\tlsrs r2, 24\n"
-        "\tstr r6, [sp]\n"
-        "\tmov r0, r8\n"
-        "\tstr r0, [sp, 0x4]\n"
-        "\tstr r5, [sp, 0x8]\n"
-        "\tmovs r0, 0x2\n"
-        "\tmovs r1, 0\n"
-        "\tmovs r3, 0x3\n"
-        "\tbl box_print\n"
-        "\tmovs r0, 0\n"
-        "\tadds r1, r5, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl GetStringWidth\n"
-        "\tadds r1, r0, 0\n"
-        "\tmovs r0, 0x70\n"
-        "\tsubs r0, r1\n"
-        "\tlsrs r1, r0, 31\n"
-        "\tadds r0, r1\n"
-        "\tasrs r0, 1\n"
-        "\tlsls r2, r0, 24\n"
-        "\tlsrs r2, 24\n"
-        "\tstr r6, [sp]\n"
-        "\tmov r0, r8\n"
-        "\tstr r0, [sp, 0x4]\n"
-        "\tstr r5, [sp, 0x8]\n"
-        "\tmovs r0, 0x3\n"
-        "\tmovs r1, 0\n"
-        "\tmovs r3, 0\n"
-        "\tbl box_print\n"
-        "\tldr r4, =sUnknown_08617E78\n"
-        "\tmovs r0, 0x1\n"
-        "\tadds r1, r4, 0\n"
-        "\tmovs r2, 0\n"
-        "\tbl GetStringWidth\n"
-        "\tadds r1, r0, 0\n"
-        "\tmovs r0, 0xD0\n"
-        "\tsubs r0, r1\n"
-        "\tlsrs r1, r0, 31\n"
-        "\tadds r0, r1\n"
-        "\tasrs r0, 1\n"
-        "\tlsls r2, r0, 24\n"
-        "\tlsrs r2, 24\n"
-        "\tldr r0, =sUnknown_08618158\n"
-        "\tstr r0, [sp]\n"
-        "\tmov r0, r8\n"
-        "\tstr r0, [sp, 0x4]\n"
-        "\tstr r4, [sp, 0x8]\n"
-        "\tmovs r0, 0\n"
-        "\tmovs r1, 0x1\n"
-        "\tmovs r3, 0x2\n"
-        "\tbl box_print\n"
-        "\tmovs r0, 0x2\n"
-        "\tmovs r1, 0x2\n"
-        "\tbl CopyWindowToVram\n"
-        "\tmovs r0, 0x3\n"
-        "\tmovs r1, 0x2\n"
-        "\tbl CopyWindowToVram\n"
-        "\tmovs r0, 0\n"
-        "\tmovs r1, 0x2\n"
-        "\tbl CopyWindowToVram\n"
-        "\tadd sp, 0x10\n"
-        "\tpop {r3}\n"
-        "\tmov r8, r3\n"
-        "\tpop {r4-r6}\n"
-        "\tpop {r0}\n"
-        "\tbx r0\n"
-        "\t.pool\n"
-        ".syntax divided");
-}
-#endif
-
 static int berry_fix_text_update(int checkval)
 {
     if (berry_fix_mb_manager->unk1 == checkval)
@@ -522,7 +318,7 @@ static void berry_fix_text_print(int scene)
     ShowBg(1);
 }
 
-static void berry_fix_bg_hide()
+static void berry_fix_bg_hide(void)
 {
     HideBg(0);
     HideBg(1);

src/berry_tag_screen.c

@@ -0,0 +1,653 @@
+#include "global.h"
+#include "berry_tag_screen.h"
+#include "berry.h"
+#include "decompress.h"
+#include "field_map_obj.h"
+#include "item_menu.h"
+#include "constants/items.h"
+#include "item.h"
+#include "item_use.h"
+#include "main.h"
+#include "menu.h"
+#include "text.h"
+#include "window.h"
+#include "task.h"
+#include "menu_helpers.h"
+#include "palette.h"
+#include "overworld.h"
+#include "constants/songs.h"
+#include "sound.h"
+#include "sprite.h"
+#include "string_util.h"
+#include "strings.h"
+#include "bg.h"
+#include "malloc.h"
+#include "scanline_effect.h"
+#include "gpu_regs.h"
+#include "graphics.h"
+#include "item_menu_icons.h"
+#include "decompress.h"
+#include "international_string_util.h"
+
+// There are 4 windows used in berry tag screen.
+enum
+{
+    WIN_BERRY_NAME,
+    WIN_SIZE_FIRM,
+    WIN_DESC,
+    WIN_BERRY_TAG
+};
+
+struct BerryTagScreenStruct
+{
+    u16 tilemapBuffers[3][0x400];
+    u16 berryId;
+    u8 berrySpriteId;
+    u8 flavorCircleIds[FLAVOR_COUNT];
+    u16 gfxState;
+};
+
+// EWRAM vars
+static EWRAM_DATA struct BerryTagScreenStruct *sBerryTag = NULL;
+
+// const rom data
+static const struct BgTemplate sBackgroundTemplates[] =
+{
+  {
+      .bg = 0,
+      .charBaseIndex = 0,
+      .mapBaseIndex = 31,
+      .screenSize = 0,
+      .paletteMode = 0,
+      .priority = 0,
+      .baseTile = 0
+  },
+  {
+      .bg = 1,
+      .charBaseIndex = 0,
+      .mapBaseIndex = 30,
+      .screenSize = 0,
+      .paletteMode = 0,
+      .priority = 1,
+      .baseTile = 0
+  },
+  {
+      .bg = 2,
+      .charBaseIndex = 0,
+      .mapBaseIndex = 29,
+      .screenSize = 0,
+      .paletteMode = 0,
+      .priority = 2,
+      .baseTile = 0
+  },
+  {
+      .bg = 3,
+      .charBaseIndex = 0,
+      .mapBaseIndex = 28,
+      .screenSize = 0,
+      .paletteMode = 0,
+      .priority = 3,
+      .baseTile = 0
+  }
+};
+
+static const u16 sFontPalette[] = INCBIN_U16("graphics/interface/berry_tag_screen.gbapal");
+
+static const u8 sTextColors[2][3] =
+{
+    {0, 2, 3},
+    {15, 14, 13}
+};
+
+static const struct WindowTemplate sWindowTemplates[] =
+{
+    {0x01, 0x0b, 0x04, 0x08, 0x02, 0x0f, 0x0045}, // WIN_BERRY_NAME
+    {0x01, 0x0b, 0x07, 0x12, 0x04, 0x0f, 0x0055}, // WIN_SIZE_FIRM
+    {0x01, 0x04, 0x0e, 0x19, 0x04, 0x0f, 0x009d}, // WIN_DESC
+    {0x00, 0x02, 0x00, 0x08, 0x02, 0x0f, 0x0101}, // WIN_BERRY_TAG
+    DUMMY_WIN_TEMPLATE
+};
+
+static const u8 *const sBerryFirmnessStrings[] =
+{
+    gBerryFirmnessString_VerySoft,
+    gBerryFirmnessString_Soft,
+    gBerryFirmnessString_Hard,
+    gBerryFirmnessString_VeryHard,
+    gBerryFirmnessString_SuperHard
+};
+
+// this file's functions
+static void CB2_InitBerryTagScreen(void);
+static void HandleInitBackgrounds(void);
+static void HandleInitWindows(void);
+static void AddBerryTagTextToBg0(void);
+static void PrintAllBerryData(void);
+static void CreateBerrySprite(void);
+static void CreateFlavorCircleSprites(void);
+static void SetFlavorCirclesVisiblity(void);
+static void PrintBerryNumberAndName(void);
+static void PrintBerrySize(void);
+static void PrintBerryFirmness(void);
+static void PrintBerryDescription1(void);
+static void PrintBerryDescription2(void);
+static bool8 InitBerryTagScreen(void);
+static bool8 LoadBerryTagGfx(void);
+static void Task_HandleInput(u8 taskId);
+static void Task_CloseBerryTagScreen(u8 taskId);
+static void Task_DisplayAnotherBerry(u8 taskId);
+static void TryChangeDisplayedBerry(u8 taskId, s8 toMove);
+static void HandleBagCursorPositionChange(s8 toMove);
+
+// code
+void DoBerryTagScreen(void)
+{
+    sBerryTag = AllocZeroed(sizeof(*sBerryTag));
+    sBerryTag->berryId = ItemIdToBerryType(gSpecialVar_ItemId);
+    SetMainCallback2(CB2_InitBerryTagScreen);
+}
+
+static void CB2_BerryTagScreen(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    do_scheduled_bg_tilemap_copies_to_vram();
+    UpdatePaletteFade();
+}
+
+static void VblankCB(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static void CB2_InitBerryTagScreen(void)
+{
+    while (1)
+    {
+        if (sub_81221EC() == TRUE)
+            break;
+        if (InitBerryTagScreen() == TRUE)
+            break;
+        if (sub_81221AC() == TRUE)
+            break;
+    }
+}
+
+static bool8 InitBerryTagScreen(void)
+{
+    switch (gMain.state)
+    {
+    case 0:
+        SetVBlankHBlankCallbacksToNull();
+        ResetVramOamAndBgCntRegs();
+        clear_scheduled_bg_copies_to_vram();
+        gMain.state++;
+        break;
+    case 1:
+        ScanlineEffect_Stop();
+        gMain.state++;
+        break;
+    case 2:
+        ResetPaletteFade();
+        gPaletteFade.bufferTransferDisabled = 1;
+        gMain.state++;
+        break;
+    case 3:
+        ResetSpriteData();
+        gMain.state++;
+        break;
+    case 4:
+        FreeAllSpritePalettes();
+        gMain.state++;
+        break;
+    case 5:
+        if (!sub_81221AC())
+            ResetTasks();
+        gMain.state++;
+        break;
+    case 6:
+        HandleInitBackgrounds();
+        sBerryTag->gfxState = 0;
+        gMain.state++;
+        break;
+    case 7:
+        if (LoadBerryTagGfx())
+            gMain.state++;
+        break;
+    case 8:
+        HandleInitWindows();
+        gMain.state++;
+        break;
+    case 9:
+        AddBerryTagTextToBg0();
+        gMain.state++;
+        break;
+    case 10:
+        PrintAllBerryData();
+        gMain.state++;
+        break;
+    case 11:
+        CreateBerrySprite();
+        gMain.state++;
+        break;
+    case 12:
+        CreateFlavorCircleSprites();
+        SetFlavorCirclesVisiblity();
+        gMain.state++;
+        break;
+    case 13:
+        CreateTask(Task_HandleInput, 0);
+        gMain.state++;
+        break;
+    case 14:
+        BlendPalettes(-1, 0x10, 0);
+        gMain.state++;
+        break;
+    case 15:
+        BeginNormalPaletteFade(-1, 0, 0x10, 0, 0);
+        gPaletteFade.bufferTransferDisabled = 0;
+        gMain.state++;
+        break;
+    default: // done
+        SetVBlankCallback(VblankCB);
+        SetMainCallback2(CB2_BerryTagScreen);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static void HandleInitBackgrounds(void)
+{
+    ResetBgsAndClearDma3BusyFlags(0);
+    InitBgsFromTemplates(0, sBackgroundTemplates, ARRAY_COUNT(sBackgroundTemplates));
+    SetBgTilemapBuffer(2, sBerryTag->tilemapBuffers[0]);
+    SetBgTilemapBuffer(3, sBerryTag->tilemapBuffers[1]);
+    ResetAllBgsCoordinates();
+    schedule_bg_copy_tilemap_to_vram(2);
+    schedule_bg_copy_tilemap_to_vram(3);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+    ShowBg(0);
+    ShowBg(1);
+    ShowBg(2);
+    ShowBg(3);
+}
+
+static bool8 LoadBerryTagGfx(void)
+{
+    u16 i;
+
+    switch (sBerryTag->gfxState)
+    {
+    case 0:
+        reset_temp_tile_data_buffers();
+        decompress_and_copy_tile_data_to_vram(2, gUnknown_08D9BB44, 0, 0, 0);
+        sBerryTag->gfxState++;
+        break;
+    case 1:
+        if (free_temp_tile_data_buffers_if_possible() != TRUE)
+        {
+            LZDecompressWram(gUnknown_08D9BF98, sBerryTag->tilemapBuffers[0]);
+            sBerryTag->gfxState++;
+        }
+        break;
+    case 2:
+        LZDecompressWram(gUnknown_08D9C13C, sBerryTag->tilemapBuffers[2]);
+        sBerryTag->gfxState++;
+        break;
+    case 3:
+        if (gSaveBlock2Ptr->playerGender == MALE)
+        {
+            for (i = 0; i < ARRAY_COUNT(sBerryTag->tilemapBuffers[1]); i++)
+                sBerryTag->tilemapBuffers[1][i] = 0x4042;
+        }
+        else
+        {
+            for (i = 0; i < ARRAY_COUNT(sBerryTag->tilemapBuffers[1]); i++)
+                sBerryTag->tilemapBuffers[1][i] = 0x5042;
+        }
+        sBerryTag->gfxState++;
+        break;
+    case 4:
+        LoadCompressedPalette(gUnknown_08D9BEF0, 0, 0xC0);
+        sBerryTag->gfxState++;
+        break;
+    case 5:
+        LoadCompressedObjectPic(&gUnknown_0857FDEC);
+        sBerryTag->gfxState++;
+        break;
+    default:
+        LoadCompressedObjectPalette(&gUnknown_0857FDF4);
+        return TRUE; // done
+    }
+
+    return FALSE;
+}
+
+static void HandleInitWindows(void)
+{
+    u16 i;
+
+    InitWindows(sWindowTemplates);
+    DeactivateAllTextPrinters();
+    LoadPalette(sFontPalette, 0xF0, 0x20);
+    for (i = 0; i < ARRAY_COUNT(sWindowTemplates) - 1; i++)
+        PutWindowTilemap(i);
+    schedule_bg_copy_tilemap_to_vram(0);
+    schedule_bg_copy_tilemap_to_vram(1);
+}
+
+static void PrintTextInBerryTagScreen(u8 windowId, const u8 *text, u8 x, u8 y, s32 speed, u8 colorStructId)
+{
+    AddTextPrinterParameterized2(windowId, 1, x, y, 0, 0, sTextColors[colorStructId], speed, text);
+}
+
+static void AddBerryTagTextToBg0(void)
+{
+    memcpy(GetBgTilemapBuffer(0), sBerryTag->tilemapBuffers[2], sizeof(sBerryTag->tilemapBuffers[2]));
+    FillWindowPixelBuffer(WIN_BERRY_TAG, 0xFF);
+    PrintTextInBerryTagScreen(WIN_BERRY_TAG, gText_BerryTag, GetStringCenterAlignXOffset(1, gText_BerryTag, 0x40), 1, 0, 1);
+    PutWindowTilemap(WIN_BERRY_TAG);
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+static void PrintAllBerryData(void)
+{
+    PrintBerryNumberAndName();
+    PrintBerrySize();
+    PrintBerryFirmness();
+    PrintBerryDescription1();
+    PrintBerryDescription2();
+}
+
+static void PrintBerryNumberAndName(void)
+{
+    const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
+    ConvertIntToDecimalStringN(gStringVar1, sBerryTag->berryId, 2, 2);
+    StringCopy(gStringVar2, berry->name);
+    StringExpandPlaceholders(gStringVar4, gText_UnkF908Var1Var2);
+    PrintTextInBerryTagScreen(WIN_BERRY_NAME, gStringVar4, 0, 1, 0, 0);
+}
+
+static void PrintBerrySize(void)
+{
+    const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
+    PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_SizeSlash, 0, 1, TEXT_SPEED_FF, NULL);
+    if (berry->size != 0)
+    {
+        u32 inches, fraction;
+
+        inches = 1000 * berry->size / 254;
+        if (inches % 10 > 4)
+            inches += 10;
+        fraction = (inches % 100) / 10;
+        inches /= 100;
+
+        ConvertIntToDecimalStringN(gStringVar1, inches, 0, 2);
+        ConvertIntToDecimalStringN(gStringVar2, fraction, 0, 2);
+        StringExpandPlaceholders(gStringVar4, gText_Var1DotVar2);
+        PrintTextOnWindow(WIN_SIZE_FIRM, 1, gStringVar4, 0x28, 1, 0, NULL);
+    }
+    else
+    {
+        PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_ThreeMarks, 0x28, 1, 0, NULL);
+    }
+}
+
+static void PrintBerryFirmness(void)
+{
+    const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
+    PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_FirmSlash, 0, 0x11, TEXT_SPEED_FF, NULL);
+    if (berry->firmness != 0)
+        PrintTextOnWindow(WIN_SIZE_FIRM, 1, sBerryFirmnessStrings[berry->firmness - 1], 0x28, 0x11, 0, NULL);
+    else
+        PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_ThreeMarks, 0x28, 0x11, 0, NULL);
+}
+
+static void PrintBerryDescription1(void)
+{
+    const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
+    PrintTextOnWindow(WIN_DESC, 1, berry->description1, 0, 1, 0, NULL);
+}
+
+static void PrintBerryDescription2(void)
+{
+    const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
+    PrintTextOnWindow(WIN_DESC, 1, berry->description2, 0, 0x11, 0, NULL);
+}
+
+static void CreateBerrySprite(void)
+{
+    sBerryTag->berrySpriteId = CreateBerryTagSprite(sBerryTag->berryId - 1, 56, 64);
+}
+
+static void DestroyBerrySprite(void)
+{
+    DestroySprite(&gSprites[sBerryTag->berrySpriteId]);
+    FreeBerryTagSpritePalette();
+}
+
+static void CreateFlavorCircleSprites(void)
+{
+    sBerryTag->flavorCircleIds[FLAVOR_SPICY] = CreateBerryFlavorCircleSprite(64);
+    sBerryTag->flavorCircleIds[FLAVOR_DRY] = CreateBerryFlavorCircleSprite(104);
+    sBerryTag->flavorCircleIds[FLAVOR_SWEET] = CreateBerryFlavorCircleSprite(144);
+    sBerryTag->flavorCircleIds[FLAVOR_BITTER] = CreateBerryFlavorCircleSprite(184);
+    sBerryTag->flavorCircleIds[FLAVOR_SOUR] = CreateBerryFlavorCircleSprite(224);
+}
+
+static void SetFlavorCirclesVisiblity(void)
+{
+    const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
+
+    if (berry->spicy)
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_SPICY]].invisible = 0;
+    else
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_SPICY]].invisible = 1;
+
+    if (berry->dry)
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_DRY]].invisible = 0;
+    else
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_DRY]].invisible = 1;
+
+    if (berry->sweet)
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_SWEET]].invisible = 0;
+    else
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_SWEET]].invisible = 1;
+
+    if (berry->bitter)
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_BITTER]].invisible = 0;
+    else
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_BITTER]].invisible = 1;
+
+    if (berry->sour)
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_SOUR]].invisible = 0;
+    else
+        gSprites[sBerryTag->flavorCircleIds[FLAVOR_SOUR]].invisible = 1;
+}
+
+static void DestroyFlavorCircleSprites(void)
+{
+    u16 i;
+
+    for (i = 0; i < FLAVOR_COUNT; i++)
+        DestroySprite(&gSprites[sBerryTag->flavorCircleIds[i]]);
+}
+
+static void PrepareToCloseBerryTagScreen(u8 taskId)
+{
+    PlaySE(SE_SELECT);
+    BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
+    gTasks[taskId].func = Task_CloseBerryTagScreen;
+}
+
+static void Task_CloseBerryTagScreen(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        DestroyBerrySprite();
+        DestroyFlavorCircleSprites();
+        Free(sBerryTag);
+        FreeAllWindowBuffers();
+        SetMainCallback2(bag_menu_mail_related);
+        DestroyTask(taskId);
+    }
+}
+
+static void Task_HandleInput(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        u16 arrowKeys = gMain.newAndRepeatedKeys & DPAD_ANY;
+        if (arrowKeys == DPAD_UP)
+            TryChangeDisplayedBerry(taskId, -1);
+        else if (arrowKeys == DPAD_DOWN)
+            TryChangeDisplayedBerry(taskId, 1);
+        else if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+            PrepareToCloseBerryTagScreen(taskId);
+    }
+}
+
+static void TryChangeDisplayedBerry(u8 taskId, s8 toMove)
+{
+    s16 *data = gTasks[taskId].data;
+    s16 currPocketPosition = gUnknown_0203CE58.unk12[3] + gUnknown_0203CE58.unk8[3];
+    u32 newPocketPosition = currPocketPosition + toMove;
+    if (newPocketPosition < 46 && BagGetItemIdByPocketPosition(BAG_BERRIES, newPocketPosition) != 0)
+    {
+        if (toMove < 0)
+            data[1] = 2;
+        else
+            data[1] = 1;
+
+        data[0] = 0;
+        PlaySE(SE_SELECT);
+        HandleBagCursorPositionChange(toMove);
+        gTasks[taskId].func = Task_DisplayAnotherBerry;
+    }
+}
+
+static void HandleBagCursorPositionChange(s8 toMove)
+{
+    u16 *scrollPos = &gUnknown_0203CE58.unk12[3];
+    u16 *cursorPos = &gUnknown_0203CE58.unk8[3];
+    if (toMove > 0)
+    {
+        if (*cursorPos < 4 || BagGetItemIdByPocketPosition(BAG_BERRIES, *scrollPos + 8) == 0)
+            *cursorPos += toMove;
+        else
+            *scrollPos += toMove;
+    }
+    else
+    {
+        if (*cursorPos > 3 || *scrollPos == 0)
+            *cursorPos += toMove;
+        else
+            *scrollPos += toMove;
+    }
+
+    sBerryTag->berryId = ItemIdToBerryType(BagGetItemIdByPocketPosition(BAG_BERRIES, *scrollPos + *cursorPos));
+}
+
+static void Task_DisplayAnotherBerry(u8 taskId)
+{
+    u16 i;
+    s16 posY;
+    s16 *data = gTasks[taskId].data;
+    data[0] += 0x10;
+    data[0] &= 0xFF;
+
+    if (data[1] == 1)
+    {
+        switch (data[0])
+        {
+        case 0x30:
+            FillWindowPixelBuffer(0, 0);
+            break;
+        case 0x40:
+            PrintBerryNumberAndName();
+            break;
+        case 0x50:
+            DestroyBerrySprite();
+            CreateBerrySprite();
+            break;
+        case 0x60:
+            FillWindowPixelBuffer(1, 0);
+            break;
+        case 0x70:
+            PrintBerrySize();
+            break;
+        case 0x80:
+            PrintBerryFirmness();
+            break;
+        case 0x90:
+            SetFlavorCirclesVisiblity();
+            break;
+        case 0xA0:
+            FillWindowPixelBuffer(2, 0);
+            break;
+        case 0xB0:
+            PrintBerryDescription1();
+            break;
+        case 0xC0:
+            PrintBerryDescription2();
+            break;
+        }
+    }
+    else
+    {
+        switch (data[0])
+        {
+        case 0x30:
+            FillWindowPixelBuffer(2, 0);
+            break;
+        case 0x40:
+            PrintBerryDescription2();
+            break;
+        case 0x50:
+            PrintBerryDescription1();
+            break;
+        case 0x60:
+            SetFlavorCirclesVisiblity();
+            break;
+        case 0x70:
+            FillWindowPixelBuffer(1, 0);
+            break;
+        case 0x80:
+            PrintBerryFirmness();
+            break;
+        case 0x90:
+            PrintBerrySize();
+            break;
+        case 0xA0:
+            DestroyBerrySprite();
+            CreateBerrySprite();
+            break;
+        case 0xB0:
+            FillWindowPixelBuffer(0, 0);
+            break;
+        case 0xC0:
+            PrintBerryNumberAndName();
+            break;
+        }
+    }
+
+    if (data[1] == 1)
+        posY = -data[0];
+    else
+        posY = data[0];
+
+    gSprites[sBerryTag->berrySpriteId].pos2.y = posY;
+    for (i = 0; i < FLAVOR_COUNT; i++)
+        gSprites[sBerryTag->flavorCircleIds[i]].pos2.y = posY;
+
+    ChangeBgY(1, 0x1000, data[1]);
+    ChangeBgY(2, 0x1000, data[1]);
+
+    if (data[0] == 0)
+        gTasks[taskId].func = Task_HandleInput;
+}

src/calculate_base_damage.c

@@ -177,7 +177,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de
         damage = damage / damageHelper;
         damage /= 50;
 
-        if ((attacker->status1 & STATUS_BURN) && attacker->ability != ABILITY_GUTS)
+        if ((attacker->status1 & STATUS1_BURN) && attacker->ability != ABILITY_GUTS)
             damage /= 2;
 
         if ((sideStatus & SIDE_STATUS_REFLECT) && gCritMultiplier == 1)

src/coord_event_weather.c

@@ -0,0 +1,119 @@
+#include "global.h"
+#include "constants/weather.h"
+#include "coord_event_weather.h"
+#include "field_weather.h"
+
+struct CoordEventWeather
+{
+    u8 coordEventWeather;
+    void (*func)(void);
+};
+
+static void CoordEventWeather_Clouds(void);
+static void CoordEventWeather_Sunny(void);
+static void CoordEventWeather_LightRain(void);
+static void CoordEventWeather_Snow(void);
+static void CoordEventWeather_Thunderstorm(void);
+static void CoordEventWeather_Fog(void);
+static void CoordEventWeather_DiagonalFog(void);
+static void CoordEventWeather_Ash(void);
+static void CoordEventWeather_Sandstorm(void);
+static void CoordEventWeather_Dark(void);
+static void CoordEventWeather_Drought(void);
+static void CoordEventWeather_Route119Cycle(void);
+static void CoordEventWeather_Route123Cycle(void);
+
+static const struct CoordEventWeather sCoordEventWeatherFuncs[] =
+{
+    { COORD_EVENT_WEATHER_CLOUDS, CoordEventWeather_Clouds },
+    { COORD_EVENT_WEATHER_SUNNY, CoordEventWeather_Sunny },
+    { COORD_EVENT_WEATHER_RAIN_LIGHT, CoordEventWeather_LightRain },
+    { COORD_EVENT_WEATHER_SNOW, CoordEventWeather_Snow },
+    { COORD_EVENT_WEATHER_RAIN_MED, CoordEventWeather_Thunderstorm },
+    { COORD_EVENT_WEATHER_FOG_1, CoordEventWeather_Fog },
+    { COORD_EVENT_WEATHER_FOG_2, CoordEventWeather_DiagonalFog },
+    { COORD_EVENT_WEATHER_ASH, CoordEventWeather_Ash },
+    { COORD_EVENT_WEATHER_SANDSTORM, CoordEventWeather_Sandstorm },
+    { COORD_EVENT_WEATHER_SHADE, CoordEventWeather_Dark },
+    { COORD_EVENT_WEATHER_DROUGHT, CoordEventWeather_Drought },
+    { COORD_EVENT_WEATHER_ROUTE119_CYCLE, CoordEventWeather_Route119Cycle },
+    { COORD_EVENT_WEATHER_ROUTE123_CYCLE, CoordEventWeather_Route123Cycle },
+};
+
+static void CoordEventWeather_Clouds(void)
+{
+    SetWeather(WEATHER_CLOUDS);
+}
+
+static void CoordEventWeather_Sunny(void)
+{
+    SetWeather(WEATHER_SUNNY);
+}
+
+static void CoordEventWeather_LightRain(void)
+{
+    SetWeather(WEATHER_RAIN_LIGHT);
+}
+
+static void CoordEventWeather_Snow(void)
+{
+    SetWeather(WEATHER_SNOW);
+}
+
+static void CoordEventWeather_Thunderstorm(void)
+{
+    SetWeather(WEATHER_RAIN_MED);
+}
+
+static void CoordEventWeather_Fog(void)
+{
+    SetWeather(WEATHER_FOG_1);
+}
+
+static void CoordEventWeather_DiagonalFog(void)
+{
+    SetWeather(WEATHER_FOG_2);
+}
+
+static void CoordEventWeather_Ash(void)
+{
+    SetWeather(WEATHER_ASH);
+}
+
+static void CoordEventWeather_Sandstorm(void)
+{
+    SetWeather(WEATHER_SANDSTORM);
+}
+
+static void CoordEventWeather_Dark(void)
+{
+    SetWeather(WEATHER_SHADE);
+}
+
+static void CoordEventWeather_Drought(void)
+{
+    SetWeather(WEATHER_DROUGHT);
+}
+
+static void CoordEventWeather_Route119Cycle(void)
+{
+    SetWeather(WEATHER_ROUTE119_CYCLE);
+}
+
+static void CoordEventWeather_Route123Cycle(void)
+{
+    SetWeather(WEATHER_ROUTE123_CYCLE);
+}
+
+void DoCoordEventWeather(u8 coordEventWeather)
+{
+    u8 i;
+    for (i = 0; i < ARRAY_COUNT(sCoordEventWeatherFuncs); i++)
+    {
+        if (sCoordEventWeatherFuncs[i].coordEventWeather == coordEventWeather)
+        {
+            sCoordEventWeatherFuncs[i].func();
+            return;
+        }
+    }
+}

src/decoration.c

@@ -529,7 +529,7 @@ void SecretBasePC_PutAway(u8 taskId)
     {
         sub_8126A58(0);
         sub_8197434(0, 0);
-        fade_screen(1, 0);
+        FadeScreen(1, 0);
         gTasks[taskId].data[2] = 0;
         gTasks[taskId].func = sub_8129ABC;
     }
@@ -1247,7 +1247,7 @@ void sub_8127F68(u8 taskId)
     {
         if (sub_8127F38() == TRUE)
         {
-            fade_screen(1, 0);
+            FadeScreen(1, 0);
             gTasks[taskId].data[2] = 0;
             gTasks[taskId].func = sub_8128060;
         }
@@ -1661,7 +1661,7 @@ void sub_8128BA0(u8 taskId)
 
 void sub_8128BBC(u8 taskId)
 {
-    fade_screen(1, 0);
+    FadeScreen(1, 0);
     gTasks[taskId].data[2] = 0;
     gTasks[taskId].func = c1_overworld_prev_quest;
 }
@@ -2013,9 +2013,9 @@ u8 AddDecorationIconObjectFromIconTable(u16 tilesTag, u16 paletteTag, u8 decor)
     {
         return MAX_SPRITES;
     }
-    LZDecompressWram(GetDecorationIconPicOrPalette(decor, 0), gUnknown_0203CEBC);
-    CopyItemIconPicTo4x4Buffer(gUnknown_0203CEBC, gUnknown_0203CEC0);
-    sheet.data = gUnknown_0203CEC0;
+    LZDecompressWram(GetDecorationIconPicOrPalette(decor, 0), gItemIconDecompressionBuffer);
+    CopyItemIconPicTo4x4Buffer(gItemIconDecompressionBuffer, gItemIcon4x4Buffer);
+    sheet.data = gItemIcon4x4Buffer;
     sheet.size = 0x200;
     sheet.tag = tilesTag;
     LoadSpriteSheet(&sheet);
@@ -2023,7 +2023,7 @@ u8 AddDecorationIconObjectFromIconTable(u16 tilesTag, u16 paletteTag, u8 decor)
     palette.tag = paletteTag;
     LoadCompressedObjectPalette(&palette);
     template = malloc(sizeof(struct SpriteTemplate));
-    *template = gUnknown_08614FF4;
+    *template = gItemIconSpriteTemplate;
     template->tileTag = tilesTag;
     template->paletteTag = paletteTag;
     spriteId = CreateSprite(template, 0, 0, 0);
@@ -2635,7 +2635,7 @@ void sub_812A1A0(u8 taskId)
 
 void sub_812A1C0(u8 taskId)
 {
-    fade_screen(1, 0);
+    FadeScreen(1, 0);
     gTasks[taskId].data[2] = 0;
     gTasks[taskId].func = sub_81298EC;
 }
@@ -2654,7 +2654,7 @@ void sub_812A210(u8 taskId)
 
 void sub_812A22C(u8 taskId)
 {
-    fade_screen(1, 0);
+    FadeScreen(1, 0);
     gTasks[taskId].data[2] = 0;
     gTasks[taskId].func = sub_812A25C;
 }

src/diploma.c

@@ -3,7 +3,7 @@
 #include "palette.h"
 #include "main.h"
 #include "gpu_regs.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "task.h"
 #include "malloc.h"
 #include "decompress.h"

src/egg_hatch.c

@@ -61,7 +61,7 @@ extern u8 sav1_map_get_name(void);
 extern s8 ProcessMenuInputNoWrap_(void);
 extern void TVShowConvertInternationalString(u8* str1, u8* str2, u8);
 extern void sub_806A068(u16, u8);
-extern void fade_screen(u8, u8);
+extern void FadeScreen(u8, u8);
 extern void overworld_free_bg_tilemaps(void);
 extern void sub_80AF168(void);
 extern void AllocateMonSpritesGfx(void);
@@ -465,7 +465,7 @@ void EggHatch(void)
 {
     ScriptContext2_Enable();
     CreateTask(Task_EggHatch, 10);
-    fade_screen(1, 0);
+    FadeScreen(1, 0);
 }
 
 static void Task_EggHatch(u8 taskID)

src/evolution_scene.c

@@ -11,7 +11,7 @@
 #include "pokemon.h"
 #include "string_util.h"
 #include "battle.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "decompress.h"
 #include "m4a.h"
 #include "menu.h"
@@ -1367,7 +1367,7 @@ static void VBlankCB_EvolutionScene(void)
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
-    sub_80BA0A8();
+    ScanlineEffect_InitHBlankDmaTransfer();
 }
 
 static void VBlankCB_TradeEvolutionScene(void)
@@ -1384,7 +1384,7 @@ static void VBlankCB_TradeEvolutionScene(void)
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
-    sub_80BA0A8();
+    ScanlineEffect_InitHBlankDmaTransfer();
 }
 
 static void sub_813FDEC(u8 taskId)

src/field_map_obj.c

@@ -14,7 +14,7 @@
 #include "rom_818CFC8.h"
 #include "rom_81BE66C.h"
 #include "field_ground_effect.h"
-#include "map_obj_8097404.h"
+#include "field_map_obj_helpers.h"
 #include "mauville_old_man.h"
 #include "metatile_behavior.h"
 #include "field_effect.h"

src/field_map_obj_helpers.c

@@ -0,0 +1,844 @@
+#include "global.h"
+#include "field_ground_effect.h"
+#include "field_map_obj.h"
+#include "field_effect.h"
+#include "field_map_obj_helpers.h"
+#include "malloc.h"
+#include "task.h"
+#include "util.h"
+
+typedef void (*SpriteStepFunc)(struct Sprite *sprite, u8 dir);
+
+extern const struct Coords16 gUnknown_0850DB7C[4];
+extern s16 gUnknown_0850E768[];
+extern SpriteStepFunc *const gUnknown_0850E754[];
+extern const s8 gUnknown_0850E772[];
+extern const s8 gUnknown_0850E7BA[];
+extern const s8 *const gUnknown_0850E834[];
+extern s16 gUnknown_0850E840[];
+extern u8 gUnknown_0850E846[];
+extern s16 gUnknown_0850E84A[];
+extern u8 gUnknown_0850E850[];
+
+void sub_8097D68(struct Sprite *sprite);
+void sub_8097FE4(u8);
+
+bool8 FreezeMapObject(struct MapObject *mapObject)
+{
+    if (mapObject->mapobj_bit_6 || mapObject->mapobj_bit_8)
+    {
+        return TRUE;
+    }
+    else
+    {
+        mapObject->mapobj_bit_8 = 1;
+        mapObject->mapobj_bit_23 = gSprites[mapObject->spriteId].animPaused;
+        mapObject->mapobj_bit_24 = gSprites[mapObject->spriteId].affineAnimPaused;
+        gSprites[mapObject->spriteId].animPaused = 1;
+        gSprites[mapObject->spriteId].affineAnimPaused = 1;
+        return FALSE;
+    }
+}
+
+void FreezeMapObjects(void)
+{
+    u8 i;
+    for (i = 0; i < MAP_OBJECTS_COUNT; i++)
+        if (gMapObjects[i].active && i != gPlayerAvatar.mapObjectId)
+            FreezeMapObject(&gMapObjects[i]);
+}
+
+void FreezeMapObjectsExceptOne(u8 a1)
+{
+    u8 i;
+    for (i = 0; i < MAP_OBJECTS_COUNT; i++)
+        if (i != a1 && gMapObjects[i].active && i != gPlayerAvatar.mapObjectId)
+            FreezeMapObject(&gMapObjects[i]);
+}
+
+void npc_sync_anim_pause_bits(struct MapObject *mapObject)
+{
+    if (mapObject->active && mapObject->mapobj_bit_8)
+    {
+        mapObject->mapobj_bit_8 = 0;
+        gSprites[mapObject->spriteId].animPaused = mapObject->mapobj_bit_23;
+        gSprites[mapObject->spriteId].affineAnimPaused = mapObject->mapobj_bit_24;
+    }
+}
+
+void UnfreezeMapObjects(void)
+{
+    u8 i;
+    for (i = 0; i < MAP_OBJECTS_COUNT; i++)
+        if (gMapObjects[i].active)
+            npc_sync_anim_pause_bits(&gMapObjects[i]);
+}
+
+void little_step(struct Sprite *sprite, u8 dir)
+{
+    sprite->pos1.x += gUnknown_0850DB7C[dir].x;
+    sprite->pos1.y += gUnknown_0850DB7C[dir].y;
+}
+
+void double_little_steps(struct Sprite *sprite, u8 dir)
+{
+    sprite->pos1.x += 2 * (u16) gUnknown_0850DB7C[dir].x;
+    sprite->pos1.y += 2 * (u16) gUnknown_0850DB7C[dir].y;
+}
+
+void triple_little_steps(struct Sprite *sprite, u8 dir)
+{
+    sprite->pos1.x += 2 * (u16) gUnknown_0850DB7C[dir].x + (u16) gUnknown_0850DB7C[dir].x;
+    sprite->pos1.y += 2 * (u16) gUnknown_0850DB7C[dir].y + (u16) gUnknown_0850DB7C[dir].y;
+}
+
+void quad_little_steps(struct Sprite *sprite, u8 dir)
+{
+    sprite->pos1.x += 4 * (u16) gUnknown_0850DB7C[dir].x;
+    sprite->pos1.y += 4 * (u16) gUnknown_0850DB7C[dir].y;
+}
+
+void oct_little_steps(struct Sprite *sprite, u8 dir)
+{
+    sprite->pos1.x += 8 * (u16) gUnknown_0850DB7C[dir].x;
+    sprite->pos1.y += 8 * (u16) gUnknown_0850DB7C[dir].y;
+}
+
+void oamt_npc_ministep_reset(struct Sprite *sprite, u8 a2, u8 a3)
+{
+    sprite->data[3] = a2;
+    sprite->data[4] = a3;
+    sprite->data[5] = 0;
+}
+
+bool8 obj_npc_ministep(struct Sprite *sprite)
+{
+    if (sprite->data[5] >= gUnknown_0850E768[sprite->data[4]])
+        return FALSE;
+
+    gUnknown_0850E754[sprite->data[4]][sprite->data[5]](sprite, sprite->data[3]);
+
+    sprite->data[5]++;
+
+    if (sprite->data[5] < gUnknown_0850E768[sprite->data[4]])
+        return FALSE;
+
+    return TRUE;
+}
+
+void sub_80976DC(struct Sprite *sprite, u8 a2)
+{
+    sprite->data[3] = a2;
+    sprite->data[4] = 0;
+    sprite->data[5] = 0;
+}
+
+bool8 sub_80976EC(struct Sprite *sprite)
+{
+    if (!(sprite->data[4] & 1))
+    {
+        little_step(sprite, sprite->data[3]);
+        sprite->data[5]++;
+    }
+
+    sprite->data[4]++;
+
+    if (sprite->data[5] > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+// new helper added here in the middle. Perhaps Game Freak kept these organized in alphebetical order or some other heirarchy?
+
+s16 sub_8097728(s16 a1)
+{
+    return gUnknown_0850E7BA[a1];
+}
+
+s16 sub_809773C(s16 a1)
+{
+    return gUnknown_0850E772[a1];
+}
+
+void sub_8097750(struct Sprite *sprite)
+{
+    sprite->data[6] = 0;
+    sprite->data[7] = 0;
+}
+
+bool8 sub_8097758(struct Sprite *sprite)
+{
+    bool8 result = FALSE;
+
+    switch(sprite->data[7])
+    {
+        case 0:
+            sprite->pos2.x += sub_809773C(sprite->data[6]);
+            sprite->pos2.y += sub_8097728(sprite->data[6]);
+            break;
+        case 1:
+            sprite->pos2.x -= sub_809773C(0x47 - sprite->data[6]);
+            sprite->pos2.y += sub_8097728(0x47 - sprite->data[6]);
+            break;
+        case 2:
+            sprite->pos2.x -= sub_809773C(sprite->data[6]);
+            sprite->pos2.y += sub_8097728(sprite->data[6]);
+            break;
+        case 3:
+            sprite->pos2.x += sub_809773C(0x47 - sprite->data[6]);
+            sprite->pos2.y += sub_8097728(0x47 - sprite->data[6]);
+            break;
+    }
+    if(++sprite->data[6] == 0x48)
+    {
+        sprite->data[6] = 0;
+        sprite->data[7]++;
+    }
+    if(sprite->data[7] == 0x4)
+    {
+        sprite->pos2.y = 0;
+        sprite->pos2.x = 0;
+        result = TRUE;
+    }
+    return result;
+}
+
+s16 sub_8097820(s16 a1, u8 a2)
+{
+    return gUnknown_0850E834[a2][a1];
+}
+
+void sub_809783C(struct Sprite *sprite, u8 a2, u8 a3, u8 a4)
+{
+    sprite->data[3] = a2;
+    sprite->data[4] = a3;
+    sprite->data[5] = a4;
+    sprite->data[6] = 0;
+}
+
+u8 sub_809785C(struct Sprite *sprite)
+{
+    s16 v5[3];
+    u8 v6[3];
+    u8 v2;
+
+    memcpy(v5, gUnknown_0850E840, 6); // TODO: get rid of memcpy
+    memcpy(v6, gUnknown_0850E846, 3);
+    v2 = 0;
+
+    if (sprite->data[4])
+        little_step(sprite, sprite->data[3]);
+
+    sprite->pos2.y = sub_8097820(sprite->data[6] >> v6[sprite->data[4]], sprite->data[5]);
+
+    sprite->data[6]++;
+
+    if (sprite->data[6] == (v5[sprite->data[4]] >> 1))
+        v2 = 1;
+
+    if (sprite->data[6] >= v5[sprite->data[4]])
+    {
+        sprite->pos2.y = 0;
+        v2 = -1;
+    }
+
+    return v2;
+}
+
+u8 sub_80978E4(struct Sprite *sprite)
+{
+    s16 v5[3];
+    u8 v6[3];
+    u8 v2;
+
+    memcpy(v5, gUnknown_0850E84A, 6);
+    memcpy(v6, gUnknown_0850E850, 3);
+    v2 = 0;
+
+    if (sprite->data[4] && !(sprite->data[6] & 1))
+        little_step(sprite, sprite->data[3]);
+
+    sprite->pos2.y = sub_8097820(sprite->data[6] >> v6[sprite->data[4]], sprite->data[5]);
+
+    sprite->data[6]++;
+
+    if (sprite->data[6] == (v5[sprite->data[4]] >> 1))
+        v2 = 1;
+
+    if (sprite->data[6] >= v5[sprite->data[4]])
+    {
+        sprite->pos2.y = 0;
+        v2 = -1;
+    }
+
+    return v2;
+}
+
+void SetFieldObjectStepTimer(struct Sprite *sprite, u16 timer)
+{
+    sprite->data[3] = timer;
+}
+
+
+bool8 RunFieldObjectStepTimer(struct Sprite *sprite)
+{
+    sprite->data[3]--;
+
+    if (sprite->data[3] == 0)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void obj_anim_image_set_and_seek(struct Sprite *sprite, u8 a2, u8 a3)
+{
+    sprite->animNum = a2;
+    sprite->animPaused = 0 ;
+    SeekSpriteAnim(sprite, a3);
+}
+
+bool8 sub_80979BC(struct Sprite *sprite)
+{
+    if (sprite->animEnded)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_80979D4(struct Sprite *sprite, bool8 invisible)
+{
+    u16 x, y;
+    s16 x2, y2;
+
+    sprite->invisible = invisible;
+
+    if (sprite->coordOffsetEnabled)
+    {
+        x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX + gSpriteCoordOffsetX;
+        y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY;
+    }
+    else
+    {
+        x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX;
+        y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY;
+    }
+
+    x2 = x - (sprite->centerToCornerVecX >> 1);
+    y2 = y - (sprite->centerToCornerVecY >> 1);
+
+    if ((s16)x > 255 || x2 < -16)
+        sprite->invisible = 1;
+    if ((s16)y > 175 || y2 < -16)
+        sprite->invisible = 1;
+}
+
+void sub_8097AC8(struct Sprite *sprite)
+{
+    sub_8097D68(sprite);
+    SetObjectSubpriorityByZCoord(sprite->data[1], sprite, 1);
+    sub_80979D4(sprite, sprite->data[2]);
+}
+
+void sub_8097AF0(void)
+{
+    int i;
+
+    for(i = 0; i < MAX_SPRITES; i++)
+    {
+        struct Sprite *sprite = &gSprites[i];
+        if(sprite->inUse && sprite->callback == sub_8097AC8)
+            DestroySprite(sprite);
+    }
+}
+
+int sub_8097B2C(u8 var) // this should return a u8, because all that call this shifts to u8, but it wont match because it doesnt shift u8 at the end.
+{
+    int i;
+
+    for(i = 0; i < MAX_SPRITES; i++)
+    {
+        struct Sprite *sprite = &gSprites[i];
+        if(sprite->inUse && sprite->callback == sub_8097AC8 && (u8)sprite->data[0] == var)
+            return i;
+    }
+    return MAX_SPRITES;
+}
+
+void sub_8097B78(u8 var1, u8 var2)
+{
+    u8 spriteId = sub_8097B2C(var1);
+
+    if(spriteId != MAX_SPRITES)
+        StartSpriteAnim(&gSprites[spriteId], FieldObjectDirectionToImageAnimId(var2));
+}
+
+void sub_8097BB4(u8 var1, u8 var2)
+{
+    int spriteId = sub_8097B2C(var1);
+
+    if(spriteId != MAX_SPRITES)
+    {
+        struct Sprite *sprite = &gSprites[spriteId];
+        const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(var2);
+        u16 tileNum = sprite->oam.tileNum;
+
+        sprite->oam = *gfxInfo->oam;
+        sprite->oam.tileNum = tileNum;
+        sprite->oam.paletteNum = gfxInfo->paletteSlot;
+        sprite->images = gfxInfo->images;
+
+        if(gfxInfo->subspriteTables == NULL)
+        {
+            sprite->subspriteTables = NULL;
+            sprite->subspriteTableNum = 0;
+            sprite->subspriteMode = 0;
+        }
+        else
+        {
+            SetSubspriteTables(sprite, gfxInfo->subspriteTables);
+            sprite->subspriteMode = 2;
+        }
+        StartSpriteAnim(sprite, 0);
+    }
+}
+
+void sub_8097C44(u8 var, bool32 var2)
+{
+    u8 spriteId = sub_8097B2C(var);
+
+    if(spriteId == MAX_SPRITES)
+        return;
+
+    if(var2)
+        gSprites[spriteId].data[2] = 1;
+    else
+        gSprites[spriteId].data[2] = 0;
+}
+
+bool32 sub_8097C8C(u8 var)
+{
+    u8 spriteId = sub_8097B2C(var);
+
+    if(spriteId == MAX_SPRITES)
+        return FALSE;
+
+    return (gSprites[spriteId].data[2] == TRUE);
+}
+
+void sub_8097CC4(u8 var1, u8 var2)
+{
+    u8 spriteId = sub_8097B2C(var1);
+
+    if(spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].data[3] = var2;
+        gSprites[spriteId].data[4] = 0;
+    }
+}
+
+void sub_8097CF4(struct Sprite *sprite)
+{
+    switch(sprite->data[4])
+    {
+        case 0:
+            sprite->pos2.y = 0;
+            sprite->data[4]++;
+        case 1:
+            sprite->pos2.y -= 8;
+            if(sprite->pos2.y == -160)
+            {
+                sprite->pos2.y = 0;
+                sprite->data[2] = 1;
+                sprite->data[3] = 0;
+                sprite->data[4] = 0;
+            }
+    }
+}
+
+void sub_8097D30(struct Sprite *sprite)
+{
+    switch(sprite->data[4])
+    {
+        case 0:
+            sprite->pos2.y = -160;
+            sprite->data[4]++;
+        case 1:
+            sprite->pos2.y += 8;
+            if(sprite->pos2.y == 0)
+            {
+                sprite->data[3] = 0;
+                sprite->data[4] = 0;
+            }
+    }
+}
+
+void sub_8097D68(struct Sprite *sprite)
+{
+    switch(sprite->data[3])
+    {
+        case 1:
+            sub_8097D30(sprite);
+            break;
+        case 2:
+            sub_8097CF4(sprite);
+            break;
+        case 0:
+            break;
+        default:
+            sprite->data[3] = 0;
+            break;
+    }
+}
+
+bool32 sub_8097D9C(u8 var)
+{
+    u8 spriteId = sub_8097B2C(var);
+
+    if(spriteId == MAX_SPRITES)
+        return FALSE;
+
+    if(gSprites[spriteId].data[3] != FALSE)
+        return TRUE;
+
+    return FALSE;
+}
+
+u32 oe_exec_and_other_stuff(u8 fieldEffectId, struct MapObject *mapObject)
+{
+    FieldObjectGetLocalIdAndMap(mapObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]);
+    return FieldEffectStart(fieldEffectId);
+}
+
+void DoShadowFieldEffect(struct MapObject *mapObject)
+{
+    if (!mapObject->mapobj_bit_22)
+    {
+        mapObject->mapobj_bit_22 = 1;
+        oe_exec_and_other_stuff(FLDEFF_SHADOW, mapObject);
+    }
+}
+
+void DoRippleFieldEffect(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId);
+    gFieldEffectArguments[0] = sprite->pos1.x;
+    gFieldEffectArguments[1] = sprite->pos1.y + (gfxInfo->height >> 1) - 2;
+    gFieldEffectArguments[2] = 151;
+    gFieldEffectArguments[3] = 3;
+    FieldEffectStart(FLDEFF_RIPPLE);
+}
+
+#ifdef NONMATCHING
+bool32 sub_8097E50(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    bool32 ableToStore = FALSE;
+    if (gUnknown_020375B8 == NULL)
+    {
+        gUnknown_020375B8 = AllocZeroed(0x14);
+        gUnknown_020375B8[0] = mapObject->localId;
+        gUnknown_020375B8[16] = 1;
+        ableToStore = TRUE;
+    }
+    else
+    {
+        u8 i;
+        u8 firstFreeSlot;
+        bool32 found;
+        for (firstFreeSlot = 16, found = FALSE, i = 0; i < 16; i++)
+        {
+            if (firstFreeSlot == 16 && gUnknown_020375B8[i] == 0)
+                firstFreeSlot = i;
+
+            if (gUnknown_020375B8[i] == mapObject->localId)
+            {
+                found = TRUE;
+                break;
+            }
+        }
+
+        if (!found && firstFreeSlot != 16)
+        {
+            gUnknown_020375B8[firstFreeSlot] = mapObject->localId;
+            gUnknown_020375B8[16]++;
+            ableToStore = TRUE; // the nonmatching problem is that ableToStore == TRUE isnt being merged with the above ableToStore = TRUE assignment.
+        }
+    }
+
+    if (ableToStore == TRUE)
+    {
+        mapObject->mapobj_bit_12 = TRUE;
+        mapObject->mapobj_bit_9 = TRUE;
+    }
+
+    sprite->data[2] = 1;
+    return TRUE;
+}
+#else
+__attribute__((naked))
+bool32 sub_8097E50(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    asm(".syntax unified\n\
+    push {r4-r7,lr}\n\
+    mov r7, r8\n\
+    push {r7}\n\
+    adds r4, r0, 0\n\
+    mov r8, r1\n\
+    movs r0, 0\n\
+    mov r12, r0\n\
+    ldr r0, =gUnknown_020375B8\n\
+    ldr r1, [r0]\n\
+    adds r6, r0, 0\n\
+    cmp r1, 0\n\
+    bne _08097E80\n\
+    movs r0, 0x14\n\
+    bl AllocZeroed\n\
+    str r0, [r6]\n\
+    ldrb r1, [r4, 0x8]\n\
+    strb r1, [r0]\n\
+    ldr r1, [r6]\n\
+    movs r0, 0x1\n\
+    strb r0, [r1, 0x10]\n\
+    b _08097ECC\n\
+    .pool\n\
+_08097E80:\n\
+    movs r2, 0x10\n\
+    movs r5, 0\n\
+    movs r1, 0\n\
+    adds r3, r6, 0\n\
+    b _08097E90\n\
+_08097E8A:\n\
+    adds r0, r1, 0x1\n\
+    lsls r0, 24\n\
+    lsrs r1, r0, 24\n\
+_08097E90:\n\
+    cmp r1, 0xF\n\
+    bhi _08097EB2\n\
+    cmp r2, 0x10\n\
+    bne _08097EA4\n\
+    ldr r0, [r3]\n\
+    adds r0, r1\n\
+    ldrb r0, [r0]\n\
+    cmp r0, 0\n\
+    bne _08097EA4\n\
+    adds r2, r1, 0\n\
+_08097EA4:\n\
+    ldr r0, [r3]\n\
+    adds r0, r1\n\
+    ldrb r0, [r0]\n\
+    ldrb r7, [r4, 0x8]\n\
+    cmp r0, r7\n\
+    bne _08097E8A\n\
+    movs r5, 0x1\n\
+_08097EB2:\n\
+    cmp r5, 0\n\
+    bne _08097ECE\n\
+    cmp r2, 0x10\n\
+    beq _08097ECE\n\
+    ldr r0, [r6]\n\
+    adds r0, r2\n\
+    ldrb r1, [r4, 0x8]\n\
+    strb r1, [r0]\n\
+    ldr r1, [r6]\n\
+    ldrb r0, [r1, 0x10]\n\
+    adds r0, 0x1\n\
+    strb r0, [r1, 0x10]\n\
+    movs r0, 0x1\n\
+_08097ECC:\n\
+    mov r12, r0\n\
+_08097ECE:\n\
+    mov r1, r12\n\
+    cmp r1, 0x1\n\
+    bne _08097EE0\n\
+    ldrb r0, [r4, 0x1]\n\
+    movs r1, 0x10\n\
+    orrs r0, r1\n\
+    movs r1, 0x2\n\
+    orrs r0, r1\n\
+    strb r0, [r4, 0x1]\n\
+_08097EE0:\n\
+    movs r0, 0x1\n\
+    mov r7, r8\n\
+    strh r0, [r7, 0x32]\n\
+    pop {r3}\n\
+    mov r8, r3\n\
+    pop {r4-r7}\n\
+    pop {r1}\n\
+    bx r1\n\
+    .syntax divided");
+}
+#endif
+
+// this function is very similar to the above one and I don't want to decompile this one until the above is matching.
+__attribute__((naked))
+bool32 sub_8097EF0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    asm(".syntax unified\n\
+    push {r4-r7,lr}\n\
+    mov r7, r8\n\
+    push {r7}\n\
+    adds r6, r0, 0\n\
+    mov r8, r1\n\
+    movs r0, 0x1\n\
+    strh r0, [r1, 0x32]\n\
+    ldr r5, =gUnknown_020375B8\n\
+    ldr r0, [r5]\n\
+    cmp r0, 0\n\
+    beq _08097F68\n\
+    movs r7, 0\n\
+    adds r0, r6, 0\n\
+    bl sub_8097F78\n\
+    lsls r0, 24\n\
+    lsrs r1, r0, 24\n\
+    cmp r1, 0x10\n\
+    beq _08097F28\n\
+    ldr r0, [r5]\n\
+    adds r0, r1\n\
+    movs r1, 0\n\
+    strb r1, [r0]\n\
+    ldr r1, [r5]\n\
+    ldrb r0, [r1, 0x10]\n\
+    subs r0, 0x1\n\
+    strb r0, [r1, 0x10]\n\
+    movs r7, 0x1\n\
+_08097F28:\n\
+    ldr r0, [r5]\n\
+    ldrb r4, [r0, 0x10]\n\
+    cmp r4, 0\n\
+    bne _08097F36\n\
+    bl Free\n\
+    str r4, [r5]\n\
+_08097F36:\n\
+    cmp r7, 0x1\n\
+    bne _08097F68\n\
+    ldrb r0, [r6, 0x5]\n\
+    bl GetFieldObjectGraphicsInfo\n\
+    ldrb r1, [r0, 0xC]\n\
+    lsls r1, 25\n\
+    lsrs r1, 31\n\
+    lsls r1, 4\n\
+    ldrb r2, [r6, 0x1]\n\
+    movs r0, 0x11\n\
+    negs r0, r0\n\
+    ands r0, r2\n\
+    orrs r0, r1\n\
+    movs r1, 0x3\n\
+    negs r1, r1\n\
+    ands r0, r1\n\
+    strb r0, [r6, 0x1]\n\
+    mov r2, r8\n\
+    adds r2, 0x2C\n\
+    ldrb r1, [r2]\n\
+    movs r0, 0x41\n\
+    negs r0, r0\n\
+    ands r0, r1\n\
+    strb r0, [r2]\n\
+_08097F68:\n\
+    movs r0, 0x1\n\
+    pop {r3}\n\
+    mov r8, r3\n\
+    pop {r4-r7}\n\
+    pop {r1}\n\
+    bx r1\n\
+    .pool\n\
+    .syntax divided");
+}
+
+u8 sub_8097F78(struct MapObject *mapObject)
+{
+    u8 i;
+
+    for(i = 0; i < MAP_OBJECTS_COUNT; i++)
+    {
+        if(gUnknown_020375B8[i] == mapObject->localId)
+            return i;
+    }
+    return MAP_OBJECTS_COUNT;
+}
+
+void sub_8097FA4(struct MapObject *mapObject)
+{
+    u8 taskId = CreateTask(sub_8097FE4, 0xFF);
+    struct Task *task = &gTasks[taskId];
+
+    StoreWordInTwoHalfwords(&task->data[0], (u32)mapObject);
+    mapObject->mapobj_unk_1B = taskId;
+    task->data[3] = 0xFFFF;
+}
+
+void sub_8097FE4(u8 taskId)
+{
+    struct MapObject *mapObject;
+    struct Sprite *sprite;
+    struct Task *task = &gTasks[taskId];
+
+    LoadWordFromTwoHalfwords(&task->data[0], (u32 *)&mapObject); // load the map object pointer.
+    sprite = &gSprites[mapObject->spriteId];
+
+    if(!(task->data[2] & 0x3))
+        sprite->pos2.y += task->data[3];
+
+    if(!(task->data[2] & 0xF))
+        task->data[3] = -task->data[3];
+
+    task->data[2]++;
+}
+
+void sub_8098044(u8 taskId)
+{
+    u32 word;
+    struct Task *task = &gTasks[taskId];
+
+    LoadWordFromTwoHalfwords(&task->data[0], &word); // huh??? why does it load a word that never gets used???
+    DestroyTask(taskId);
+}
+
+void sub_8098074(u8 var1, u8 var2)
+{
+    u8 i;
+
+    for(i = 0; i < MAP_OBJECTS_COUNT; i++)
+    {
+        if(i != var1 && i != var2 &&
+            gMapObjects[i].active && i != gPlayerAvatar.mapObjectId)
+                FreezeMapObject(&gMapObjects[i]);
+    }
+}
+
+bool32 sub_80980C0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    sprite->pos2.y = 0;
+    sprite->data[2]++;
+    return FALSE;
+}
+
+bool32 sub_80980D0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    sprite->pos2.y -= 8;
+
+    if(sprite->pos2.y == -160)
+        sprite->data[2]++;
+    return FALSE;
+}
+
+bool32 sub_80980F4(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    sprite->pos2.y = -160;
+    sprite->data[2]++;
+    return FALSE;
+}
+
+bool32 sub_8098108(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    sprite->pos2.y += 8;
+
+    if(!sprite->pos2.y)
+        sprite->data[2]++;
+    return FALSE;
+}
+
+// though this function returns TRUE without doing anything, this header is required due to being in an array of functions which needs it.
+bool32 sub_8098124(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return TRUE;
+}

src/field_message_box.c

@@ -0,0 +1,155 @@
+#include "global.h"
+#include "menu.h"
+#include "string.h"
+#include "string_util.h"
+#include "task.h"
+#include "text.h"
+#include "battle_frontier_1.h"
+
+EWRAM_DATA u8 gUnknown_020375BC = 0;
+
+void textbox_fdecode_auto_and_task_add(u8*, int);
+void textbox_auto_and_task_add(void);
+
+void sub_8098128(void)
+{
+    gUnknown_020375BC = 0;
+    gTextFlags.flag_0 = 0;
+    gTextFlags.flag_1 = 0;
+    gTextFlags.flag_2 = 0;
+    gTextFlags.flag_3 = 0;
+}
+
+void sub_8098154(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+    
+    switch (task->data[0])
+    {
+        case 0:
+           sub_81973A4();
+           task->data[0]++;
+           break;
+        case 1:
+           NewMenuHelpers_DrawDialogueFrame(0, 1);
+           task->data[0]++;
+           break;
+        case 2:
+            if (sub_8197224() != 1)
+            {
+                gUnknown_020375BC = 0;
+                DestroyTask(taskId);
+            }
+    }
+}
+
+void task_add_textbox(void)
+{
+    CreateTask(sub_8098154, 0x50);
+}
+
+void task_del_textbox(void)
+{
+    u8 taskId = FindTaskIdByFunc(sub_8098154);
+    if (taskId != 0xFF)
+        DestroyTask(taskId);
+}
+
+bool8 ShowFieldMessage(u8 *str)
+{
+    if (gUnknown_020375BC != 0)
+        return FALSE;
+    textbox_fdecode_auto_and_task_add(str, 1);
+    gUnknown_020375BC = 2;
+    return TRUE; 
+}
+
+void sub_8098214(u8 taskId)
+{
+    if (sub_8196094() == 0)
+    {
+        gUnknown_020375BC = 0;
+        DestroyTask(taskId);
+    }
+}
+
+bool8 sub_8098238(u8 *str)
+{
+    if (gUnknown_020375BC != 0)
+        return FALSE;
+    StringExpandPlaceholders(gStringVar4, str);
+    CreateTask(sub_8098214, 0);
+    sub_8196080(str);
+    gUnknown_020375BC = 2;
+    return TRUE;
+}
+
+bool8 ShowFieldAutoScrollMessage(u8 *str)
+{
+    if (gUnknown_020375BC != 0)
+        return FALSE;
+    gUnknown_020375BC = 3;
+    textbox_fdecode_auto_and_task_add(str, 0);
+    return TRUE;
+}
+
+bool8 sub_80982A0(u8 *str)
+{
+    gUnknown_020375BC = 3;
+    textbox_fdecode_auto_and_task_add(str, 1);
+    return TRUE;
+}
+
+bool8 sub_80982B8(void)
+{
+    if (gUnknown_020375BC != 0)
+        return FALSE;
+    gUnknown_020375BC = 2;
+    textbox_auto_and_task_add();
+    return TRUE;
+}
+
+void textbox_fdecode_auto_and_task_add(u8* str, int a)
+{
+    StringExpandPlaceholders(gStringVar4, str);
+    AddTextPrinterForMessage(a);
+    task_add_textbox();
+}
+
+void textbox_auto_and_task_add(void)
+{
+    AddTextPrinterForMessage(1);
+    task_add_textbox();
+}
+
+void HideFieldMessageBox(void)
+{
+    task_del_textbox();
+    sub_8197434(0, 1);
+    gUnknown_020375BC = 0;
+}
+
+u8 textbox_any_visible(void)
+{
+    return gUnknown_020375BC;
+}
+
+bool8 IsFieldMessageBoxHidden(void)
+{
+    if (gUnknown_020375BC == 0)
+        return TRUE;
+    return FALSE;
+}
+
+void sub_8098358(void)
+{
+    task_del_textbox();
+    NewMenuHelpers_DrawStdWindowFrame(0, 1);
+    gUnknown_020375BC = 0;
+}
+
+void sub_8098374(void)
+{
+    task_del_textbox();
+    gUnknown_020375BC = 0;
+}

src/field_poison.c

@@ -42,7 +42,7 @@ static bool32 sub_80F958C(void)
 static void sub_80F95C0(u8 partyIdx)
 {
     struct Pokemon *pokemon = gPlayerParty + partyIdx;
-    unsigned int status = STATUS_NONE;
+    unsigned int status = STATUS1_NONE;
     AdjustFriendship(pokemon, 0x07);
     SetMonData(pokemon, MON_DATA_STATUS, &status);
     GetMonData(pokemon, MON_DATA_NICKNAME, gStringVar1);

src/hall_of_fame.c

@@ -20,11 +20,12 @@
 #include "string_util.h"
 #include "m4a.h"
 #include "international_string_util.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "trig.h"
 #include "random.h"
 #include "event_data.h"
 #include "overworld.h"
+#include "menu.h"
 
 struct HallofFameMon
 {
@@ -53,7 +54,6 @@ static EWRAM_DATA struct HofGfx *sHofGfxPtr = NULL;
 
 extern bool8 gHasHallOfFameRecords;
 extern u32 gUnknown_0203BCD4;
-extern u8 gDecompressionBuffer[];
 extern struct MusicPlayerInfo gMPlayInfo_BGM;
 extern MainCallback gGameContinueCallback;
 extern u32 gDamagedSaveSectors;

src/item_icon.c

@@ -0,0 +1,169 @@
+#include "global.h"
+#include "item_icon.h"
+#include "malloc.h"
+#include "sprite.h"
+#include "decompress.h"
+#include "constants/items.h"
+
+// EWRAM vars
+EWRAM_DATA void *gItemIconDecompressionBuffer = NULL;
+EWRAM_DATA void *gItemIcon4x4Buffer = NULL;
+
+// const rom data
+extern const void *const gItemIconTable[][2]; // todo: move to C file
+
+static const struct OamData sOamData_ItemIcon =
+{
+    .y = 0,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 0,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 2,
+    .tileNum = 0,
+    .priority = 1,
+    .paletteNum = 2,
+    .affineParam = 0
+};
+
+static const union AnimCmd sSpriteAnim_ItemIcon[] =
+{
+    ANIMCMD_FRAME(0, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_ItemIcon[] =
+{
+    sSpriteAnim_ItemIcon
+};
+
+const struct SpriteTemplate gItemIconSpriteTemplate =
+{
+    .tileTag = 0,
+    .paletteTag = 0,
+    .oam = &sOamData_ItemIcon,
+    .anims = sSpriteAnimTable_ItemIcon,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+// code
+bool8 AllocItemIconTemporaryBuffers(void)
+{
+    gItemIconDecompressionBuffer = gItemIconDecompressionBuffer; // needed to match
+    gItemIconDecompressionBuffer = Alloc(0x120);
+    if (gItemIconDecompressionBuffer == NULL)
+        return FALSE;
+
+    gItemIcon4x4Buffer = gItemIcon4x4Buffer; // needed to match
+    gItemIcon4x4Buffer = AllocZeroed(0x200);
+    if (gItemIcon4x4Buffer == NULL)
+    {
+        Free(gItemIconDecompressionBuffer);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+void FreeItemIconTemporaryBuffers(void)
+{
+    Free(gItemIconDecompressionBuffer);
+    Free(gItemIcon4x4Buffer);
+}
+
+void CopyItemIconPicTo4x4Buffer(const void *src, void *dest)
+{
+    u8 i;
+
+    for (i = 0; i < 3; i++)
+        CpuCopy16(src + i * 96, dest + i * 128, 0x60);
+}
+
+u8 AddItemIconSprite(u16 tilesTag, u16 paletteTag, u16 itemId)
+{
+    if (!AllocItemIconTemporaryBuffers())
+    {
+        return MAX_SPRITES;
+    }
+    else
+    {
+        u8 spriteId;
+        struct SpriteSheet spriteSheet;
+        struct CompressedSpritePalette spritePalette;
+        struct SpriteTemplate *spriteTemplate;
+
+        LZDecompressWram(GetItemIconPicOrPalette(itemId, 0), gItemIconDecompressionBuffer);
+        CopyItemIconPicTo4x4Buffer(gItemIconDecompressionBuffer, gItemIcon4x4Buffer);
+        spriteSheet.data = gItemIcon4x4Buffer;
+        spriteSheet.size = 0x200;
+        spriteSheet.tag = tilesTag;
+        LoadSpriteSheet(&spriteSheet);
+
+        spritePalette.data = GetItemIconPicOrPalette(itemId, 1);
+        spritePalette.tag = paletteTag;
+        LoadCompressedObjectPalette(&spritePalette);
+
+        spriteTemplate = Alloc(sizeof(*spriteTemplate));
+        CpuCopy16(&gItemIconSpriteTemplate, spriteTemplate, sizeof(*spriteTemplate));
+        spriteTemplate->tileTag = tilesTag;
+        spriteTemplate->paletteTag = paletteTag;
+        spriteId = CreateSprite(spriteTemplate, 0, 0, 0);
+
+        FreeItemIconTemporaryBuffers();
+        Free(spriteTemplate);
+
+        return spriteId;
+    }
+}
+
+u8 AddCustomItemIconSprite(struct SpriteTemplate *customSpriteTemplate, u16 tilesTag, u16 paletteTag, u16 itemId)
+{
+    if (!AllocItemIconTemporaryBuffers())
+    {
+        return MAX_SPRITES;
+    }
+    else
+    {
+        u8 spriteId;
+        struct SpriteSheet spriteSheet;
+        struct CompressedSpritePalette spritePalette;
+        struct SpriteTemplate *spriteTemplate;
+
+        LZDecompressWram(GetItemIconPicOrPalette(itemId, 0), gItemIconDecompressionBuffer);
+        CopyItemIconPicTo4x4Buffer(gItemIconDecompressionBuffer, gItemIcon4x4Buffer);
+        spriteSheet.data = gItemIcon4x4Buffer;
+        spriteSheet.size = 0x200;
+        spriteSheet.tag = tilesTag;
+        LoadSpriteSheet(&spriteSheet);
+
+        spritePalette.data = GetItemIconPicOrPalette(itemId, 1);
+        spritePalette.tag = paletteTag;
+        LoadCompressedObjectPalette(&spritePalette);
+
+        spriteTemplate = Alloc(sizeof(*spriteTemplate));
+        CpuCopy16(customSpriteTemplate, spriteTemplate, sizeof(*spriteTemplate));
+        spriteTemplate->tileTag = tilesTag;
+        spriteTemplate->paletteTag = paletteTag;
+        spriteId = CreateSprite(spriteTemplate, 0, 0, 0);
+
+        FreeItemIconTemporaryBuffers();
+        Free(spriteTemplate);
+
+        return spriteId;
+    }
+}
+
+const void *GetItemIconPicOrPalette(u16 itemId, u8 which)
+{
+    if (itemId == 0xFFFF)
+        itemId = ITEM_FIELD_ARROW;
+    else if (itemId > ITEM_LAST_ID)
+        itemId = 0;
+
+    return gItemIconTable[itemId][which];
+}

src/mail.c

@@ -4,7 +4,7 @@
 #include "main.h"
 #include "overworld.h"
 #include "task.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "palette.h"
 #include "text.h"
 #include "menu.h"

src/mystery_event_menu.c

@@ -0,0 +1,302 @@
+#include "global.h"
+#include "mystery_event_menu.h"
+#include "link.h"
+#include "main.h"
+#include "menu.h"
+#include "mystery_event_script.h"
+#include "palette.h"
+#include "save.h"
+#include "constants/songs.h"
+#include "sound.h"
+#include "sprite.h"
+#include "string_util.h"
+#include "strings.h"
+#include "task.h"
+#include "text.h"
+#include "bg.h"
+#include "window.h"
+#include "gpu_regs.h"
+#include "text_window.h"
+#include "decompress.h"
+
+// this file's functions
+static void CB2_MysteryEventMenu(void);
+static void PrintMysteryMenuText(u8 windowId, const u8 *text, u8 x, u8 y, s32 speed);
+
+// EWRAM vars
+static EWRAM_DATA u8 sUnknown_0203BCF8 = 0; // set but unused
+
+// const rom data
+static const struct BgTemplate sBgTemplates[] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0
+    }
+};
+
+static const struct WindowTemplate sWindowTemplates[] =
+{
+    {0, 4, 15, 22, 4, 14, 20},
+    {0, 7, 6, 16, 4, 14, 0x6C},
+    DUMMY_WIN_TEMPLATE
+};
+
+// code
+static void VBlankCB(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static bool8 CheckLanguageMatch(void)
+{
+    return (gLinkPlayers[0].language == gLinkPlayers[1].language);
+}
+
+void CB2_InitMysteryEventMenu(void)
+{
+    ResetSpriteData();
+    FreeAllSpritePalettes();
+    ResetTasks();
+    SetVBlankCallback(VBlankCB);
+    ResetBgsAndClearDma3BusyFlags(0);
+    InitBgsFromTemplates(0, sBgTemplates, ARRAY_COUNT(sBgTemplates));
+    if (InitWindows(sWindowTemplates))
+    {
+        s32 i;
+
+        DeactivateAllTextPrinters();
+        for (i = 0; i < 2; i++)
+            FillWindowPixelBuffer(i, 0);
+
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x1E, 0x14);
+        sub_809882C(0, 1u, 0xD0u);
+        sub_81978B0(0xE0);
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON);
+        SetGpuReg(REG_OFFSET_BLDCNT, 0);
+        CreateTask(Task_DestroySelf, 0);
+        StopMapMusic();
+        RunTasks();
+        AnimateSprites();
+        BuildOamBuffer();
+        RunTextPrinters();
+        UpdatePaletteFade();
+        FillPalette(0, 0, 2);
+        SetMainCallback2(CB2_MysteryEventMenu);
+    }
+}
+
+static bool8 GetEventLoadMessage(u8 *dest, u32 status)
+{
+    bool8 retVal = TRUE;
+
+    if (status == 0)
+    {
+        StringCopy(dest, gText_EventSafelyLoaded);
+        retVal = FALSE;
+    }
+
+    if (status == 2)
+        retVal = FALSE;
+
+    if (status == 1)
+        StringCopy(dest, gText_LoadErrorEndingSession);
+
+    return retVal;
+}
+
+static void CB2_MysteryEventMenu(void)
+{
+    switch (gMain.state)
+    {
+    case 0:
+        SetWindowBorderStyle(0, 1, 1, 0xD);
+        PutWindowTilemap(0);
+        CopyWindowToVram(0, 3);
+        ShowBg(0);
+        BeginNormalPaletteFade(-1, 0, 0x10, 0, 0);
+        gMain.state++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+        {
+            PrintMysteryMenuText(0, gText_LinkStandby2, 1, 2, 1);
+            gMain.state++;
+        }
+        break;
+    case 2:
+        if (!IsTextPrinterActive(0))
+        {
+            gMain.state++;
+            gLinkType = 21761;
+            OpenLink();
+        }
+        break;
+    case 3:
+        if ((gLinkStatus & 0x20) && (gLinkStatus & 0x1C) > 4)
+        {
+            PlaySE(SE_PIN);
+            PrintMysteryMenuText(0, gText_PressAToLoadEvent, 1, 2, 1);
+            gMain.state++;
+        }
+        if (gMain.newKeys & B_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            CloseLink();
+            gMain.state = 15;
+        }
+        break;
+    case 4:
+        if (!IsTextPrinterActive(0))
+            gMain.state++;
+        break;
+    case 5:
+        if (GetLinkPlayerCount_2() == 2)
+        {
+            if (gMain.newKeys & A_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                sub_800A620();
+                SetWindowBorderStyle(1, 1, 1, 0xD);
+                PrintMysteryMenuText(1, gText_LoadingEvent, 1, 2, 0);
+                PutWindowTilemap(1);
+                CopyWindowToVram(1, 3);
+                gMain.state++;
+            }
+            else if (gMain.newKeys & B_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                CloseLink();
+                gMain.state = 15;
+            }
+        }
+        else
+        {
+            GetEventLoadMessage(gStringVar4, 1);
+            PrintMysteryMenuText(0, gStringVar4, 1, 2, 1);
+            gMain.state = 13;
+        }
+        break;
+    case 6:
+        if (IsLinkConnectionEstablished())
+        {
+            if (gReceivedRemoteLinkPlayers != 0)
+            {
+                if (sub_800A0C8(2, 2) == 3)
+                {
+                    sub_800AC34();
+                    GetEventLoadMessage(gStringVar4, 1);
+                    PrintMysteryMenuText(0, gStringVar4, 1, 2, 1);
+                    gMain.state = 13;
+                }
+                else if (CheckLanguageMatch())
+                {
+                    PrintMysteryMenuText(0, gText_DontRemoveCableTurnOff, 1, 2, 1);
+                    gMain.state++;
+                }
+                else
+                {
+                    CloseLink();
+                    GetEventLoadMessage(gStringVar4, 1);
+                    PrintMysteryMenuText(0, gStringVar4, 1, 2, 1);
+                    gMain.state = 13;
+                }
+            }
+        }
+        else if (gMain.newKeys & B_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            CloseLink();
+            gMain.state = 15;
+        }
+        break;
+    case 7:
+        if (!IsTextPrinterActive(0))
+            gMain.state++;
+        break;
+    case 8:
+        if (GetBlockReceivedStatus())
+        {
+            ResetBlockReceivedFlags();
+            gMain.state++;
+        }
+        break;
+    case 9:
+        gMain.state++;
+        break;
+    case 10:
+        sub_800AC34();
+        gMain.state++;
+        break;
+    case 11:
+        if (gReceivedRemoteLinkPlayers == 0)
+        {
+            u16 unkVal = RunMysteryEventScript(gDecompressionBuffer);
+            CpuFill32(0, gDecompressionBuffer, 0x7D4);
+            if (!GetEventLoadMessage(gStringVar4, unkVal))
+                TrySavingData(NORMAL_SAVE);
+            gMain.state++;
+        }
+        break;
+    case 12:
+        PrintMysteryMenuText(0, gStringVar4, 1, 2, 1);
+        gMain.state++;
+        break;
+    case 13:
+        if (!IsTextPrinterActive(0))
+        {
+            gMain.state++;
+            sUnknown_0203BCF8 = 0;
+        }
+        break;
+    case 14:
+        if (gMain.newKeys & A_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            gMain.state++;
+        }
+        break;
+    case 15:
+        BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
+        gMain.state++;
+        break;
+    case 16:
+        if (!gPaletteFade.active)
+            DoSoftReset();
+        break;
+    }
+
+    if (gLinkStatus & 0x40 && !IsLinkMaster())
+    {
+        CloseLink();
+        GetEventLoadMessage(gStringVar4, 1);
+        PrintMysteryMenuText(0, gStringVar4, 1, 2, 1);
+        gMain.state = 13;
+    }
+
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    RunTextPrinters();
+    UpdatePaletteFade();
+}
+
+static void PrintMysteryMenuText(u8 windowId, const u8 *text, u8 x, u8 y, s32 speed)
+{
+    u8 textColor[3];
+    u8 letterSpacing = 0;
+    u8 lineSpacing = 1;
+    textColor[0] = 1;
+    textColor[1] = 2;
+    textColor[2] = 3;
+
+    FillWindowPixelBuffer(windowId, (textColor[0]) | (textColor[0] << 4));
+    AddTextPrinterParameterized2(windowId, 1, x, y, letterSpacing, lineSpacing, textColor, speed, text);
+}

src/option_menu.c

@@ -2,7 +2,7 @@
 #include "option_menu.h"
 #include "main.h"
 #include "menu.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "palette.h"
 #include "sprite.h"
 #include "task.h"

src/palette.c

@@ -4,6 +4,7 @@
 #include "decompress.h"
 #include "gpu_regs.h"
 #include "task.h"
+#include "constants/rgb.h"
 
 enum
 {
@@ -839,289 +840,94 @@ void BlendPalettesUnfaded(u32 selectedPalettes, u8 coeff, u16 color)
 
 void TintPalette_GrayScale(u16 *palette, u16 count)
 {
-    int r;
-    int g;
-    int b;
+    s32 r, g, b, i;
     u32 gray;
 
-    int i;
     for (i = 0; i < count; i++)
     {
-        r = *palette & 0x1F;
-        g = (*palette >> 5) & 0x1F;
+        r = (*palette >>  0) & 0x1F;
+        g = (*palette >>  5) & 0x1F;
         b = (*palette >> 10) & 0x1F;
 
-        r = r * Q_8_8(0.2969);
-        r += g * Q_8_8(0.5899);
-        r += b * Q_8_8(0.1133);
+        gray = (r * Q_8_8(0.3) + g * Q_8_8(0.59) + b * Q_8_8(0.1133)) >> 8;
 
-        gray = r >> 8;
-
-        *palette++ = gray << 10 | gray << 5 | gray;
+        *palette++ = (gray << 10) | (gray << 5) | (gray << 0);
     }
 }
 
 void TintPalette_GrayScale2(u16 *palette, u16 count)
 {
-    int r;
-    int g;
-    int b;
+    s32 r, g, b, i;
     u32 gray;
 
-    int i;
     for (i = 0; i < count; i++)
     {
-        r = *palette & 0x1F;
-        g = (*palette >> 5) & 0x1F;
+        r = (*palette >>  0) & 0x1F;
+        g = (*palette >>  5) & 0x1F;
         b = (*palette >> 10) & 0x1F;
 
-        r = r * Q_8_8(0.2969);
-        r += g * Q_8_8(0.5899);
-        r += b * Q_8_8(0.1133);
-
-        gray = r >> 8;
+        gray = (r * Q_8_8(0.3) + g * Q_8_8(0.59) + b * Q_8_8(0.1133)) >> 8;
 
         if (gray > 0x1F)
             gray = 0x1F;
 
         gray = sRoundedDownGrayscaleMap[gray];
 
-        *palette++ = gray << 10 | gray << 5 | gray;
+        *palette++ = (gray << 10) | (gray << 5) | (gray << 0);
     }
 }
 
-#ifdef NONMATCHING
 void TintPalette_SepiaTone(u16 *palette, u16 count)
 {
-    int red;
-    int green;
-    int blue;
+    s32 r, g, b, i;
     u32 gray;
-    u32 sepia;
-    s8 r2;
-    s8 g2;
-    s8 b2;
-
-    int i;
+    
     for (i = 0; i < count; i++)
     {
-        r = *palette & 0x1F;
-        g = (*palette >> 5) & 0x1F;
+        r = (*palette >>  0) & 0x1F;
+        g = (*palette >>  5) & 0x1F;
         b = (*palette >> 10) & 0x1F;
 
-        r *= 0x4C;
-        r += g * 0x97;
-        r += b * 0x1D;
+        gray = (r * Q_8_8(0.3) + g * Q_8_8(0.59) + b * Q_8_8(0.1133)) >> 8;
 
-        gray = (s32)(r >> 8);
+        r = (u16)((Q_8_8(1.2) * gray)) >> 8;
+        g = (u16)((Q_8_8(1.0) * gray)) >> 8;
+        b = (u16)((Q_8_8(0.94) * gray)) >> 8;
 
-        sepia = (gray * 0x133);
+        if (r > 31)
+            r = 31;
 
-        r2 = (u16)sepia >> 8;
-
-        g2 = gray;
-
-        b2 = (gray * 15);
-
-        if (r2 > 0x1F)
-            r2 = 0x1F;
-
-        *palette++ = b2 << 10 | g2 << 5 | r2;
+        *palette++ = (b << 10) | (g << 5) | (r << 0);
     }
 }
-#else
-__attribute__((naked))
-void TintPalette_SepiaTone(u16 *palette, u16 count)
-{
-    asm("push {r4-r7,lr}\n\
-    add r5, r0, #0\n\
-    lsl r1, #16\n\
-    lsr r1, #16\n\
-    cmp r1, #0\n\
-    beq _080A2BA2\n\
-    mov r7, #0x1F\n\
-    add r6, r1, #0\n\
-_080A2B50:\n\
-    ldrh r0, [r5]\n\
-    mov r1, #0x1F\n\
-    and r1, r0\n\
-    lsl r0, #16\n\
-    lsr r2, r0, #21\n\
-    and r2, r7\n\
-    lsr r3, r0, #26\n\
-    and r3, r7\n\
-    mov r0, #0x4C\n\
-    mul r1, r0\n\
-    mov r0, #0x97\n\
-    mul r0, r2\n\
-    add r1, r0\n\
-    lsl r0, r3, #3\n\
-    sub r0, r3\n\
-    lsl r0, #2\n\
-    add r0, r3\n\
-    add r1, r0\n\
-    asr r1, #8\n\
-    ldr r0, =0x00000133\n\
-    mul r0, r1\n\
-    lsl r0, #16\n\
-    lsr r2, r0, #24\n\
-    lsl r0, r1, #24\n\
-    lsr r4, r0, #24\n\
-    lsl r0, r1, #4\n\
-    sub r0, r1\n\
-    lsl r0, #20\n\
-    lsr r3, r0, #24\n\
-    cmp r2, #0x1F\n\
-    ble _080A2B90\n\
-    mov r2, #0x1F\n\
-_080A2B90:\n\
-    lsl r0, r3, #10\n\
-    lsl r1, r4, #5\n\
-    orr r0, r1\n\
-    orr r0, r2\n\
-    strh r0, [r5]\n\
-    add r5, #0x2\n\
-    sub r6, #0x1\n\
-    cmp r6, #0\n\
-    bne _080A2B50\n\
-_080A2BA2:\n\
-    pop {r4-r7}\n\
-    pop {r0}\n\
-    bx r0\n\
-    .pool");
-}
-#endif // NONMATCHING
 
-#ifdef NONMATCHING
-void TintPalette_CustomTone(u16 *palette, u16 count, u16 a3, u16 a4, u16 a5)
+void TintPalette_CustomTone(u16 *palette, u16 count, u16 rTone, u16 gTone, u16 bTone)
 {
-    s32 r;
-    s32 g;
-    s32 b;
-    s32 gray;
-    u8 r2;
-    u8 g2;
-    u8 b2;
+    s32 r, g, b, i;
+    u32 gray;
 
-    int i;
     for (i = 0; i < count; i++)
     {
-        r = *palette & 0x1F;
-        g = (*palette >> 5) & 0x1F;
+        r = (*palette >>  0) & 0x1F;
+        g = (*palette >>  5) & 0x1F;
         b = (*palette >> 10) & 0x1F;
 
-        r *= 0x4C;
-        r += g * 0x97;
-        r += b * 0x1D;
+        gray = (r * Q_8_8(0.3) + g * Q_8_8(0.59) + b * Q_8_8(0.1133)) >> 8;
 
-        gray = r >> 8;
+        r = (u16)((rTone * gray)) >> 8;
+        g = (u16)((gTone * gray)) >> 8;
+        b = (u16)((bTone * gray)) >> 8;
 
-        r2 = (u16)(gray * a3) >> 8;
+        if (r > 31)
+            r = 31;
+        if (g > 31)
+            g = 31;
+        if (b > 31)
+            b = 31;
 
-        g2 = (u16)(gray * a4) >> 8;
-
-        b2 = (u16)(gray * a5) >> 8;
-
-        if (r2 > 0x1F)
-            r2 = 0x1F;
-
-        if (g2 > 0x1F)
-            g2 = 0x1F;
-
-        if (b2 > 0x1F)
-            b2 = 0x1F;
-
-        *palette++ = b2 << 10 | g2 << 5 | r2;
+        *palette++ = (b << 10) | (g << 5) | (r << 0);
     }
-    return;
 }
-#else
-__attribute__((naked))
-void TintPalette_CustomTone(u16 *palette, u16 count, u16 a3, u16 a4, u16 a5)
-{
-    asm("push {r4-r7,lr}\n\
-    mov r7, r9\n\
-    mov r6, r8\n\
-    push {r6,r7}\n\
-    add r5, r0, #0\n\
-    ldr r0, [sp, #0x1C]\n\
-    lsl r1, #16\n\
-    lsr r1, #16\n\
-    lsl r2, #16\n\
-    lsr r2, #16\n\
-    mov r9, r2\n\
-    lsl r3, #16\n\
-    lsr r3, #16\n\
-    mov r8, r3\n\
-    lsl r0, #16\n\
-    lsr r0, #16\n\
-    mov r12, r0\n\
-    cmp r1, #0\n\
-    beq _080A2C38\n\
-    mov r7, #0x1F\n\
-    add r6, r1, #0\n\
-_080A2BD6:\n\
-    ldrh r0, [r5]\n\
-    mov r1, #0x1F\n\
-    and r1, r0\n\
-    lsl r0, #16\n\
-    lsr r2, r0, #21\n\
-    and r2, r7\n\
-    lsr r3, r0, #26\n\
-    and r3, r7\n\
-    mov r0, #0x4C\n\
-    mul r1, r0\n\
-    mov r0, #0x97\n\
-    mul r0, r2\n\
-    add r1, r0\n\
-    lsl r0, r3, #3\n\
-    sub r0, r3\n\
-    lsl r0, #2\n\
-    add r0, r3\n\
-    add r1, r0\n\
-    asr r1, #8\n\
-    mov r0, r9\n\
-    mul r0, r1\n\
-    lsl r0, #16\n\
-    lsr r4, r0, #24\n\
-    mov r0, r8\n\
-    mul r0, r1\n\
-    lsl r0, #16\n\
-    lsr r2, r0, #24\n\
-    mov r0, r12\n\
-    mul r0, r1\n\
-    lsl r0, #16\n\
-    lsr r3, r0, #24\n\
-    cmp r4, #0x1F\n\
-    ble _080A2C1A\n\
-    mov r4, #0x1F\n\
-_080A2C1A:\n\
-    cmp r2, #0x1F\n\
-    ble _080A2C20\n\
-    mov r2, #0x1F\n\
-_080A2C20:\n\
-    cmp r3, #0x1F\n\
-    ble _080A2C26\n\
-    mov r3, #0x1F\n\
-_080A2C26:\n\
-    lsl r0, r3, #10\n\
-    lsl r1, r2, #5\n\
-    orr r0, r1\n\
-    orr r0, r4\n\
-    strh r0, [r5]\n\
-    add r5, #0x2\n\
-    sub r6, #0x1\n\
-    cmp r6, #0\n\
-    bne _080A2BD6\n\
-_080A2C38:\n\
-    pop {r3,r4}\n\
-    mov r8, r3\n\
-    mov r9, r4\n\
-    pop {r4-r7}\n\
-    pop {r0}\n\
-    bx r0");
-}
-#endif
 
 void sub_80A2C44(u32 a1, s8 a2, u8 a3, u8 a4, u16 a5, u8 a6, u8 a7)
 {

src/pokeball.c

@@ -16,11 +16,11 @@
 #include "graphics.h"
 
 extern bool8 gDoingBattleAnim;
-extern u8 gActiveBank;
-extern u8 gBankTarget;
-extern u16 gBattlePartyID[];
-extern u8 gBankSpriteIds[];
-extern u8 gHealthBoxesIds[];
+extern u8 gActiveBattler;
+extern u8 gBattlerTarget;
+extern u16 gBattlerPartyIndexes[];
+extern u8 gBattlerSpriteIds[];
+extern u8 gHealthboxSpriteIds[];
 extern struct MusicPlayerInfo gMPlayInfo_BGM;
 
 // this file's functions
@@ -334,12 +334,12 @@ u8 DoPokeballSendOutAnimation(s16 pan, u8 kindOfThrow)
     u8 taskId;
 
     gDoingBattleAnim = TRUE;
-    gBattleSpritesDataPtr->healthBoxesData[gActiveBank].ballAnimActive = 1;
+    gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive = 1;
 
     taskId = CreateTask(Task_DoPokeballSendOutAnim, 5);
     gTasks[taskId].tPan = pan;
     gTasks[taskId].tThrowId = kindOfThrow;
-    gTasks[taskId].tBank = gActiveBank;
+    gTasks[taskId].tBank = gActiveBattler;
 
     return 0;
 }
@@ -363,10 +363,10 @@ static void Task_DoPokeballSendOutAnim(u8 taskId)
     throwCaseId = gTasks[taskId].tThrowId;
     bank = gTasks[taskId].tBank;
 
-    if (GetBankSide(bank) != SIDE_PLAYER)
-        itemId = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_POKEBALL);
+    if (GetBattlerSide(bank) != B_SIDE_PLAYER)
+        itemId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[bank]], MON_DATA_POKEBALL);
     else
-        itemId = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_POKEBALL);
+        itemId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_POKEBALL);
 
     ballId = ItemIdToBallId(itemId);
     LoadBallGfx(ballId);
@@ -378,25 +378,25 @@ static void Task_DoPokeballSendOutAnim(u8 taskId)
     switch (throwCaseId)
     {
     case POKEBALL_PLAYER_SENDOUT:
-        gBankTarget = bank;
+        gBattlerTarget = bank;
         gSprites[ballSpriteId].pos1.x = 24;
         gSprites[ballSpriteId].pos1.y = 68;
         gSprites[ballSpriteId].callback = SpriteCB_PlayerMonSendOut_1;
         break;
     case POKEBALL_OPPONENT_SENDOUT:
-        gSprites[ballSpriteId].pos1.x = GetBankPosition(bank, BANK_X_POS);
-        gSprites[ballSpriteId].pos1.y = GetBankPosition(bank, BANK_Y_POS) + 24;
-        gBankTarget = bank;
+        gSprites[ballSpriteId].pos1.x = GetBattlerSpriteCoord(bank, BANK_X_POS);
+        gSprites[ballSpriteId].pos1.y = GetBattlerSpriteCoord(bank, BANK_Y_POS) + 24;
+        gBattlerTarget = bank;
         gSprites[ballSpriteId].data[0] = 0;
         gSprites[ballSpriteId].callback = SpriteCB_OpponentMonSendOut;
         break;
     default:
-        gBankTarget = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
+        gBattlerTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
         notSendOut = TRUE;
         break;
     }
 
-    gSprites[ballSpriteId].sBank = gBankTarget;
+    gSprites[ballSpriteId].sBank = gBattlerTarget;
     if (!notSendOut)
     {
         DestroyTask(taskId);
@@ -405,12 +405,12 @@ static void Task_DoPokeballSendOutAnim(u8 taskId)
 
     // this will perform an unused ball throw animation
     gSprites[ballSpriteId].data[0] = 0x22;
-    gSprites[ballSpriteId].data[2] = GetBankPosition(gBankTarget, BANK_X_POS);
-    gSprites[ballSpriteId].data[4] = GetBankPosition(gBankTarget, BANK_Y_POS) - 16;
+    gSprites[ballSpriteId].data[2] = GetBattlerSpriteCoord(gBattlerTarget, BANK_X_POS);
+    gSprites[ballSpriteId].data[4] = GetBattlerSpriteCoord(gBattlerTarget, BANK_Y_POS) - 16;
     gSprites[ballSpriteId].data[5] = -40;
     sub_80A68D4(&gSprites[ballSpriteId]);
     gSprites[ballSpriteId].oam.affineParam = taskId;
-    gTasks[taskId].tOpponentBank = gBankTarget;
+    gTasks[taskId].tOpponentBank = gBattlerTarget;
     gTasks[taskId].func = TaskDummy;
     PlaySE(SE_NAGERU);
 }
@@ -458,9 +458,9 @@ static void sub_80756E0(struct Sprite *sprite)
     {
         sprite->data[5] = 0;
         sprite->callback = sub_807574C;
-        StartSpriteAffineAnim(&gSprites[gBankSpriteIds[sprite->sBank]], 2);
-        AnimateSprite(&gSprites[gBankSpriteIds[sprite->sBank]]);
-        gSprites[gBankSpriteIds[sprite->sBank]].data[1] = 0;
+        StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[sprite->sBank]], 2);
+        AnimateSprite(&gSprites[gBattlerSpriteIds[sprite->sBank]]);
+        gSprites[gBattlerSpriteIds[sprite->sBank]].data[1] = 0;
     }
 }
 
@@ -469,17 +469,17 @@ static void sub_807574C(struct Sprite *sprite)
     sprite->data[5]++;
     if (sprite->data[5] == 11)
         PlaySE(SE_SUIKOMU);
-    if (gSprites[gBankSpriteIds[sprite->sBank]].affineAnimEnded)
+    if (gSprites[gBattlerSpriteIds[sprite->sBank]].affineAnimEnded)
     {
         StartSpriteAnim(sprite, 2);
-        gSprites[gBankSpriteIds[sprite->sBank]].invisible = TRUE;
+        gSprites[gBattlerSpriteIds[sprite->sBank]].invisible = TRUE;
         sprite->data[5] = 0;
         sprite->callback = sub_80757E4;
     }
     else
     {
-        gSprites[gBankSpriteIds[sprite->sBank]].data[1] += 0x60;
-        gSprites[gBankSpriteIds[sprite->sBank]].pos2.y = -gSprites[gBankSpriteIds[sprite->sBank]].data[1] >> 8;
+        gSprites[gBattlerSpriteIds[sprite->sBank]].data[1] += 0x60;
+        gSprites[gBattlerSpriteIds[sprite->sBank]].pos2.y = -gSprites[gBattlerSpriteIds[sprite->sBank]].data[1] >> 8;
     }
 }
 
@@ -755,19 +755,19 @@ static void SpriteCB_ReleaseMonFromBall(struct Sprite *sprite)
         u16 wantedCryCase;
         u8 taskId;
 
-        if (GetBankSide(bank) != SIDE_PLAYER)
+        if (GetBattlerSide(bank) != B_SIDE_PLAYER)
         {
-            mon = &gEnemyParty[gBattlePartyID[bank]];
+            mon = &gEnemyParty[gBattlerPartyIndexes[bank]];
             pan = 25;
         }
         else
         {
-            mon = &gPlayerParty[gBattlePartyID[bank]];
+            mon = &gPlayerParty[gBattlerPartyIndexes[bank]];
             pan = -25;
         }
 
         species = GetMonData(mon, MON_DATA_SPECIES);
-        if ((bank == GetBankByIdentity(IDENTITY_PLAYER_MON1) || bank == GetBankByIdentity(IDENTITY_OPPONENT_MON1))
+        if ((bank == GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) || bank == GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))
          && IsDoubleBattle() && gBattleSpritesDataPtr->animationData->field_9_x1)
         {
             if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK)
@@ -783,7 +783,7 @@ static void SpriteCB_ReleaseMonFromBall(struct Sprite *sprite)
 
         if (!IsDoubleBattle() || !gBattleSpritesDataPtr->animationData->field_9_x1)
             wantedCryCase = 0;
-        else if (bank == GetBankByIdentity(IDENTITY_PLAYER_MON1) || bank == GetBankByIdentity(IDENTITY_OPPONENT_MON1))
+        else if (bank == GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) || bank == GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))
             wantedCryCase = 1;
         else
             wantedCryCase = 2;
@@ -795,21 +795,21 @@ static void SpriteCB_ReleaseMonFromBall(struct Sprite *sprite)
         gTasks[taskId].tCryTaskPan = pan;
         gTasks[taskId].tCryTaskWantedCry = wantedCryCase;
         gTasks[taskId].tCryTaskBank = bank;
-        gTasks[taskId].tCryTaskMonSpriteId = gBankSpriteIds[sprite->sBank];
+        gTasks[taskId].tCryTaskMonSpriteId = gBattlerSpriteIds[sprite->sBank];
         gTasks[taskId].tCryTaskMonPtr1 = (u32)(mon) >> 0x10;
         gTasks[taskId].tCryTaskMonPtr2 = (u32)(mon);
         gTasks[taskId].tCryTaskState = 0;
     }
 
-    StartSpriteAffineAnim(&gSprites[gBankSpriteIds[sprite->sBank]], 1);
+    StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[sprite->sBank]], 1);
 
-    if (GetBankSide(sprite->sBank) == SIDE_OPPONENT)
-        gSprites[gBankSpriteIds[sprite->sBank]].callback = sub_8039B58;
+    if (GetBattlerSide(sprite->sBank) == B_SIDE_OPPONENT)
+        gSprites[gBattlerSpriteIds[sprite->sBank]].callback = sub_8039B58;
     else
-        gSprites[gBankSpriteIds[sprite->sBank]].callback = sub_8039E44;
+        gSprites[gBattlerSpriteIds[sprite->sBank]].callback = sub_8039E44;
 
-    AnimateSprite(&gSprites[gBankSpriteIds[sprite->sBank]]);
-    gSprites[gBankSpriteIds[sprite->sBank]].data[1] = 0x1000;
+    AnimateSprite(&gSprites[gBattlerSpriteIds[sprite->sBank]]);
+    gSprites[gBattlerSpriteIds[sprite->sBank]].data[1] = 0x1000;
 }
 
 #undef tCryTaskSpecies
@@ -836,35 +836,35 @@ static void HandleBallAnimEnd(struct Sprite *sprite)
     bool8 affineAnimEnded = FALSE;
     u8 bank = sprite->sBank;
 
-    gSprites[gBankSpriteIds[bank]].invisible = FALSE;
+    gSprites[gBattlerSpriteIds[bank]].invisible = FALSE;
     if (sprite->animEnded)
         sprite->invisible = TRUE;
-    if (gSprites[gBankSpriteIds[bank]].affineAnimEnded)
+    if (gSprites[gBattlerSpriteIds[bank]].affineAnimEnded)
     {
-        StartSpriteAffineAnim(&gSprites[gBankSpriteIds[bank]], 0);
+        StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[bank]], 0);
         affineAnimEnded = TRUE;
     }
     else
     {
-        gSprites[gBankSpriteIds[bank]].data[1] -= 288;
-        gSprites[gBankSpriteIds[bank]].pos2.y = gSprites[gBankSpriteIds[bank]].data[1] >> 8;
+        gSprites[gBattlerSpriteIds[bank]].data[1] -= 288;
+        gSprites[gBattlerSpriteIds[bank]].pos2.y = gSprites[gBattlerSpriteIds[bank]].data[1] >> 8;
     }
     if (sprite->animEnded && affineAnimEnded)
     {
         s32 i, doneBanks;
 
-        gSprites[gBankSpriteIds[bank]].pos2.y = 0;
+        gSprites[gBattlerSpriteIds[bank]].pos2.y = 0;
         gDoingBattleAnim = FALSE;
         gBattleSpritesDataPtr->healthBoxesData[bank].ballAnimActive = 0;
         FreeSpriteOamMatrix(sprite);
         DestroySprite(sprite);
 
-        for (doneBanks = 0, i = 0; i < BATTLE_BANKS_COUNT; i++)
+        for (doneBanks = 0, i = 0; i < MAX_BATTLERS_COUNT; i++)
         {
             if (gBattleSpritesDataPtr->healthBoxesData[i].ballAnimActive == 0)
                 doneBanks++;
         }
-        if (doneBanks == BATTLE_BANKS_COUNT)
+        if (doneBanks == MAX_BATTLERS_COUNT)
         {
             for (i = 0; i < POKEBALL_COUNT; i++)
                 FreeBallGfx(i);
@@ -889,8 +889,8 @@ static void sub_80760F8(struct Sprite *sprite)
     }
     else if (sprite->data[4] == 315)
     {
-        FreeOamMatrix(gSprites[gBankSpriteIds[sprite->sBank]].oam.matrixNum);
-        DestroySprite(&gSprites[gBankSpriteIds[sprite->sBank]]);
+        FreeOamMatrix(gSprites[gBattlerSpriteIds[sprite->sBank]].oam.matrixNum);
+        DestroySprite(&gSprites[gBattlerSpriteIds[sprite->sBank]]);
         DestroySpriteAndFreeResources(sprite);
         if (gMain.inBattle)
             gBattleSpritesDataPtr->healthBoxesData[bank].ballAnimActive = 0;
@@ -900,8 +900,8 @@ static void sub_80760F8(struct Sprite *sprite)
 static void SpriteCB_PlayerMonSendOut_1(struct Sprite *sprite)
 {
     sprite->data[0] = 25;
-    sprite->data[2] = GetBankPosition(sprite->sBank, 2);
-    sprite->data[4] = GetBankPosition(sprite->sBank, 3) + 24;
+    sprite->data[2] = GetBattlerSpriteCoord(sprite->sBank, 2);
+    sprite->data[4] = GetBattlerSpriteCoord(sprite->sBank, 3) + 24;
     sprite->data[5] = -30;
     sprite->oam.affineParam = sprite->sBank;
     sub_80A68D4(sprite);
@@ -956,7 +956,7 @@ static void SpriteCB_PlayerMonSendOut_2(struct Sprite *sprite)
             sprite->data[0] = 0;
 
             if (IsDoubleBattle() && gBattleSpritesDataPtr->animationData->field_9_x1
-             && sprite->sBank == GetBankByIdentity(IDENTITY_PLAYER_MON2))
+             && sprite->sBank == GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT))
                 sprite->callback = SpriteCB_ReleaseMon2FromBall;
             else
                 sprite->callback = SpriteCB_ReleaseMonFromBall;
@@ -982,7 +982,7 @@ static void SpriteCB_OpponentMonSendOut(struct Sprite *sprite)
     {
         sprite->data[0] = 0;
         if (IsDoubleBattle() && gBattleSpritesDataPtr->animationData->field_9_x1
-         && sprite->sBank == GetBankByIdentity(IDENTITY_OPPONENT_MON2))
+         && sprite->sBank == GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT))
             sprite->callback = SpriteCB_ReleaseMon2FromBall;
         else
             sprite->callback = SpriteCB_ReleaseMonFromBall;
@@ -1183,14 +1183,14 @@ static void DestroySpriteAndFreeResources_(struct Sprite *sprite)
 
 void sub_8076918(u8 bank)
 {
-    struct Sprite *healthboxSprite = &gSprites[gHealthBoxesIds[bank]];
+    struct Sprite *healthboxSprite = &gSprites[gHealthboxSpriteIds[bank]];
 
     healthboxSprite->data[0] = 5;
     healthboxSprite->data[1] = 0;
     healthboxSprite->pos2.x = 0x73;
     healthboxSprite->pos2.y = 0;
     healthboxSprite->callback = sub_80769CC;
-    if (GetBankSide(bank) != SIDE_PLAYER)
+    if (GetBattlerSide(bank) != B_SIDE_PLAYER)
     {
         healthboxSprite->data[0] = -healthboxSprite->data[0];
         healthboxSprite->data[1] = -healthboxSprite->data[1];
@@ -1198,7 +1198,7 @@ void sub_8076918(u8 bank)
         healthboxSprite->pos2.y = -healthboxSprite->pos2.y;
     }
     gSprites[healthboxSprite->data[5]].callback(&gSprites[healthboxSprite->data[5]]);
-    if (GetBankIdentity(bank) == IDENTITY_PLAYER_MON2)
+    if (GetBattlerPosition(bank) == B_POSITION_PLAYER_RIGHT)
         healthboxSprite->callback = sub_80769A8;
 }
 
@@ -1226,7 +1226,7 @@ void DoHitAnimHealthboxEffect(u8 bank)
 
     spriteId = CreateInvisibleSpriteWithCallback(SpriteCB_HitAnimHealthoxEffect);
     gSprites[spriteId].data[0] = 1;
-    gSprites[spriteId].data[1] = gHealthBoxesIds[bank];
+    gSprites[spriteId].data[1] = gHealthboxSpriteIds[bank];
     gSprites[spriteId].callback = SpriteCB_HitAnimHealthoxEffect;
 }
 
@@ -1275,8 +1275,8 @@ void FreeBallGfx(u8 ballId)
 
 static u16 GetBankPokeballItemId(u8 bank)
 {
-    if (GetBankSide(bank) == SIDE_PLAYER)
-        return GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_POKEBALL);
+    if (GetBattlerSide(bank) == B_SIDE_PLAYER)
+        return GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_POKEBALL);
     else
-        return GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_POKEBALL);
+        return GetMonData(&gEnemyParty[gBattlerPartyIndexes[bank]], MON_DATA_POKEBALL);
 }

src/pokeblock.c

@@ -13,7 +13,7 @@
 #include "battle.h"
 #include "battle_controllers.h"
 #include "palette.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "list_menu.h"
 #include "gpu_regs.h"
 #include "decompress.h"

src/pokemon_2.c

@@ -14,10 +14,10 @@ struct Unknown_020249B4
     struct SpriteTemplate* templates;
 };
 
-extern u8 gAbsentBankFlags;
-extern u8 gActiveBank;
-extern u8 gBankAttacker;
-extern u8 gBankTarget;
+extern u8 gAbsentBattlerFlags;
+extern u8 gActiveBattler;
+extern u8 gBattlerAttacker;
+extern u8 gBattlerTarget;
 extern u8 gLastUsedAbility;
 extern u16 gTrainerBattleOpponent_A;
 extern u32 gBattleTypeFlags;
@@ -34,9 +34,9 @@ extern const union AnimCmd* const * const gUnknown_0830536C[];
 extern const u8 gText_BadEgg[];
 extern const u8 gText_EggNickname[];
 
-extern u8 GetBankSide(u8 bank);
-extern u8 GetBankByIdentity(u8 bank);
-extern u8 GetBankIdentity(u8 bank);
+extern u8 GetBattlerSide(u8 bank);
+extern u8 GetBattlerAtPosition(u8 bank);
+extern u8 GetBattlerPosition(u8 bank);
 
 u8 CountAliveMonsInBattle(u8 caseId)
 {
@@ -48,21 +48,21 @@ u8 CountAliveMonsInBattle(u8 caseId)
     case BATTLE_ALIVE_EXCEPT_ACTIVE:
         for (i = 0; i < 4; i++)
         {
-            if (i != gActiveBank && !(gAbsentBankFlags & gBitTable[i]))
+            if (i != gActiveBattler && !(gAbsentBattlerFlags & gBitTable[i]))
                 retVal++;
         }
         break;
     case BATTLE_ALIVE_ATK_SIDE:
         for (i = 0; i < 4; i++)
         {
-            if (GetBankSide(i) == GetBankSide(gBankAttacker) && !(gAbsentBankFlags & gBitTable[i]))
+            if (GetBattlerSide(i) == GetBattlerSide(gBattlerAttacker) && !(gAbsentBattlerFlags & gBitTable[i]))
                 retVal++;
         }
         break;
     case BATTLE_ALIVE_DEF_SIDE:
         for (i = 0; i < 4; i++)
         {
-            if (GetBankSide(i) == GetBankSide(gBankTarget) && !(gAbsentBankFlags & gBitTable[i]))
+            if (GetBattlerSide(i) == GetBattlerSide(gBattlerTarget) && !(gAbsentBattlerFlags & gBitTable[i]))
                 retVal++;
         }
         break;
@@ -75,7 +75,7 @@ bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 bank)
 {
     if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_x2000000 | BATTLE_TYPE_FRONTIER))
         return FALSE;
-    if (GetBankSide(bank) != SIDE_PLAYER)
+    if (GetBattlerSide(bank) != B_SIDE_PLAYER)
         return FALSE;
     if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gTrainerBattleOpponent_A == SECRET_BASE_OPPONENT)
         return FALSE;
@@ -86,11 +86,11 @@ bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 bank)
 
 u8 GetDefaultMoveTarget(u8 bank)
 {
-    u8 status = GetBankIdentity(bank) & 1;
+    u8 status = GetBattlerPosition(bank) & 1;
 
     status ^= 1;
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
-        return GetBankByIdentity(status);
+        return GetBattlerAtPosition(status);
     if (CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_ACTIVE) > 1)
     {
         u8 val;
@@ -99,14 +99,14 @@ u8 GetDefaultMoveTarget(u8 bank)
             val = status ^ 2;
         else
             val = status;
-        return GetBankByIdentity(val);
+        return GetBattlerAtPosition(val);
     }
     else
     {
-        if ((gAbsentBankFlags & gBitTable[status]))
-            return GetBankByIdentity(status ^ 2);
+        if ((gAbsentBattlerFlags & gBitTable[status]))
+            return GetBattlerAtPosition(status ^ 2);
         else
-            return GetBankByIdentity(status);
+            return GetBattlerAtPosition(status);
     }
 }
 
@@ -1197,26 +1197,26 @@ void CreateSecretBaseEnemyParty(struct SecretBaseRecord *secretBaseRecord)
 
     for (i = 0; i < PARTY_SIZE; i++)
     {
-        if (gBattleResources->secretBase->partySpecies[i])
+        if (gBattleResources->secretBase->party.species[i])
         {
             CreateMon(&gEnemyParty[i],
-                gBattleResources->secretBase->partySpecies[i],
-                gBattleResources->secretBase->partyLevels[i],
+                gBattleResources->secretBase->party.species[i],
+                gBattleResources->secretBase->party.levels[i],
                 15,
                 1,
-                gBattleResources->secretBase->partyPersonality[i],
+                gBattleResources->secretBase->party.personality[i],
                 2,
                 0);
 
-            SetMonData(&gEnemyParty[i], MON_DATA_HELD_ITEM, &gBattleResources->secretBase->partyHeldItems[i]);
+            SetMonData(&gEnemyParty[i], MON_DATA_HELD_ITEM, &gBattleResources->secretBase->party.heldItems[i]);
 
             for (j = 0; j < 6; j++)
-                SetMonData(&gEnemyParty[i], MON_DATA_HP_EV + j, &gBattleResources->secretBase->partyEVs[i]);
+                SetMonData(&gEnemyParty[i], MON_DATA_HP_EV + j, &gBattleResources->secretBase->party.EVs[i]);
 
             for (j = 0; j < 4; j++)
             {
-                SetMonData(&gEnemyParty[i], MON_DATA_MOVE1 + j, &gBattleResources->secretBase->partyMoves[i * 4 + j]);
-                SetMonData(&gEnemyParty[i], MON_DATA_PP1 + j, &gBattleMoves[gBattleResources->secretBase->partyMoves[i * 4 + j]].pp);
+                SetMonData(&gEnemyParty[i], MON_DATA_MOVE1 + j, &gBattleResources->secretBase->party.moves[i * 4 + j]);
+                SetMonData(&gEnemyParty[i], MON_DATA_PP1 + j, &gBattleMoves[gBattleResources->secretBase->party.moves[i * 4 + j]].pp);
             }
         }
     }
@@ -1353,7 +1353,7 @@ void CopyPlayerPartyMonToBattleData(u8 bank, u8 partyIndex)
     StringCopy10(gBattleMons[bank].nickname, nickname);
     GetMonData(&gPlayerParty[partyIndex], MON_DATA_OT_NAME, gBattleMons[bank].otName);
 
-    hpSwitchout = &gBattleStruct->hpOnSwitchout[GetBankSide(bank)];
+    hpSwitchout = &gBattleStruct->hpOnSwitchout[GetBattlerSide(bank)];
     *hpSwitchout = gBattleMons[bank].hp;
 
     for (i = 0; i < 8; i++)

src/pokemon_3.c

@@ -25,15 +25,15 @@
 
 extern struct BattlePokemon gBattleMons[4];
 extern struct BattleEnigmaBerry gEnigmaBerries[4];
-extern u8 gActiveBank;
+extern u8 gActiveBattler;
 extern u8 gBankInMenu;
-extern u8 gBankTarget;
-extern u8 gBankAttacker;
-extern u8 gStringBank;
+extern u8 gBattlerTarget;
+extern u8 gBattlerAttacker;
+extern u8 gStringBattler;
 extern u16 gTrainerBattleOpponent_A;
 extern u32 gBattleTypeFlags;
 extern u8 gBattleMonForms[4];
-extern u16 gBattlePartyID[4];
+extern u16 gBattlerPartyIndexes[4];
 extern u8 gLastUsedAbility;
 extern u16 gPartnerTrainerId;
 extern u32 gHitMarker;
@@ -74,8 +74,6 @@ extern u8 GetFrontierOpponentClass(u16 trainerId);
 extern u8 pokemon_order_func(u8 bankPartyId);
 extern void GetFrontierTrainerName(u8* dest, u16 trainerId);
 extern void sub_81C488C(u8);
-extern void sub_817F578(struct Sprite*, u8 frontAnimId);
-extern u8 GetSpeciesBackAnimId(u16 species);
 
 static void sub_806E6CC(u8 taskId);
 
@@ -115,7 +113,7 @@ u8 GetItemEffectParamOffset(u16 itemId, u8 effectByte, u8 effectBit)
 
     if (itemId == ITEM_ENIGMA_BERRY)
     {
-        temp = gEnigmaBerries[gActiveBank].itemEffect;
+        temp = gEnigmaBerries[gActiveBattler].itemEffect;
     }
 
     itemEffect = temp;
@@ -212,7 +210,7 @@ u8 GetItemEffectParamOffset(u16 itemId, u8 effectByte, u8 effectBit)
 
 void sub_806CF24(s32 stat)
 {
-    gBankTarget = gBankInMenu;
+    gBattlerTarget = gBankInMenu;
     StringCopy(gBattleTextBuff1, gStatNamesTable[gUnknown_08329EC8[stat]]);
     StringCopy(gBattleTextBuff2, gText_StatRose);
     BattleStringExpandPlaceholdersToDisplayedString(gText_PkmnsStatChanged2);
@@ -235,7 +233,7 @@ u8 *sub_806CF78(u16 itemId)
         itemEffect = gItemEffectTable[itemId - 13];
     }
 
-    gStringBank = gBankInMenu;
+    gStringBattler = gBankInMenu;
 
     for (i = 0; i < 3; i++)
     {
@@ -249,7 +247,7 @@ u8 *sub_806CF78(u16 itemId)
             }
             else
             {
-                gBankAttacker = gBankInMenu;
+                gBattlerAttacker = gBankInMenu;
                 BattleStringExpandPlaceholdersToDisplayedString(gText_PkmnGettingPumped);
             }
         }
@@ -257,7 +255,7 @@ u8 *sub_806CF78(u16 itemId)
 
     if (itemEffect[3] & 0x80)
     {
-        gBankAttacker = gBankInMenu;
+        gBattlerAttacker = gBankInMenu;
         BattleStringExpandPlaceholdersToDisplayedString(gText_PkmnShroudedInMist);
     }
 
@@ -617,7 +615,7 @@ bool16 sub_806D82C(u8 id)
     return retVal;
 }
 
-s32 GetBankMultiplayerId(u16 a1)
+s32 GetBattlerMultiplayerId(u16 a1)
 {
     s32 id;
     for (id = 0; id < MAX_LINK_PLAYERS; id++)
@@ -1368,12 +1366,12 @@ void sub_806E994(void)
     gBattleTextBuff1[2] = gBattleStruct->field_49;
     gBattleTextBuff1[4] = B_BUFF_EOS;
 
-    if (!GetBankSide(gBattleStruct->field_49))
-        gBattleTextBuff1[3] = pokemon_order_func(gBattlePartyID[gBattleStruct->field_49]);
+    if (!GetBattlerSide(gBattleStruct->field_49))
+        gBattleTextBuff1[3] = pokemon_order_func(gBattlerPartyIndexes[gBattleStruct->field_49]);
     else
-        gBattleTextBuff1[3] = gBattlePartyID[gBattleStruct->field_49];
+        gBattleTextBuff1[3] = gBattlerPartyIndexes[gBattleStruct->field_49];
 
-    PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff2, gBankInMenu, pokemon_order_func(gBattlePartyID[gBankInMenu]))
+    PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff2, gBankInMenu, pokemon_order_func(gBattlerPartyIndexes[gBankInMenu]))
 
     BattleStringExpandPlaceholders(gText_PkmnsXPreventsSwitching, gStringVar4);
 }
@@ -1480,7 +1478,7 @@ const u8 *GetTrainerPartnerName(void)
     else
     {
         u8 id = GetMultiplayerId();
-        return gLinkPlayers[GetBankMultiplayerId(gLinkPlayers[id].lp_field_18 ^ 2)].name;
+        return gLinkPlayers[GetBattlerMultiplayerId(gLinkPlayers[id].lp_field_18 ^ 2)].name;
     }
 }
 
@@ -1508,7 +1506,7 @@ static void Task_PokemonSummaryAnimateAfterDelay(u8 taskId)
 {
     if (--gTasks[taskId].data[3] == 0)
     {
-        sub_817F578(READ_PTR_FROM_TASK(taskId, 0), gTasks[taskId].data[2]);
+        StartMonSummaryAnimation(READ_PTR_FROM_TASK(taskId, 0), gTasks[taskId].data[2]);
         sub_81C488C(0xFF);
         DestroyTask(taskId);
     }
@@ -1523,7 +1521,6 @@ void BattleAnimateFrontSprite(struct Sprite* sprite, u16 species, bool8 noCry, u
 }
 
 extern void SpriteCallbackDummy_2(struct Sprite*);
-extern void sub_817F60C(struct Sprite*);
 
 void DoMonFrontSpriteAnimation(struct Sprite* sprite, u16 species, bool8 noCry, u8 arg3)
 {
@@ -1580,11 +1577,11 @@ void PokemonSummaryDoMonAnimation(struct Sprite* sprite, u16 species, bool8 oneF
         gTasks[taskId].data[2] = gMonFrontAnimIdsTable[species - 1];
         gTasks[taskId].data[3] = gMonAnimationDelayTable[species - 1];
         sub_81C488C(taskId);
-        sub_817F60C(sprite);
+        SetSpriteCB_MonAnimDummy(sprite);
     }
     else
     {
-        sub_817F578(sprite, gMonFrontAnimIdsTable[species - 1]);
+        StartMonSummaryAnimation(sprite, gMonFrontAnimIdsTable[species - 1]);
     }
 }
 
@@ -1603,7 +1600,7 @@ void BattleAnimateBackSprite(struct Sprite* sprite, u16 species)
     }
     else
     {
-        LaunchAnimationTaskForBackSprite(sprite, GetSpeciesBackAnimId(species));
+        LaunchAnimationTaskForBackSprite(sprite, GetSpeciesBackAnimSet(species));
         sprite->callback = SpriteCallbackDummy_2;
     }
 }

src/recorded_battle.c

@@ -25,11 +25,11 @@ extern u32 gBattleTypeFlags;
 extern u16 gTrainerBattleOpponent_A;
 extern u16 gTrainerBattleOpponent_B;
 extern u16 gPartnerTrainerId;
-extern u8 gActiveBank;
-extern u8 gNoOfAllBanks;
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
-extern u16 gChosenMovesByBanks[BATTLE_BANKS_COUNT];
+extern u8 gActiveBattler;
+extern u8 gBattlersCount;
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
+extern u16 gChosenMoveByBattler[MAX_BATTLERS_COUNT];
 extern u8 gUnknown_03001278;
 extern u8 gUnknown_03001279;
 
@@ -52,13 +52,13 @@ struct RecordedBattleSave
 {
     struct Pokemon playerParty[PARTY_SIZE];
     struct Pokemon opponentParty[PARTY_SIZE];
-    u8 playersName[BATTLE_BANKS_COUNT][PLAYER_NAME_LENGTH];
-    u8 playersGender[BATTLE_BANKS_COUNT];
-    u32 playersTrainerId[BATTLE_BANKS_COUNT];
-    u8 playersLanguage[BATTLE_BANKS_COUNT];
+    u8 playersName[MAX_BATTLERS_COUNT][PLAYER_NAME_LENGTH];
+    u8 playersGender[MAX_BATTLERS_COUNT];
+    u32 playersTrainerId[MAX_BATTLERS_COUNT];
+    u8 playersLanguage[MAX_BATTLERS_COUNT];
     u32 rngSeed;
     u32 battleFlags;
-    u8 playersBank[BATTLE_BANKS_COUNT];
+    u8 playersBank[MAX_BATTLERS_COUNT];
     u16 opponentA;
     u16 opponentB;
     u16 partnerId;
@@ -75,14 +75,14 @@ struct RecordedBattleSave
     u16 field_50E[6];
     u8 field_51A;
     u8 field_51B;
-    u8 battleRecord[BATTLE_BANKS_COUNT][BANK_RECORD_SIZE];
+    u8 battleRecord[MAX_BATTLERS_COUNT][BANK_RECORD_SIZE];
     u32 checksum;
 };
 
 EWRAM_DATA u32 gRecordedBattleRngSeed = 0;
 EWRAM_DATA u32 gBattlePalaceMoveSelectionRngValue = 0;
-EWRAM_DATA static u8 sBattleRecords[BATTLE_BANKS_COUNT][BANK_RECORD_SIZE] = {0};
-EWRAM_DATA static u16 sRecordedBytesNo[BATTLE_BANKS_COUNT] = {0};
+EWRAM_DATA static u8 sBattleRecords[MAX_BATTLERS_COUNT][BANK_RECORD_SIZE] = {0};
+EWRAM_DATA static u16 sRecordedBytesNo[MAX_BATTLERS_COUNT] = {0};
 EWRAM_DATA static u16 sUnknown_0203C79C[4] = {0};
 EWRAM_DATA static u16 sUnknown_0203C7A4[4] = {0};
 EWRAM_DATA static u8 sUnknown_0203C7AC = 0;
@@ -99,7 +99,7 @@ EWRAM_DATA static u32 sRecordedBattle_AI_Scripts = 0;
 EWRAM_DATA static struct Pokemon sSavedPlayerParty[PARTY_SIZE] = {0};
 EWRAM_DATA static struct Pokemon sSavedOpponentParty[PARTY_SIZE] = {0};
 EWRAM_DATA static u16 sRecordedBattle_PlayerMonMoves[2][4] = {0};
-EWRAM_DATA static struct PlayerInfo sRecordedBattle_Players[BATTLE_BANKS_COUNT] = {0};
+EWRAM_DATA static struct PlayerInfo sRecordedBattle_Players[MAX_BATTLERS_COUNT] = {0};
 EWRAM_DATA static u8 sUnknown_0203CCD0 = 0;
 EWRAM_DATA static u8 sUnknown_0203CCD1[8] = {0};
 EWRAM_DATA static u8 sUnknown_0203CCD9 = 0;
@@ -123,7 +123,7 @@ void sub_8184DA4(u8 arg0)
     sUnknown_0203C7AC = arg0;
     sUnknown_0203CCD0 = 0;
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
         sRecordedBytesNo[i] = 0;
         sUnknown_0203C79C[i] = 0;
@@ -164,7 +164,7 @@ void sub_8184E58(void)
         gUnknown_0203C7B4 = GetMultiplayerId();
         linkPlayersCount = GetLinkPlayerCount();
 
-        for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+        for (i = 0; i < MAX_BATTLERS_COUNT; i++)
         {
             sRecordedBattle_Players[i].trainerId = gLinkPlayers[i].trainerId;
             sRecordedBattle_Players[i].gender = gLinkPlayers[i].gender;
@@ -200,7 +200,7 @@ void sub_8184E58(void)
     }
 }
 
-void RecordedBattle_SetBankAction(u8 bank, u8 action)
+void RecordedBattle_SetBattlerAction(u8 bank, u8 action)
 {
     if (sRecordedBytesNo[bank] < BANK_RECORD_SIZE && sUnknown_0203C7AC != 2)
     {
@@ -208,7 +208,7 @@ void RecordedBattle_SetBankAction(u8 bank, u8 action)
     }
 }
 
-void RecordedBattle_ClearBankAction(u8 bank, u8 bytesToClear)
+void RecordedBattle_ClearBattlerAction(u8 bank, u8 bytesToClear)
 {
     s32 i;
 
@@ -221,12 +221,12 @@ void RecordedBattle_ClearBankAction(u8 bank, u8 bytesToClear)
     }
 }
 
-u8 RecordedBattle_ReadBankAction(u8 bank)
+u8 RecordedBattle_GetBattlerAction(u8 bank)
 {
     // trying to read past array or invalid action byte, battle is over
     if (sRecordedBytesNo[bank] >= BANK_RECORD_SIZE || sBattleRecords[bank][sRecordedBytesNo[bank]] == 0xFF)
     {
-        gSpecialVar_Result = gBattleOutcome = BATTLE_PLAYER_TELEPORTED; // hah
+        gSpecialVar_Result = gBattleOutcome = B_OUTCOME_PLAYER_TELEPORTED; // hah
         ResetPaletteFadeControl();
         BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
         SetMainCallback2(CB2_QuitRecordedBattle);
@@ -248,7 +248,7 @@ u8 sub_81850DC(u8 *arg0)
     u8 i, j;
     u8 ret = 0;
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
         if (sRecordedBytesNo[i] != sUnknown_0203C79C[i])
         {
@@ -350,7 +350,7 @@ u32 MoveRecordedBattleToSaveData(void)
         battleSave->opponentParty[i] = sSavedOpponentParty[i];
     }
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
         for (j = 0; j < PLAYER_NAME_LENGTH; j++)
         {
@@ -1339,7 +1339,7 @@ static void SetRecordedBattleVarsFromSave(struct RecordedBattleSave *src)
         gEnemyParty[i] = src->opponentParty[i];
     }
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
         for (var = FALSE, j = 0; j < PLAYER_NAME_LENGTH; j++)
         {
@@ -1386,7 +1386,7 @@ static void SetRecordedBattleVarsFromSave(struct RecordedBattleSave *src)
 
     gSaveBlock2Ptr->frontierChosenLvl = src->field_4FC;
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
         for (j = 0; j < BANK_RECORD_SIZE; j++)
         {
@@ -1462,7 +1462,7 @@ u8 GetActiveBankLinkPlayerGender(void)
 
     for (i = 0; i < MAX_LINK_PLAYERS; i++)
     {
-        if (gLinkPlayers[i].lp_field_18 == gActiveBank)
+        if (gLinkPlayers[i].lp_field_18 == gActiveBattler)
             break;
     }
 
@@ -1501,7 +1501,7 @@ void RecordedBattle_CopyBankMoves(void)
 {
     s32 i;
 
-    if (GetBankSide(gActiveBank) == SIDE_OPPONENT)
+    if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT)
         return;
     if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_x2000000))
         return;
@@ -1510,7 +1510,7 @@ void RecordedBattle_CopyBankMoves(void)
 
     for (i = 0; i < 4; i++)
     {
-        sRecordedBattle_PlayerMonMoves[gActiveBank / 2][i] = gBattleMons[gActiveBank].moves[i];
+        sRecordedBattle_PlayerMonMoves[gActiveBattler / 2][i] = gBattleMons[gActiveBattler].moves[i];
     }
 }
 
@@ -1523,9 +1523,9 @@ void sub_818603C(u8 arg0)
     if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_x2000000))
         return;
 
-    for (bank = 0; bank < gNoOfAllBanks; bank++)
+    for (bank = 0; bank < gBattlersCount; bank++)
     {
-        if (GetBankSide(bank) != SIDE_OPPONENT) // player's side only
+        if (GetBattlerSide(bank) != B_SIDE_OPPONENT) // player's side only
         {
             if (arg0 == 1)
             {
@@ -1536,14 +1536,14 @@ void sub_818603C(u8 arg0)
                 }
                 if (j != 4) // player's mon's move has been changed
                 {
-                    RecordedBattle_SetBankAction(bank, ACTION_MOVE_CHANGE);
+                    RecordedBattle_SetBattlerAction(bank, ACTION_MOVE_CHANGE);
                     for (j = 0; j < 4; j++)
                     {
                         for (k = 0; k < 4; k++)
                         {
                             if (gBattleMons[bank].moves[j] == sRecordedBattle_PlayerMonMoves[bank / 2][k])
                             {
-                                RecordedBattle_SetBankAction(bank, k);
+                                RecordedBattle_SetBattlerAction(bank, k);
                                 break;
                             }
                         }
@@ -1561,14 +1561,14 @@ void sub_818603C(u8 arg0)
                     u8 array3[8];
                     u8 var;
 
-                    RecordedBattle_ReadBankAction(bank);
+                    RecordedBattle_GetBattlerAction(bank);
                     for (j = 0; j < 4; j++)
                     {
                         ppBonuses[j] = ((gBattleMons[bank].ppBonuses & ((3 << (j << 1)))) >> (j << 1));
                     }
                     for (j = 0; j < 4; j++)
                     {
-                        array1[j] = RecordedBattle_ReadBankAction(bank);
+                        array1[j] = RecordedBattle_GetBattlerAction(bank);
                         movePp.moves[j] = gBattleMons[bank].moves[array1[j]];
                         movePp.pp[j] = gBattleMons[bank].pp[array1[j]];
                         array3[j] = ppBonuses[array1[j]];
@@ -1591,28 +1591,28 @@ void sub_818603C(u8 arg0)
                     {
                         for (j = 0; j < 4; j++)
                         {
-                            ppBonuses[j] = ((GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_PP_BONUSES, NULL) & ((3 << (j << 1)))) >> (j << 1));
+                            ppBonuses[j] = ((GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_PP_BONUSES, NULL) & ((3 << (j << 1)))) >> (j << 1));
                         }
                         for (j = 0; j < 4; j++)
                         {
-                            movePp.moves[j] = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_MOVE1 + array1[j], NULL);
-                            movePp.pp[j] = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_PP1 + array1[j], NULL);
+                            movePp.moves[j] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_MOVE1 + array1[j], NULL);
+                            movePp.pp[j] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_PP1 + array1[j], NULL);
                             array3[j] = ppBonuses[array1[j]];
                         }
                         for (j = 0; j < 4; j++)
                         {
-                            SetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_MOVE1 + j, &movePp.moves[j]);
-                            SetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_PP1 + j, &movePp.pp[j]);
+                            SetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_MOVE1 + j, &movePp.moves[j]);
+                            SetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_PP1 + j, &movePp.pp[j]);
                         }
                         var = 0;
                         for (j = 0; j < 4; j++)
                         {
                             var |= (array3[j]) << (j << 1);
                         }
-                        SetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_PP_BONUSES, &var);
+                        SetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_PP_BONUSES, &var);
                     }
 
-                    gChosenMovesByBanks[bank] = gBattleMons[bank].moves[*(gBattleStruct->chosenMovePositions + bank)];
+                    gChosenMoveByBattler[bank] = gBattleMons[bank].moves[*(gBattleStruct->chosenMovePositions + bank)];
                 }
             }
         }

src/reset_rtc_screen.c

@@ -0,0 +1,639 @@
+#include "global.h"
+#include "reset_rtc_screen.h"
+#include "event_data.h"
+#include "main.h"
+#include "menu.h"
+#include "palette.h"
+#include "rtc.h"
+#include "save.h"
+#include "sprite.h"
+#include "constants/songs.h"
+#include "sound.h"
+#include "string_util.h"
+#include "strings.h"
+#include "task.h"
+#include "text.h"
+#include "scanline_effect.h"
+#include "bg.h"
+#include "window.h"
+#include "gpu_regs.h"
+
+struct ResetRtcStruct
+{
+    /*0x0*/ u8 dataIndex;
+    /*0x2*/ u16 minVal;
+    /*0x4*/ u16 maxVal;
+    /*0x6*/ u8 left;
+    /*0x7*/ u8 right;
+    /*0x8*/ u8 unk8;
+};
+
+// this file's functions
+static void CB2_ResetRtcScreen(void);
+static void VBlankCB(void);
+static void Task_ResetRtcScreen(u8 taskId);
+static void sub_809F048(void);
+
+// const rom data
+static const struct BgTemplate sBackgroundTemplates[] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0
+    }
+};
+
+static const struct WindowTemplate sUnknown_08510408[] =
+{
+    {0x00, 0x01, 0x01, 0x13, 0x09, 0x0f, 0x0155},
+    {0x00, 0x02, 0x0f, 0x1b, 0x04, 0x0f, 0x00e9},
+    DUMMY_WIN_TEMPLATE
+};
+
+static const struct WindowTemplate sUnknown_08510420 = {0x00, 0x04, 0x09, 0x15, 0x02, 0x0f, 0x00bf};
+
+static const struct ResetRtcStruct sUnknown_08510428[5] =
+{
+    {
+        .dataIndex = 3,
+        .minVal = 1,
+        .maxVal = 9999,
+        .left = 0,
+        .right = 2,
+        .unk8 = 0,
+    },
+    {
+        .dataIndex = 4,
+        .minVal = 0,
+        .maxVal = 23,
+        .left = 1,
+        .right = 3,
+        .unk8 = 0,
+    },
+    {
+        .dataIndex = 5,
+        .minVal = 0,
+        .maxVal = 59,
+        .left = 2,
+        .right = 4,
+        .unk8 = 0,
+    },
+    {
+        .dataIndex = 6,
+        .minVal = 0,
+        .maxVal = 59,
+        .left = 3,
+        .right = 5,
+        .unk8 = 0,
+    },
+    {
+        .dataIndex = 7,
+        .minVal = 0,
+        .maxVal = 0,
+        .left = 4,
+        .right = 0,
+        .unk8 = 6,
+    },
+};
+
+static const struct OamData sOamData_08510464 =
+{
+    .y = 0,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 0,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 0,
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+static const u8 sResetRtcScreen_DownArrowGfx[] = INCBIN_U8("graphics/misc/reset_rtc_screen_downarrow.4bpp");
+static const u8 sResetRtcScreen_RightArrowGfx[] = INCBIN_U8("graphics/misc/reset_rtc_screen_rightarrow.4bpp");
+static const u16 sResetRtcScreen_ArrowPal[] = INCBIN_U16("graphics/misc/reset_rtc_screen_arrow.gbapal");
+
+static const struct SpriteFrameImage sSpriteImageTable_85104B4[] =
+{
+    obj_frame_tiles(sResetRtcScreen_DownArrowGfx),
+    obj_frame_tiles(sResetRtcScreen_RightArrowGfx)
+};
+
+static const struct SpritePalette sSpritePalette_Arrow =
+{
+    sResetRtcScreen_ArrowPal, 0x1000
+};
+
+static const union AnimCmd sSpriteAnim_85104CC[] =
+{
+    ANIMCMD_FRAME(0, 30),
+    ANIMCMD_JUMP(0),
+};
+
+static const union AnimCmd sSpriteAnim_85104D4[] =
+{
+    ANIMCMD_FRAME(0, 158, .vFlip = TRUE),
+    ANIMCMD_JUMP(0),
+};
+
+static const union AnimCmd sSpriteAnim_85104DC[] =
+{
+    ANIMCMD_FRAME(1, 30),
+    ANIMCMD_JUMP(0),
+};
+
+static const union AnimCmd *const sSpriteAnimTable_85104E4[] =
+{
+    sSpriteAnim_85104CC,
+    sSpriteAnim_85104D4,
+    sSpriteAnim_85104DC,
+};
+
+static const struct SpriteTemplate sSpriteTemplate_85104F0 =
+{
+    .tileTag = 0xFFFF,
+    .paletteTag = 0x1000,
+    .oam = &sOamData_08510464,
+    .anims = sSpriteAnimTable_85104E4,
+    .images = sSpriteImageTable_85104B4,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+// code
+static void SpriteCB_ResetRtcCursor0(struct Sprite *sprite)
+{
+    int state = gTasks[sprite->data[0]].data[2];
+    if (state != sprite->data[1])
+    {
+        sprite->data[1] = state;
+        switch (state)
+        {
+        case 1:
+            sprite->invisible = FALSE;
+            sprite->animNum = 1;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 53;
+            sprite->pos1.y = 68;
+            break;
+        case 2:
+            sprite->invisible = FALSE;
+            sprite->animNum = 1;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 86;
+            sprite->pos1.y = 68;
+            break;
+        case 3:
+            sprite->invisible = FALSE;
+            sprite->animNum = 1;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 101;
+            sprite->pos1.y = 68;
+            break;
+        case 4:
+            sprite->invisible = FALSE;
+            sprite->animNum = 1;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 116;
+            sprite->pos1.y = 68;
+            break;
+        case 5:
+            sprite->invisible = FALSE;
+            sprite->animNum = 2;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 153;
+            sprite->pos1.y = 80;
+            break;
+        case 6:
+            DestroySprite(sprite);
+            break;
+        }
+    }
+}
+
+static void SpriteCB_ResetRtcCursor1(struct Sprite *sprite)
+{
+    int state = gTasks[sprite->data[0]].data[2];
+    if (state != sprite->data[1])
+    {
+        sprite->data[1] = state;
+        switch (state)
+        {
+        case 1:
+            sprite->invisible = FALSE;
+            sprite->animNum = 0;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 53;
+            sprite->pos1.y = 92;
+            break;
+        case 2:
+            sprite->invisible = FALSE;
+            sprite->animNum = 0;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 86;
+            sprite->pos1.y = 92;
+            break;
+        case 3:
+            sprite->invisible = FALSE;
+            sprite->animNum = 0;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 101;
+            sprite->pos1.y = 92;
+            break;
+        case 4:
+            sprite->invisible = FALSE;
+            sprite->animNum = 0;
+            sprite->animDelayCounter = 0;
+            sprite->pos1.x = 116;
+            sprite->pos1.y = 92;
+            break;
+        case 5:
+            sprite->invisible = TRUE;
+            break;
+        case 6:
+            DestroySprite(sprite);
+            break;
+        }
+    }
+}
+
+static void CreateCursor(u8 taskId)
+{
+    u32 spriteId;
+
+    LoadSpritePalette(&sSpritePalette_Arrow);
+
+    spriteId = CreateSpriteAtEnd(&sSpriteTemplate_85104F0, 53, 68, 0);
+    gSprites[spriteId].callback = SpriteCB_ResetRtcCursor0;
+    gSprites[spriteId].data[0] = taskId;
+    gSprites[spriteId].data[1] = -1;
+
+    spriteId = CreateSpriteAtEnd(&sSpriteTemplate_85104F0, 53, 68, 0);
+    gSprites[spriteId].callback = SpriteCB_ResetRtcCursor1;
+    gSprites[spriteId].data[0] = taskId;
+    gSprites[spriteId].data[1] = -1;
+}
+
+static void FreeCursorPalette(void)
+{
+    FreeSpritePaletteByTag(sSpritePalette_Arrow.tag);
+}
+
+static void HideChooseTimeWindow(u8 windowId)
+{
+    sub_8198070(windowId, FALSE);
+    RemoveWindow(windowId);
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+static void PrintTime(u8 windowId, u8 x, u8 y, u16 days, u8 hours, u8 minutes, u8 seconds)
+{
+    u8 *dest = gStringVar4;
+
+    ConvertIntToDecimalStringN(gStringVar1, days, 1, 4);
+    dest = StringCopy(dest, gStringVar1);
+    dest = StringCopy(dest, gText_Day);
+
+    ConvertIntToDecimalStringN(gStringVar1, hours, 1, 3);
+    dest = StringCopy(dest, gStringVar1);
+    dest = StringCopy(dest, gText_Colon3);
+
+    ConvertIntToDecimalStringN(gStringVar1, minutes, 2, 2);
+    dest = StringCopy(dest, gStringVar1);
+    dest = StringCopy(dest, gText_Colon3);
+
+    ConvertIntToDecimalStringN(gStringVar1, seconds, 2, 2);
+    dest = StringCopy(dest, gStringVar1);
+
+    PrintTextOnWindow(windowId, 1, gStringVar4, x, y, TEXT_SPEED_FF, NULL);
+}
+
+static void ShowChooseTimeWindow(u8 windowId, u16 days, u8 hours, u8 minutes, u8 seconds)
+{
+    SetWindowBorderStyle(windowId, FALSE, 0x214, 0xE);
+    PrintTime(windowId, 0, 1, days, hours, minutes, seconds);
+    PrintTextOnWindow(windowId, 1, gText_Confirm2, 126, 1, 0, NULL);
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+static bool32 MoveTimeUpDown(s16 *val, int minVal, int maxVal, u16 keys)
+{
+    if (keys & DPAD_DOWN)
+    {
+        *val -= 1;
+        if (*val < minVal)
+            *val = maxVal;
+    }
+    else if (keys & DPAD_UP)
+    {
+        *val += 1;
+        if (*val > maxVal)
+            *val = minVal;
+    }
+    else if (keys & DPAD_LEFT)
+    {
+        *val -= 10;
+        if (*val < minVal)
+            *val = maxVal;
+    }
+    else if (keys & DPAD_RIGHT)
+    {
+        *val += 10;
+        if (*val > maxVal)
+            *val = minVal;
+    }
+    else
+    {
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void Task_ResetRtc_3(u8 taskId)
+{
+    gTasks[taskId].data[0] = 1;
+}
+
+static void Task_ResetRtc_2(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    HideChooseTimeWindow(data[8]);
+    FreeCursorPalette();
+    gTasks[taskId].func = Task_ResetRtc_3;
+}
+
+static void Task_ResetRtc_1(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    u8 selection = data[2];
+    const struct ResetRtcStruct *selectionInfo = &sUnknown_08510428[selection - 1];
+
+    if (gMain.newKeys & B_BUTTON)
+    {
+        gTasks[taskId].func = Task_ResetRtc_2;
+        data[1] = 0;
+        data[2] = 6;
+        PlaySE(SE_SELECT);
+        return;
+    }
+
+    if (gMain.newKeys & DPAD_RIGHT)
+    {
+        if (selectionInfo->right)
+        {
+            data[2] = selectionInfo->right;
+            PlaySE(SE_SELECT);
+            return;
+        }
+    }
+
+    if (gMain.newKeys & DPAD_LEFT)
+    {
+        if (selectionInfo->left)
+        {
+            data[2] = selectionInfo->left;
+            PlaySE(SE_SELECT);
+            return;
+        }
+    }
+
+    if (selection == 5)
+    {
+        if (gMain.newKeys & A_BUTTON)
+        {
+            gLocalTime.days = data[3];
+            gLocalTime.hours = data[4];
+            gLocalTime.minutes = data[5];
+            gLocalTime.seconds = data[6];
+            PlaySE(SE_SELECT);
+            gTasks[taskId].func = Task_ResetRtc_2;
+            data[1] = 1;
+            data[2] = 6;
+        }
+    }
+    else if (MoveTimeUpDown(&data[selectionInfo->dataIndex], selectionInfo->minVal, selectionInfo->maxVal, gMain.newAndRepeatedKeys & (DPAD_UP | DPAD_DOWN)))
+    {
+        PlaySE(SE_SELECT);
+        PrintTime(data[8], 0, 1, data[3], data[4], data[5], data[6]);
+        CopyWindowToVram(data[8], 2);
+    }
+}
+
+static void Task_ResetRtc_0(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    data[0] = 0;
+    data[3] = gLocalTime.days;
+    data[4] = gLocalTime.hours;
+    data[5] = gLocalTime.minutes;
+    data[6] = gLocalTime.seconds;
+    data[8] = AddWindow(&sUnknown_08510420);
+    ShowChooseTimeWindow(data[8], data[3], data[4], data[5], data[6]);
+    CreateCursor(taskId);
+    data[2] = 2;
+    gTasks[taskId].func = Task_ResetRtc_1;
+}
+
+void CB2_InitResetRtcScreen(void)
+{
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    SetVBlankCallback(NULL);
+    DmaClear16(3, PLTT, PLTT_SIZE);
+    DmaFillLarge16(3, 0, (u8 *)VRAM, 0x18000, 0x1000);
+    ResetOamRange(0, 128);
+    LoadOam();
+    ScanlineEffect_Stop();
+    ScanlineEffect_Clear();
+    ResetSpriteData();
+    ResetTasks();
+    ResetPaletteFade();
+    sub_809F048();
+    SetVBlankCallback(VBlankCB);
+    SetMainCallback2(CB2_ResetRtcScreen);
+    CreateTask(Task_ResetRtcScreen, 80);
+}
+
+static void sub_809F048(void)
+{
+    clear_scheduled_bg_copies_to_vram();
+    ResetBgsAndClearDma3BusyFlags(0);
+    InitBgsFromTemplates(0, sBackgroundTemplates, ARRAY_COUNT(sBackgroundTemplates));
+    schedule_bg_copy_tilemap_to_vram(0);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+    ShowBg(0);
+    InitWindows(sUnknown_08510408);
+    DeactivateAllTextPrinters();
+    sub_81973A4();
+}
+
+static void CB2_ResetRtcScreen(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    do_scheduled_bg_tilemap_copies_to_vram();
+    UpdatePaletteFade();
+}
+
+static void VBlankCB(void)
+{
+    ProcessSpriteCopyRequests();
+    LoadOam();
+    TransferPlttBuffer();
+}
+
+static void ShowMessage(const u8 *str)
+{
+    sub_8197B1C(1, FALSE, 0x200, 0xF);
+    PrintTextOnWindow(1, 1, str, 0, 1, 0, NULL);
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+static void Task_ShowResetRtcPrompt(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+    case 0:
+        SetWindowBorderStyle(0, FALSE, 0x214, 0xE);
+        PrintTextOnWindow(0, 1, gText_PresentTime, 0, 1, TEXT_SPEED_FF, 0);
+        PrintTime(
+            0,
+            0,
+            17,
+            gLocalTime.days,
+            gLocalTime.hours,
+            gLocalTime.minutes,
+            gLocalTime.seconds);
+        PrintTextOnWindow(0, 1, gText_PreviousTime, 0, 33, TEXT_SPEED_FF, 0);
+        PrintTime(
+            0,
+            0,
+            49,
+            gSaveBlock2Ptr->lastBerryTreeUpdate.days,
+            gSaveBlock2Ptr->lastBerryTreeUpdate.hours,
+            gSaveBlock2Ptr->lastBerryTreeUpdate.minutes,
+            gSaveBlock2Ptr->lastBerryTreeUpdate.seconds);
+        ShowMessage(gText_ResetRTCConfirmCancel);
+        CopyWindowToVram(0, 2);
+        schedule_bg_copy_tilemap_to_vram(0);
+        data[0]++;
+    case 1:
+        if (gMain.newKeys & B_BUTTON)
+        {
+            DestroyTask(taskId);
+            DoSoftReset();
+        }
+        else if (gMain.newKeys & A_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+static void Task_ResetRtcScreen(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+    case 0:
+        BeginNormalPaletteFade(-1, 1, 0x10, 0, 0xFFFF);
+        data[0] = 1;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+        {
+            if (gSaveFileStatus == 0 || gSaveFileStatus == 2)
+            {
+                ShowMessage(gText_NoSaveFileCantSetTime);
+                data[0] = 5;
+            }
+            else
+            {
+                RtcCalcLocalTime();
+                data[1] = CreateTask(Task_ShowResetRtcPrompt, 80);
+                data[0] = 2;
+            }
+        }
+        break;
+    case 2:
+        if (gTasks[data[1]].isActive != TRUE)
+        {
+            sub_8198070(0, FALSE);
+            ShowMessage(gText_PleaseResetTime);
+            gLocalTime = gSaveBlock2Ptr->lastBerryTreeUpdate;
+            data[1] = CreateTask(Task_ResetRtc_0, 80);
+            data[0] = 3;
+        }
+        break;
+    case 3:
+        if (gTasks[data[1]].data[0])
+        {
+            if (!gTasks[data[1]].data[1])
+            {
+                DestroyTask(data[1]);
+                data[0] = 2;
+            }
+            else
+            {
+                DestroyTask(data[1]);
+                RtcReset();
+                RtcCalcLocalTimeOffset(
+                    gLocalTime.days,
+                    gLocalTime.hours,
+                    gLocalTime.minutes,
+                    gLocalTime.seconds);
+                gSaveBlock2Ptr->lastBerryTreeUpdate = gLocalTime;
+                VarSet(VAR_DAYS, gLocalTime.days);
+                DisableResetRTC();
+                ShowMessage(gText_ClockHasBeenReset);
+                data[0] = 4;
+            }
+        }
+        break;
+    case 4:
+        if (TrySavingData(0) == 1)
+        {
+            ShowMessage(gText_SaveCompleted);
+            PlaySE(SE_PINPON);
+        }
+        else
+        {
+            ShowMessage(gText_SaveFailed);
+            PlaySE(SE_BOO);
+        }
+        data[0] = 5;
+    case 5:
+        if (gMain.newKeys & A_BUTTON)
+        {
+            BeginNormalPaletteFade(-1, 1, 0, 0x10, 0xFFFF);
+            data[0] = 6;
+        }
+        else
+        {
+            break;
+        }
+    case 6:
+        if (!gPaletteFade.active)
+        {
+            DestroyTask(taskId);
+            FreeAllWindowBuffers();
+            DoSoftReset();
+        }
+    }
+}

src/reshow_battle_screen.c

@@ -3,7 +3,7 @@
 #include "battle.h"
 #include "palette.h"
 #include "main.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "text.h"
 #include "gpu_regs.h"
 #include "bg.h"
@@ -22,32 +22,32 @@ extern u16 gBattle_BG2_Y;
 extern u16 gBattle_BG3_X;
 extern u16 gBattle_BG3_Y;
 extern u8 gReservedSpritePaletteCount;
-extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT];
+extern u8 gActionSelectionCursor[MAX_BATTLERS_COUNT];
 extern u8 gBankInMenu;
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern u8 gNoOfAllBanks;
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern u8 gBattlersCount;
 extern u32 gBattleTypeFlags;
-extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT];
-extern u8 gBattleMonForms[BATTLE_BANKS_COUNT];
-extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT];
+extern u8 gBattlerSpriteIds[MAX_BATTLERS_COUNT];
+extern u8 gBattleMonForms[MAX_BATTLERS_COUNT];
+extern u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT];
 extern struct SpriteTemplate gUnknown_0202499C;
 
 extern const union AnimCmd * const * const gMonAnimationsSpriteAnimsPtrTable[];
 
-extern void dp12_8087EA4(void);
+extern void ScanlineEffect_Clear(void);
 extern void sub_8035658(void);
 extern bool8 IsDoubleBattle(void);
 extern u8 GetSubstituteSpriteDefault_Y(u8 bank);
-extern u8 GetBankSpriteDefault_Y(u8 bank);
+extern u8 GetBattlerSpriteDefault_Y(u8 bank);
 extern u8 sub_80A82E4(u8 bank);
 extern void sub_806A068(u16 species, u8 bankIdentity);
 extern void sub_806A12C(u16 backPicId, u8 bankIdentity);
-extern u8 GetBankPosition(u8 bank, u8 caseId);
+extern u8 GetBattlerSpriteCoord(u8 bank, u8 caseId);
 
 // this file's functions
 static void CB2_ReshowBattleScreenAfterMenu(void);
-static bool8 LoadBankSpriteGfx(u8 bank);
-static void CreateBankSprite(u8 bank);
+static bool8 LoadBattlerSpriteGfx(u8 bank);
+static void CreateBattlerSprite(u8 bank);
 static void CreateHealthboxSprite(u8 bank);
 static void sub_80A95F4(void);
 
@@ -72,7 +72,7 @@ static void CB2_ReshowBattleScreenAfterMenu(void)
     switch (gBattleScripting.reshowMainState)
     {
     case 0:
-        dp12_8087EA4();
+        ScanlineEffect_Clear();
         sub_8035658();
         SetBgAttribute(1, BG_CTRL_ATTR_VISIBLE, 0);
         SetBgAttribute(2, BG_CTRL_ATTR_VISIBLE, 0);
@@ -118,32 +118,32 @@ static void CB2_ReshowBattleScreenAfterMenu(void)
         }
         break;
     case 7:
-        if (!LoadBankSpriteGfx(0))
+        if (!LoadBattlerSpriteGfx(0))
             gBattleScripting.reshowMainState--;
         break;
     case 8:
-        if (!LoadBankSpriteGfx(1))
+        if (!LoadBattlerSpriteGfx(1))
             gBattleScripting.reshowMainState--;
         break;
     case 9:
-        if (!LoadBankSpriteGfx(2))
+        if (!LoadBattlerSpriteGfx(2))
             gBattleScripting.reshowMainState--;
         break;
     case 10:
-        if (!LoadBankSpriteGfx(3))
+        if (!LoadBattlerSpriteGfx(3))
             gBattleScripting.reshowMainState--;
         break;
     case 11:
-        CreateBankSprite(0);
+        CreateBattlerSprite(0);
         break;
     case 12:
-        CreateBankSprite(1);
+        CreateBattlerSprite(1);
         break;
     case 13:
-        CreateBankSprite(2);
+        CreateBattlerSprite(2);
         break;
     case 14:
-        CreateBankSprite(3);
+        CreateBattlerSprite(3);
         break;
     case 15:
         CreateHealthboxSprite(0);
@@ -164,15 +164,15 @@ static void CB2_ReshowBattleScreenAfterMenu(void)
 
             LoadAndCreateEnemyShadowSprites();
 
-            opponentBank = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
-            species = GetMonData(&gEnemyParty[gBattlePartyID[opponentBank]], MON_DATA_SPECIES);
-            SetBankEnemyShadowSpriteCallback(opponentBank, species);
+            opponentBank = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
+            species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[opponentBank]], MON_DATA_SPECIES);
+            SetBattlerShadowSpriteCallback(opponentBank, species);
 
             if (IsDoubleBattle())
             {
-                opponentBank = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
-                species = GetMonData(&gEnemyParty[gBattlePartyID[opponentBank]], MON_DATA_SPECIES);
-                SetBankEnemyShadowSpriteCallback(opponentBank, species);
+                opponentBank = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
+                species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[opponentBank]], MON_DATA_SPECIES);
+                SetBattlerShadowSpriteCallback(opponentBank, species);
             }
 
             ActionSelectionCreateCursorAt(gActionSelectionCursor[gBankInMenu], 0);
@@ -208,25 +208,25 @@ static void sub_80A95F4(void)
     regBgcnt2->charBaseBlock = 0;
 }
 
-static bool8 LoadBankSpriteGfx(u8 bank)
+static bool8 LoadBattlerSpriteGfx(u8 battler)
 {
-    if (bank < gNoOfAllBanks)
+    if (battler < gBattlersCount)
     {
-        if (GetBankSide(bank) != SIDE_PLAYER)
+        if (GetBattlerSide(battler) != B_SIDE_PLAYER)
         {
-            if (!gBattleSpritesDataPtr->bankData[bank].behindSubstitute)
-                BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[bank]], bank);
+            if (!gBattleSpritesDataPtr->battlerData[battler].behindSubstitute)
+                BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battler]], battler);
             else
-                BattleLoadSubstituteOrMonSpriteGfx(bank, FALSE);
+                BattleLoadSubstituteOrMonSpriteGfx(battler, FALSE);
         }
-        else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0)
-            DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, bank);
-        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0)
-            DecompressTrainerBackPic(BACK_PIC_WALLY, bank);
-        else if (!gBattleSpritesDataPtr->bankData[bank].behindSubstitute)
-            BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[bank]], bank);
+        else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && battler == 0)
+            DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, battler);
+        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && battler == 0)
+            DecompressTrainerBackPic(BACK_PIC_WALLY, battler);
+        else if (!gBattleSpritesDataPtr->battlerData[battler].behindSubstitute)
+            BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
         else
-            BattleLoadSubstituteOrMonSpriteGfx(bank, FALSE);
+            BattleLoadSubstituteOrMonSpriteGfx(battler, FALSE);
 
         gBattleScripting.reshowHelperState = 0;
     }
@@ -243,111 +243,111 @@ struct MonCoords
 };
 extern const struct MonCoords gTrainerBackPicCoords[];
 
-static void CreateBankSprite(u8 bank)
+static void CreateBattlerSprite(u8 battler)
 {
-    if (bank < gNoOfAllBanks)
+    if (battler < gBattlersCount)
     {
         u8 posY;
 
-        if (gBattleSpritesDataPtr->bankData[bank].behindSubstitute)
-            posY = GetSubstituteSpriteDefault_Y(bank);
+        if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute)
+            posY = GetSubstituteSpriteDefault_Y(battler);
         else
-            posY = GetBankSpriteDefault_Y(bank);
+            posY = GetBattlerSpriteDefault_Y(battler);
 
-        if (GetBankSide(bank) != SIDE_PLAYER)
+        if (GetBattlerSide(battler) != B_SIDE_PLAYER)
         {
-            if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+            if (GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_HP) == 0)
                 return;
 
-            sub_806A068(GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES), GetBankIdentity(bank));
-            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, GetBankPosition(bank, 2), posY, sub_80A82E4(bank));
-            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
-            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
-            gSprites[gBankSpriteIds[bank]].data[0] = bank;
-            gSprites[gBankSpriteIds[bank]].data[2] = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES);
+            sub_806A068(GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES), GetBattlerPosition(battler));
+            gBattlerSpriteIds[battler] = CreateSprite(&gUnknown_0202499C, GetBattlerSpriteCoord(battler, 2), posY, sub_80A82E4(battler));
+            gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+            gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
+            gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
+            gSprites[gBattlerSpriteIds[battler]].data[2] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
 
-            StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]);
-            if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_CASTFORM)
-                gSprites[gBankSpriteIds[bank]].anims = gMonAnimationsSpriteAnimsPtrTable[SPECIES_CASTFORM];
+            StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
+            if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies == SPECIES_CASTFORM)
+                gSprites[gBattlerSpriteIds[battler]].anims = gMonAnimationsSpriteAnimsPtrTable[SPECIES_CASTFORM];
         }
-        else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0)
+        else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && battler == 0)
         {
-            sub_806A12C(gSaveBlock2Ptr->playerGender, GetBankIdentity(IDENTITY_PLAYER_MON1));
-            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, 0x50,
+            sub_806A12C(gSaveBlock2Ptr->playerGender, GetBattlerPosition(B_POSITION_PLAYER_LEFT));
+            gBattlerSpriteIds[battler] = CreateSprite(&gUnknown_0202499C, 0x50,
                                                 (8 - gTrainerBackPicCoords[gSaveBlock2Ptr->playerGender].coords) * 4 + 80,
                                                  sub_80A82E4(0));
-            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
-            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
-            gSprites[gBankSpriteIds[bank]].data[0] = bank;
+            gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+            gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
+            gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
         }
-        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0)
+        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && battler == 0)
         {
-            sub_806A12C(BACK_PIC_WALLY, GetBankIdentity(0));
-            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, 0x50,
+            sub_806A12C(BACK_PIC_WALLY, GetBattlerPosition(0));
+            gBattlerSpriteIds[battler] = CreateSprite(&gUnknown_0202499C, 0x50,
                                                 (8 - gTrainerBackPicCoords[BACK_PIC_WALLY].coords) * 4 + 80,
                                                  sub_80A82E4(0));
-            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
-            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
-            gSprites[gBankSpriteIds[bank]].data[0] = bank;
+            gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+            gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
+            gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
         }
         else
         {
-            if (GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+            if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_HP) == 0)
                 return;
 
-            sub_806A068(GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES), GetBankIdentity(bank));
-            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, GetBankPosition(bank, 2), posY, sub_80A82E4(bank));
-            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
-            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
-            gSprites[gBankSpriteIds[bank]].data[0] = bank;
-            gSprites[gBankSpriteIds[bank]].data[2] = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES);
+            sub_806A068(GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES), GetBattlerPosition(battler));
+            gBattlerSpriteIds[battler] = CreateSprite(&gUnknown_0202499C, GetBattlerSpriteCoord(battler, 2), posY, sub_80A82E4(battler));
+            gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+            gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
+            gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
+            gSprites[gBattlerSpriteIds[battler]].data[2] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
 
-            StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]);
-            if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_CASTFORM)
-                gSprites[gBankSpriteIds[bank]].anims = gMonAnimationsSpriteAnimsPtrTable[SPECIES_CASTFORM];
+            StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
+            if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies == SPECIES_CASTFORM)
+                gSprites[gBattlerSpriteIds[battler]].anims = gMonAnimationsSpriteAnimsPtrTable[SPECIES_CASTFORM];
         }
 
-        gSprites[gBankSpriteIds[bank]].invisible = gBattleSpritesDataPtr->bankData[bank].invisible;
+        gSprites[gBattlerSpriteIds[battler]].invisible = gBattleSpritesDataPtr->battlerData[battler].invisible;
     }
 }
 
-static void CreateHealthboxSprite(u8 bank)
+static void CreateHealthboxSprite(u8 battler)
 {
-    if (bank < gNoOfAllBanks)
+    if (battler < gBattlersCount)
     {
         u8 healthboxSpriteId;
 
-        if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0)
+        if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && battler == 0)
             healthboxSpriteId = CreateSafariPlayerHealthboxSprites();
-        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0)
+        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && battler == 0)
             return;
         else
-            healthboxSpriteId = CreateBankHealthboxSprites(bank);
+            healthboxSpriteId = CreateBattlerHealthboxSprites(battler);
 
-        gHealthBoxesIds[bank] = healthboxSpriteId;
-        SetBankHealthboxSpritePos(bank);
+        gHealthboxSpriteIds[battler] = healthboxSpriteId;
+        InitBattlerHealthboxCoords(battler);
         SetHealthboxSpriteVisible(healthboxSpriteId);
 
-        if (GetBankSide(bank) != SIDE_PLAYER)
-            UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gEnemyParty[gBattlePartyID[bank]], HEALTHBOX_ALL);
+        if (GetBattlerSide(battler) != B_SIDE_PLAYER)
+            UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gEnemyParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL);
         else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
-            UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[gBattlePartyID[bank]], HEALTHBOX_SAFARI_ALL_TEXT);
+            UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_SAFARI_ALL_TEXT);
         else
-            UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[gBattlePartyID[bank]], HEALTHBOX_ALL);
+            UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL);
 
-        if (GetBankIdentity(bank) == IDENTITY_OPPONENT_MON2 || GetBankIdentity(bank) == IDENTITY_PLAYER_MON2)
-            DummyBattleInterfaceFunc(gHealthBoxesIds[bank], TRUE);
+        if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_RIGHT || GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT)
+            DummyBattleInterfaceFunc(gHealthboxSpriteIds[battler], TRUE);
         else
-            DummyBattleInterfaceFunc(gHealthBoxesIds[bank], FALSE);
+            DummyBattleInterfaceFunc(gHealthboxSpriteIds[battler], FALSE);
 
-        if (GetBankSide(bank) != SIDE_PLAYER)
+        if (GetBattlerSide(battler) != B_SIDE_PLAYER)
         {
-            if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+            if (GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_HP) == 0)
                 SetHealthboxSpriteInvisible(healthboxSpriteId);
         }
         else if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI))
         {
-            if (GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+            if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_HP) == 0)
                 SetHealthboxSpriteInvisible(healthboxSpriteId);
         }
     }

src/safari_zone.c

@@ -108,20 +108,20 @@ void SafariZoneRetirePrompt(void)
 void CB2_EndSafariBattle(void)
 {
     sSafariZoneFleedMons += gBattleResults.field_1F;
-    if (gBattleOutcome == BATTLE_CAUGHT)
+    if (gBattleOutcome == B_OUTCOME_CAUGHT_POKE)
         sSafariZoneCaughtMons++;
     if (gNumSafariBalls != 0)
     {
         SetMainCallback2(c2_exit_to_overworld_2_switch);
     }
-    else if (gBattleOutcome == BATTLE_SAFARI_OUT_OF_BALLS)
+    else if (gBattleOutcome == B_OUTCOME_NO_SAFARI_BALLS)
     {
         ScriptContext2_RunNewScript(EventScript_2A4B4C);
         warp_in();
         gFieldCallback = sub_80AF6F0;
         SetMainCallback2(c2_load_new_map);
     }
-    else if (gBattleOutcome == BATTLE_CAUGHT)
+    else if (gBattleOutcome == B_OUTCOME_CAUGHT_POKE)
     {
         ScriptContext1_SetupScript(EventScript_2A4B9B);
         ScriptContext1_Stop();

src/save.c

@@ -4,13 +4,68 @@
 #include "constants/game_stat.h"
 #include "task.h"
 
+// for the chunk declarations
+extern struct SaveBlock2 gSaveblock2;
+extern struct SaveBlock1 gSaveblock1;
+extern struct PokemonStorage gPokemonStorage;
+
 extern struct SaveSectionLocation gRamSaveSectionLocations[0xE];
 extern u8 gDecompressionBuffer[];
 extern u32 gFlashMemoryPresent;
 extern u16 gUnknown_03006294;
 extern bool8 gSoftResetDisabled;
 
-extern const struct SaveSectionOffsets gSaveSectionOffsets[0xE];
+// Divide save blocks into individual chunks to be written to flash sectors
+
+// Each 4 KiB flash sector contains 3968 bytes of actual data followed by a 128 byte footer
+#define SECTOR_DATA_SIZE 3968
+#define SECTOR_FOOTER_SIZE 128
+
+/*
+ * Sector Layout:
+ * 
+ * Sectors 0 - 13:      Save Slot 1
+ * Sectors 14 - 27:     Save Slot 2
+ * Sectors 28 - 29:     Hall of Fame
+ * Sector 30:           e-Reader/Mystery Gift Stuff (note: e-Reader is deprecated in Emerald US)
+ * Sector 31:           Recorded Battle
+ * 
+ * There are two save slots for saving the player's game data. We alternate between
+ * them each time the game is saved, so that if the current save slot is corrupt,
+ * we can load the previous one. We also rotate the sectors in each save slot
+ * so that the same data is not always being written to the same sector. This
+ * might be done to reduce wear on the flash memory, but I'm not sure, since all
+ * 14 sectors get written anyway.
+ */
+
+// (u8 *)structure was removed from the first statement of the macro in Emerald.
+// This is because malloc is used to allocate addresses so storing the raw
+// addresses should not be done in the offsets information. 
+#define SAVEBLOCK_CHUNK(structure, chunkNum)                                \
+{                                                                           \
+    chunkNum * SECTOR_DATA_SIZE,                                            \
+    min(sizeof(structure) - chunkNum * SECTOR_DATA_SIZE, SECTOR_DATA_SIZE)  \
+}                                                                           \
+
+const struct SaveSectionOffsets gSaveSectionOffsets[] =
+{
+    SAVEBLOCK_CHUNK(gSaveblock2, 0),
+
+    SAVEBLOCK_CHUNK(gSaveblock1, 0),
+    SAVEBLOCK_CHUNK(gSaveblock1, 1),
+    SAVEBLOCK_CHUNK(gSaveblock1, 2),
+    SAVEBLOCK_CHUNK(gSaveblock1, 3),
+
+    SAVEBLOCK_CHUNK(gPokemonStorage, 0),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 1),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 2),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 3),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 4),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 5),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 6),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 7),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 8),
+};
 
 extern void DoSaveFailedScreen(u8); // save_failed_screen
 extern void LoadSerializedGame(void); // load_save

src/scanline_effect.c

@@ -0,0 +1,262 @@
+#include "global.h"
+#include "data2.h"
+#include "task.h"
+#include "trig.h"
+#include "scanline_effect.h"
+
+static void CopyValue16Bit(void);
+static void CopyValue32Bit(void);
+
+extern u16 gBattle_BG0_Y;
+extern u16 gBattle_BG0_X;
+extern u16 gBattle_BG1_X;
+extern u16 gBattle_BG1_Y;
+extern u16 gBattle_BG2_X;
+extern u16 gBattle_BG2_Y;
+extern u16 gBattle_BG3_X;
+extern u16 gBattle_BG3_Y;
+
+// EWRAM vars
+
+// Per-scanline register values.
+// This is double buffered so that it can be safely written to at any time
+// without overwriting the buffer that the DMA is currently reading
+EWRAM_DATA u16 gScanlineEffectRegBuffers[2][0x3C0] = {0};
+
+EWRAM_DATA struct ScanlineEffect gScanlineEffect = {0};
+EWRAM_DATA static bool8 sShouldStopWaveTask = FALSE;
+
+void ScanlineEffect_Stop(void)
+{
+    gScanlineEffect.state = 0;
+    DmaStop(0);
+    if (gScanlineEffect.waveTaskId != 0xFF)
+    {
+        DestroyTask(gScanlineEffect.waveTaskId);
+        gScanlineEffect.waveTaskId = 0xFF;
+    }
+}
+
+void ScanlineEffect_Clear(void)
+{
+    CpuFill16(0, gScanlineEffectRegBuffers, sizeof(gScanlineEffectRegBuffers));
+    gScanlineEffect.dmaSrcBuffers[0] = NULL;
+    gScanlineEffect.dmaSrcBuffers[1] = NULL;
+    gScanlineEffect.dmaDest = NULL;
+    gScanlineEffect.dmaControl = 0;
+    gScanlineEffect.srcBuffer = 0;
+    gScanlineEffect.state = 0;
+    gScanlineEffect.unused16 = 0;
+    gScanlineEffect.unused17 = 0;
+    gScanlineEffect.waveTaskId = 0xFF;
+}
+
+void ScanlineEffect_SetParams(struct ScanlineEffectParams params)
+{
+    if (params.dmaControl == SCANLINE_EFFECT_DMACNT_16BIT)  // 16-bit
+    {
+        // Set the DMA src to the value for the second scanline because the
+        // first DMA transfer occurs in HBlank *after* the first scanline is drawn
+        gScanlineEffect.dmaSrcBuffers[0] = (u16 *)gScanlineEffectRegBuffers[0] + 1;
+        gScanlineEffect.dmaSrcBuffers[1] = (u16 *)gScanlineEffectRegBuffers[1] + 1;
+        gScanlineEffect.setFirstScanlineReg = CopyValue16Bit;
+    }
+    else  // assume 32-bit
+    {
+        // Set the DMA src to the value for the second scanline because the
+        // first DMA transfer occurs in HBlank *after* the first scanline is drawn
+        gScanlineEffect.dmaSrcBuffers[0] = (u32 *)gScanlineEffectRegBuffers[0] + 1;
+        gScanlineEffect.dmaSrcBuffers[1] = (u32 *)gScanlineEffectRegBuffers[1] + 1;
+        gScanlineEffect.setFirstScanlineReg = CopyValue32Bit;
+    }
+
+    gScanlineEffect.dmaControl = params.dmaControl;
+    gScanlineEffect.dmaDest    = params.dmaDest;
+    gScanlineEffect.state      = params.initState;
+    gScanlineEffect.unused16   = params.unused9;
+    gScanlineEffect.unused17   = params.unused9;
+}
+
+void ScanlineEffect_InitHBlankDmaTransfer(void)
+{
+    if (gScanlineEffect.state == 0)
+    {
+        return;
+    }
+    else if (gScanlineEffect.state == 3)
+    {
+        gScanlineEffect.state = 0;
+        DmaStop(0);
+        sShouldStopWaveTask = TRUE;
+    }
+    else
+    {
+        DmaStop(0);
+        // Set DMA to copy to dest register on each HBlank for the next frame.
+        // The HBlank DMA transfers do not occurr during VBlank, so the transfer
+        // will begin on the HBlank after the first scanline
+        DmaSet(0, gScanlineEffect.dmaSrcBuffers[gScanlineEffect.srcBuffer], gScanlineEffect.dmaDest, gScanlineEffect.dmaControl);
+        // Manually set the reg for the first scanline
+        gScanlineEffect.setFirstScanlineReg();
+        // Swap current buffer
+        gScanlineEffect.srcBuffer ^= 1;
+    }
+}
+
+// These two functions are used to copy the register for the first scanline,
+// depending whether it is a 16-bit register or a 32-bit register.
+
+static void CopyValue16Bit(void)
+{
+    u16 *dest = (u16 *)gScanlineEffect.dmaDest;
+    u16 *src = (u16 *)&gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer];
+
+    *dest = *src;
+}
+
+static void CopyValue32Bit(void)
+{
+    u32 *dest = (u32 *)gScanlineEffect.dmaDest;
+    u32 *src = (u32 *)&gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer];
+
+    *dest = *src;
+}
+
+#define tStartLine            data[0]
+#define tEndLine              data[1]
+#define tWaveLength           data[2]
+#define tSrcBufferOffset      data[3]
+#define tFramesUntilMove      data[4]
+#define tDelayInterval        data[5]
+#define tRegOffset            data[6]
+#define tApplyBattleBgOffsets data[7]
+
+static void TaskFunc_UpdateWavePerFrame(u8 taskId)
+{
+    int value = 0;
+    int i;
+    int offset;
+
+    if (sShouldStopWaveTask)
+    {
+        DestroyTask(taskId);
+        gScanlineEffect.waveTaskId = 0xFF;
+    }
+    else
+    {
+        if (gTasks[taskId].tApplyBattleBgOffsets)
+        {
+            switch (gTasks[taskId].tRegOffset)
+            {
+            case SCANLINE_EFFECT_REG_BG0HOFS:
+                value = gBattle_BG0_X;
+                break;
+            case SCANLINE_EFFECT_REG_BG0VOFS:
+                value = gBattle_BG0_Y;
+                break;
+            case SCANLINE_EFFECT_REG_BG1HOFS:
+                value = gBattle_BG1_X;
+                break;
+            case SCANLINE_EFFECT_REG_BG1VOFS:
+                value = gBattle_BG1_Y;
+                break;
+            case SCANLINE_EFFECT_REG_BG2HOFS:
+                value = gBattle_BG2_X;
+                break;
+            case SCANLINE_EFFECT_REG_BG2VOFS:
+                value = gBattle_BG2_Y;
+                break;
+            case SCANLINE_EFFECT_REG_BG3HOFS:
+                value = gBattle_BG3_X;
+                break;
+            case SCANLINE_EFFECT_REG_BG3VOFS:
+                value = gBattle_BG3_Y;
+                break;
+            }
+        }
+        if (gTasks[taskId].tFramesUntilMove != 0)
+        {
+            gTasks[taskId].tFramesUntilMove--;
+            offset = gTasks[taskId].tSrcBufferOffset + 320;
+            for (i = gTasks[taskId].tStartLine; i < gTasks[taskId].tEndLine; i++)
+            {
+                gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer][i] = gScanlineEffectRegBuffers[0][offset] + value;
+                offset++;
+            }
+        }
+        else
+        {
+            gTasks[taskId].tFramesUntilMove = gTasks[taskId].tDelayInterval;
+            offset = gTasks[taskId].tSrcBufferOffset + 320;
+            for (i = gTasks[taskId].tStartLine; i < gTasks[taskId].tEndLine; i++)
+            {
+                gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer][i] = gScanlineEffectRegBuffers[0][offset] + value;
+                offset++;
+            }
+
+            // increment src buffer offset
+            gTasks[taskId].tSrcBufferOffset++;
+            if (gTasks[taskId].tSrcBufferOffset == gTasks[taskId].tWaveLength)
+                gTasks[taskId].tSrcBufferOffset = 0;
+        }
+    }
+}
+
+static void GenerateWave(u16 *buffer, u8 frequency, u8 amplitude, u8 unused)
+{
+    u16 i = 0;
+    u8 theta = 0;
+
+    while (i < 256)
+    {
+        buffer[i] = (gSineTable[theta] * amplitude) / 256;
+        theta += frequency;
+        i++;
+    }
+}
+
+// Initializes a background "wave" effect that affects scanlines startLine (inclusive) to endLine (exclusive).
+// 'frequency' and 'amplitude' control the frequency and amplitude of the wave.
+// 'delayInterval' controls how fast the wave travels up the screen. The wave will shift upwards one scanline every 'delayInterval'+1 frames.
+// 'regOffset' is the offset of the video register to modify.
+u8 ScanlineEffect_InitWave(u8 startLine, u8 endLine, u8 frequency, u8 amplitude, u8 delayInterval, u8 regOffset, bool8 applyBattleBgOffsets)
+{
+    int i;
+    int offset;
+    struct ScanlineEffectParams params;
+    u8 taskId;
+
+    ScanlineEffect_Clear();
+
+    params.dmaDest = (void *)(REG_ADDR_BG0HOFS + regOffset);
+    params.dmaControl = SCANLINE_EFFECT_DMACNT_16BIT;
+    params.initState = 1;
+    params.unused9 = 0;
+    ScanlineEffect_SetParams(params);
+
+    taskId = CreateTask(TaskFunc_UpdateWavePerFrame, 0);
+
+    gTasks[taskId].tStartLine            = startLine;
+    gTasks[taskId].tEndLine              = endLine;
+    gTasks[taskId].tWaveLength           = 256 / frequency;
+    gTasks[taskId].tSrcBufferOffset      = 0;
+    gTasks[taskId].tFramesUntilMove      = delayInterval;
+    gTasks[taskId].tDelayInterval        = delayInterval;
+    gTasks[taskId].tRegOffset            = regOffset;
+    gTasks[taskId].tApplyBattleBgOffsets = applyBattleBgOffsets;
+
+    gScanlineEffect.waveTaskId = taskId;
+    sShouldStopWaveTask = FALSE;
+
+    GenerateWave(&gScanlineEffectRegBuffers[0][320], frequency, amplitude, endLine - startLine);
+
+    offset = 320;
+    for (i = startLine; i < endLine; i++)
+    {
+        gScanlineEffectRegBuffers[0][i] = gScanlineEffectRegBuffers[0][offset];
+        gScanlineEffectRegBuffers[1][i] = gScanlineEffectRegBuffers[0][offset];
+        offset++;
+    }
+
+    return taskId;
+}

src/scrcmd.c

@@ -637,7 +637,7 @@ static bool8 IsPaletteNotActive(void)
 
 bool8 ScrCmd_fadescreen(struct ScriptContext *ctx)
 {
-    fade_screen(ScriptReadByte(ctx), 0);
+    FadeScreen(ScriptReadByte(ctx), 0);
     SetupNativeScript(ctx, IsPaletteNotActive);
     return TRUE;
 }
@@ -647,7 +647,7 @@ bool8 ScrCmd_fadescreenspeed(struct ScriptContext *ctx)
     u8 mode = ScriptReadByte(ctx);
     u8 speed = ScriptReadByte(ctx);
 
-    fade_screen(mode, speed);
+    FadeScreen(mode, speed);
     SetupNativeScript(ctx, IsPaletteNotActive);
     return TRUE;
 }
@@ -661,12 +661,12 @@ bool8 ScrCmd_fadescreenswapbuffers(struct ScriptContext *ctx)
         case 1:
         default:
             CpuCopy32(gPlttBufferUnfaded, gPaletteDecompressionBuffer, PLTT_DECOMP_BUFFER_SIZE);
-            fade_screen(mode, 0);
+            FadeScreen(mode, 0);
             break;
         case 0:
         case 2:
             CpuCopy32(gPaletteDecompressionBuffer, gPlttBufferUnfaded, PLTT_DECOMP_BUFFER_SIZE);
-            fade_screen(mode, 0);
+            FadeScreen(mode, 0);
             break;
     }
 
@@ -725,7 +725,7 @@ bool8 ScrCmd_setweather(struct ScriptContext *ctx)
 
 bool8 ScrCmd_resetweather(struct ScriptContext *ctx)
 {
-    sub_80AEDBC();
+    SetSav1WeatherFromCurrMapHeader();
     return FALSE;
 }
 

src/secret_base.c

@@ -12,6 +12,7 @@
 #include "menu_indicators.h"
 #include "constants/maps.h"
 #include "constants/songs.h"
+#include "constants/species.h"
 #include "sound.h"
 #include "overworld.h"
 #include "fieldmap.h"
@@ -393,7 +394,7 @@ void sub_80E8FD0(u8 taskId)
 void sub_80E9068(void)
 {
     CreateTask(sub_80E8FD0, 0);
-    fade_screen(1, 0);
+    FadeScreen(1, 0);
     saved_warp2_set(0, gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1);
 }
 
@@ -450,7 +451,7 @@ void sub_80E916C(u8 taskId)
 void sub_80E91F8(void)
 {
     CreateTask(sub_80E916C, 0);
-    fade_screen(1, 0);
+    FadeScreen(1, 0);
 }
 
 bool8 CurrentMapIsSecretBase(void)
@@ -650,7 +651,7 @@ void sub_80E96A4(u8 taskId)
 void sub_80E9728(void)
 {
     CreateTask(sub_80E96A4, 0);
-    fade_screen(1, 0);
+    FadeScreen(1, 0);
 }
 
 void sub_80E9744(void)
@@ -710,237 +711,45 @@ u8 sub_80E98AC(struct Pokemon *pokemon)
     return evTotal / 6;
 }
 
-#ifdef NONMATCHING
-// This function is a meme
 void sub_80E9914(void)
 {
-    u32 zero;
-    u32 *personality;
     u16 partyIdx;
     u16 moveIdx;
     u16 sbPartyIdx;
-    u16 *species;
-    u16 *items;
-    u16 *moves;
-    u8 *levels;
-    u8 *evs;
+    struct SecretBaseParty *party;
 
     sbPartyIdx = 0;
-    personality = gSaveBlock1Ptr->secretBases[0].partyPersonality;
+    party = &gSaveBlock1Ptr->secretBases[0].party;
     if (gSaveBlock1Ptr->secretBases[0].secretBaseId != 0)
     {
-        partyIdx = 0;
-        moves = gSaveBlock1Ptr->secretBases[0].partyMoves;
-        species = gSaveBlock1Ptr->secretBases[0].partySpecies;
-        items = gSaveBlock1Ptr->secretBases[0].partyHeldItems;
-        levels = gSaveBlock1Ptr->secretBases[0].partyLevels;
-        evs = gSaveBlock1Ptr->secretBases[0].partyEVs;
-        zero = 0;
-        for (partyIdx = 0; partyIdx < PARTY_SIZE; partyIdx ++)
+        for (partyIdx = 0; partyIdx < PARTY_SIZE; partyIdx++)
         {
-            for (moveIdx = 0; moveIdx < 4; moveIdx ++)
+            for (moveIdx = 0; moveIdx < 4; moveIdx++)
             {
-                moves[partyIdx * 4 + moveIdx] = zero;
+                party->moves[partyIdx * 4 + moveIdx] = 0;
             }
-            species[partyIdx] = zero;
-            items[partyIdx] = zero;
-            levels[partyIdx] = zero;
-            personality[partyIdx] = zero;
-            evs[partyIdx] = zero;
-            if (GetMonData(&gPlayerParty[partyIdx], MON_DATA_SPECIES) != SPECIES_NONE && !GetMonData(&gPlayerParty[partyIdx], MON_DATA_IS_EGG))
+            party->species[partyIdx] = 0;
+            party->heldItems[partyIdx] = 0;
+            party->levels[partyIdx] = 0;
+            party->personality[partyIdx] = 0;
+            party->EVs[partyIdx] = 0;
+            if (GetMonData(&gPlayerParty[partyIdx], MON_DATA_SPECIES) != SPECIES_NONE
+                && !GetMonData(&gPlayerParty[partyIdx], MON_DATA_IS_EGG))
             {
-                for (moveIdx = 0; moveIdx < 4; moveIdx ++)
+                for (moveIdx = 0; moveIdx < 4; moveIdx++)
                 {
-                    moves[sbPartyIdx * 4 + moveIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_MOVE1 + moveIdx);
+                    party->moves[sbPartyIdx * 4 + moveIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_MOVE1 + moveIdx);
                 }
-                species[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_SPECIES);
-                items[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_HELD_ITEM);
-                levels[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_LEVEL);
-                personality[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_PERSONALITY);
-                evs[sbPartyIdx] = sub_80E98AC(&gPlayerParty[partyIdx]);
-                sbPartyIdx ++;
+                party->species[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_SPECIES);
+                party->heldItems[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_HELD_ITEM);
+                party->levels[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_LEVEL);
+                party->personality[sbPartyIdx] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_PERSONALITY);
+                party->EVs[sbPartyIdx] = sub_80E98AC(&gPlayerParty[partyIdx]);
+                sbPartyIdx++;
             }
         }
     }
 }
-#else
-__attribute__((naked)) void sub_80E9914(void)
-{
-    asm_unified("\tpush {r4-r7,lr}\n"
-                    "\tmov r7, r10\n"
-                    "\tmov r6, r9\n"
-                    "\tmov r5, r8\n"
-                    "\tpush {r5-r7}\n"
-                    "\tsub sp, 0x24\n"
-                    "\tmovs r0, 0\n"
-                    "\tmov r10, r0\n"
-                    "\tldr r0, =gSaveBlock1Ptr\n"
-                    "\tldr r1, [r0]\n"
-                    "\tldr r2, =0x00001ad0\n"
-                    "\tadds r2, r1, r2\n"
-                    "\tstr r2, [sp]\n"
-                    "\tldr r3, =0x00001a9c\n"
-                    "\tadds r0, r1, r3\n"
-                    "\tldrb r0, [r0]\n"
-                    "\tcmp r0, 0\n"
-                    "\tbne _080E993A\n"
-                    "\tb _080E9A60\n"
-                    "_080E993A:\n"
-                    "\tmovs r6, 0\n"
-                    "\tldr r7, =0x00001ae8\n"
-                    "\tadds r7, r1, r7\n"
-                    "\tstr r7, [sp, 0x14]\n"
-                    "\tldr r0, =0x00001b18\n"
-                    "\tadds r0, r1, r0\n"
-                    "\tstr r0, [sp, 0xC]\n"
-                    "\tldr r2, =0x00001b24\n"
-                    "\tadds r2, r1, r2\n"
-                    "\tstr r2, [sp, 0x10]\n"
-                    "\tadds r3, 0x94\n"
-                    "\tadds r3, r1, r3\n"
-                    "\tstr r3, [sp, 0x18]\n"
-                    "\tldr r7, =0x00001b36\n"
-                    "\tadds r7, r1, r7\n"
-                    "\tstr r7, [sp, 0x1C]\n"
-                    "\tmov r9, r6\n"
-                    "_080E995C:\n"
-                    "\tmovs r4, 0\n"
-                    "\tlsls r5, r6, 2\n"
-                    "\tlsls r3, r6, 1\n"
-                    "\tldr r0, =gPlayerParty\n"
-                    "\tmov r8, r0\n"
-                    "\tadds r1, r6, 0x1\n"
-                    "\tstr r1, [sp, 0x4]\n"
-                    "\tadds r2, r5, 0\n"
-                    "\tldr r1, [sp, 0x14]\n"
-                    "_080E996E:\n"
-                    "\tadds r0, r2, r4\n"
-                    "\tlsls r0, 1\n"
-                    "\tadds r0, r1, r0\n"
-                    "\tmov r7, r9\n"
-                    "\tstrh r7, [r0]\n"
-                    "\tadds r0, r4, 0x1\n"
-                    "\tlsls r0, 16\n"
-                    "\tlsrs r4, r0, 16\n"
-                    "\tcmp r4, 0x3\n"
-                    "\tbls _080E996E\n"
-                    "\tldr r1, [sp, 0xC]\n"
-                    "\tadds r0, r1, r3\n"
-                    "\tmov r2, r9\n"
-                    "\tstrh r2, [r0]\n"
-                    "\tldr r7, [sp, 0x10]\n"
-                    "\tadds r0, r7, r3\n"
-                    "\tstrh r2, [r0]\n"
-                    "\tldr r1, [sp, 0x18]\n"
-                    "\tadds r0, r1, r6\n"
-                    "\tmov r2, r9\n"
-                    "\tstrb r2, [r0]\n"
-                    "\tldr r3, [sp]\n"
-                    "\tadds r0, r3, r5\n"
-                    "\tmov r7, r9\n"
-                    "\tstr r7, [r0]\n"
-                    "\tldr r1, [sp, 0x1C]\n"
-                    "\tadds r0, r1, r6\n"
-                    "\tstrb r7, [r0]\n"
-                    "\tmovs r2, 0x64\n"
-                    "\tadds r5, r6, 0\n"
-                    "\tmuls r5, r2\n"
-                    "\tmov r3, r8\n"
-                    "\tadds r4, r5, r3\n"
-                    "\tadds r0, r4, 0\n"
-                    "\tmovs r1, 0xB\n"
-                    "\tbl GetMonData\n"
-                    "\tcmp r0, 0\n"
-                    "\tbeq _080E9A54\n"
-                    "\tadds r0, r4, 0\n"
-                    "\tmovs r1, 0x2D\n"
-                    "\tbl GetMonData\n"
-                    "\tcmp r0, 0\n"
-                    "\tbne _080E9A54\n"
-                    "\tmovs r4, 0\n"
-                    "\tmov r7, r10\n"
-                    "\tlsls r7, 2\n"
-                    "\tmov r8, r7\n"
-                    "\tmov r0, r10\n"
-                    "\tlsls r7, r0, 1\n"
-                    "\tadds r0, 0x1\n"
-                    "\tstr r0, [sp, 0x8]\n"
-                    "\tldr r2, =gPlayerParty\n"
-                    "_080E99DA:\n"
-                    "\tadds r1, r4, 0\n"
-                    "\tadds r1, 0xD\n"
-                    "\tadds r0, r5, r2\n"
-                    "\tstr r2, [sp, 0x20]\n"
-                    "\tbl GetMonData\n"
-                    "\tmov r3, r8\n"
-                    "\tadds r1, r3, r4\n"
-                    "\tlsls r1, 1\n"
-                    "\tldr r3, [sp, 0x14]\n"
-                    "\tadds r1, r3, r1\n"
-                    "\tstrh r0, [r1]\n"
-                    "\tadds r0, r4, 0x1\n"
-                    "\tlsls r0, 16\n"
-                    "\tlsrs r4, r0, 16\n"
-                    "\tldr r2, [sp, 0x20]\n"
-                    "\tcmp r4, 0x3\n"
-                    "\tbls _080E99DA\n"
-                    "\tmovs r0, 0x64\n"
-                    "\tadds r4, r6, 0\n"
-                    "\tmuls r4, r0\n"
-                    "\tldr r0, =gPlayerParty\n"
-                    "\tadds r4, r0\n"
-                    "\tadds r0, r4, 0\n"
-                    "\tmovs r1, 0xB\n"
-                    "\tbl GetMonData\n"
-                    "\tldr r2, [sp, 0xC]\n"
-                    "\tadds r1, r2, r7\n"
-                    "\tstrh r0, [r1]\n"
-                    "\tadds r0, r4, 0\n"
-                    "\tmovs r1, 0xC\n"
-                    "\tbl GetMonData\n"
-                    "\tldr r3, [sp, 0x10]\n"
-                    "\tadds r1, r3, r7\n"
-                    "\tstrh r0, [r1]\n"
-                    "\tadds r0, r4, 0\n"
-                    "\tmovs r1, 0x38\n"
-                    "\tbl GetMonData\n"
-                    "\tldr r1, [sp, 0x18]\n"
-                    "\tadd r1, r10\n"
-                    "\tstrb r0, [r1]\n"
-                    "\tadds r0, r4, 0\n"
-                    "\tmovs r1, 0\n"
-                    "\tbl GetMonData\n"
-                    "\tldr r1, [sp]\n"
-                    "\tadd r1, r8\n"
-                    "\tstr r0, [r1]\n"
-                    "\tadds r0, r4, 0\n"
-                    "\tbl sub_80E98AC\n"
-                    "\tldr r1, [sp, 0x1C]\n"
-                    "\tadd r1, r10\n"
-                    "\tstrb r0, [r1]\n"
-                    "\tldr r7, [sp, 0x8]\n"
-                    "\tlsls r0, r7, 16\n"
-                    "\tlsrs r0, 16\n"
-                    "\tmov r10, r0\n"
-                    "_080E9A54:\n"
-                    "\tldr r1, [sp, 0x4]\n"
-                    "\tlsls r0, r1, 16\n"
-                    "\tlsrs r6, r0, 16\n"
-                    "\tcmp r6, 0x5\n"
-                    "\tbhi _080E9A60\n"
-                    "\tb _080E995C\n"
-                    "_080E9A60:\n"
-                    "\tadd sp, 0x24\n"
-                    "\tpop {r3-r5}\n"
-                    "\tmov r8, r3\n"
-                    "\tmov r9, r4\n"
-                    "\tmov r10, r5\n"
-                    "\tpop {r4-r7}\n"
-                    "\tpop {r0}\n"
-                    "\tbx r0\n"
-                    "\t.pool");
-}
-#endif
 
 void sub_80E9A90(void)
 {
@@ -1356,7 +1165,6 @@ void sub_80EA354(void)
     gSpecialVar_Result = gSaveBlock1Ptr->secretBases[secretBaseRecordId].sbr_field_1_5;
 }
 
-
 void sub_80EA3E4(u8 taskId)
 {
     s16 x;

src/sprite.c

@@ -240,12 +240,26 @@ static const AffineAnimCmdFunc sAffineAnimCmdFuncs[] =
     AffineAnimCmd_frame,
 };
 
-static const s32 sUnknown_082EC6F4[24] =
+static const s32 sUnknown_082EC6F4[3][4][2] =
 {
-    8,      8,      0x10,   0x10,   0x20,   0x20,
-    0x40,   0x40,   0x10,   8,      0x20,   8,
-    0x20,   0x10,   0x40,   0x20,   8,      0x10,
-    8,      0x20,   0x10,   0x20,   0x20,   0x40,
+    {
+        {8, 8},
+        {0x10, 0x10},
+        {0x20, 0x20},
+        {0x40, 0x40},
+    },
+    {
+        {0x10, 8},
+        {0x20, 8},
+        {0x20, 0x10},
+        {0x40, 0x20},
+    },
+    {
+        {8, 0x10},
+        {8, 0x20},
+        {0x10, 0x20},
+        {0x20, 0x40},
+    },
 };
 
 static const struct OamDimensions sOamDimensions[3][4] =
@@ -1207,106 +1221,26 @@ s32 sub_8007E28(s32 a0, s32 a1, s32 a2)
     return a2 - ((u32)(a2 * a1) / (u32)(a0) + var1);
 }
 
-#ifdef NONMATCHING
-void obj_update_pos2(struct Sprite* sprite, s32 a1, s32 a2)
+void obj_update_pos2(struct Sprite *sprite, s32 a1, s32 a2)
 {
     s32 var0, var1, var2;
-    u8 matrixNum = sprite->oam.matrixNum;
+
+    u32 matrixNum = sprite->oam.matrixNum;
     if (a1 != 0x800)
     {
-        var0 = sUnknown_082EC6F4[sprite->oam.size * 8 + sprite->oam.shape * 32];
+        var0 = sUnknown_082EC6F4[sprite->oam.shape][sprite->oam.size][0];
         var1 = var0 << 8;
         var2 = (var0 << 16) / gOamMatrices[matrixNum].a;
         sprite->pos2.x = sub_8007E28(var1, var2, a1);
     }
     if (a2 != 0x800)
     {
-        var0 = sUnknown_082EC6F4[4 + (sprite->oam.size * 8 + sprite->oam.shape * 32)];
+        var0 = sUnknown_082EC6F4[sprite->oam.shape][sprite->oam.size][1];
         var1 = var0 << 8;
         var2 = (var0 << 16) / gOamMatrices[matrixNum].d;
         sprite->pos2.y = sub_8007E28(var1, var2, a2);
     }
 }
-#else
-__attribute__((naked))
-void obj_update_pos2(struct Sprite* sprite, s32 a1, s32 a2)
-{
-    asm(".syntax unified\n\
-	push {r4-r7,lr}\n\
-	mov r7, r9\n\
-	mov r6, r8\n\
-	push {r6,r7}\n\
-	adds r5, r0, 0\n\
-	adds r6, r1, 0\n\
-	mov r8, r2\n\
-	ldrb r1, [r5, 0x3]\n\
-	lsls r0, r1, 26\n\
-	lsrs r7, r0, 27\n\
-	movs r0, 0x80\n\
-	lsls r0, 4\n\
-	mov r9, r0\n\
-	cmp r6, r9\n\
-	beq _08007EA2\n\
-	ldr r2, =sUnknown_082EC6F4\n\
-	lsrs r1, 6\n\
-	lsls r1, 3\n\
-	ldrb r0, [r5, 0x1]\n\
-	lsrs r0, 6\n\
-	lsls r0, 5\n\
-	adds r1, r0\n\
-	adds r1, r2\n\
-	ldr r0, [r1]\n\
-	lsls r4, r0, 8\n\
-	lsls r0, 16\n\
-	ldr r2, =gOamMatrices\n\
-	lsls r1, r7, 3\n\
-	adds r1, r2\n\
-	movs r2, 0\n\
-	ldrsh r1, [r1, r2]\n\
-	bl __divsi3\n\
-	adds r1, r0, 0\n\
-	adds r0, r4, 0\n\
-	adds r2, r6, 0\n\
-	bl sub_8007E28\n\
-	strh r0, [r5, 0x24]\n\
-_08007EA2:\n\
-	cmp r8, r9\n\
-	beq _08007EDA\n\
-	ldr r2, =sUnknown_082EC6F4\n\
-	ldrb r1, [r5, 0x3]\n\
-	lsrs r1, 6\n\
-	lsls r1, 3\n\
-	ldrb r0, [r5, 0x1]\n\
-	lsrs r0, 6\n\
-	lsls r0, 5\n\
-	adds r1, r0\n\
-	adds r2, 0x4\n\
-	adds r1, r2\n\
-	ldr r0, [r1]\n\
-	lsls r4, r0, 8\n\
-	lsls r0, 16\n\
-	ldr r2, =gOamMatrices\n\
-	lsls r1, r7, 3\n\
-	adds r1, r2\n\
-	movs r2, 0x6\n\
-	ldrsh r1, [r1, r2]\n\
-	bl __divsi3\n\
-	adds r1, r0, 0\n\
-	adds r0, r4, 0\n\
-	mov r2, r8\n\
-	bl sub_8007E28\n\
-	strh r0, [r5, 0x26]\n\
-_08007EDA:\n\
-	pop {r3,r4}\n\
-	mov r8, r3\n\
-	mov r9, r4\n\
-	pop {r4-r7}\n\
-	pop {r0}\n\
-	bx r0\n\
-	.pool\n\
-        .syntax divided");
-}
-#endif // NONMATCHING
 
 void SetSpriteOamFlipBits(struct Sprite *sprite, u8 hFlip, u8 vFlip)
 {

src/start_menu.c

@@ -62,6 +62,11 @@ EWRAM_DATA u8 sBattlePyramidFloorWindowId = 0;
 EWRAM_DATA u8 sStartMenuCursorPos = 0;
 EWRAM_DATA u8 sNumStartMenuActions = 0;
 EWRAM_DATA u8 sCurrentStartMenuActions[9] = {0};
+EWRAM_DATA u8 gUnknown_02037619[2] = {0};
+EWRAM_DATA bool8 (*gUnknown_0203761C)(void) = NULL;
+EWRAM_DATA u8 gUnknown_02037620 = 0;
+EWRAM_DATA u8 gUnknown_02037621 = 0;
+EWRAM_DATA u8 gUnknown_02037622 = 0;
 
 // const rom data
 static const struct WindowTemplate gSafariBallsWindowTemplate = {0, 1, 1, 9, 4, 0xF, 8};
@@ -120,6 +125,13 @@ const struct WindowTemplate gUnknown_085105AC[] =
 const struct WindowTemplate gUnknown_085105BC = {0, 1, 1, 0xE, 0xA, 0xF, 8};
 
 // code
+void SetDexPokemonPokenavFlags(void) // unused
+{
+    FlagSet(FLAG_SYS_POKEDEX_GET);
+    FlagSet(FLAG_SYS_POKEMON_GET);
+    FlagSet(FLAG_SYS_POKENAV_GET);
+}
+
 void BuildStartMenuActions(void)
 {
     sNumStartMenuActions = 0;

src/time_events.c

@@ -0,0 +1,118 @@
+#include "global.h"
+#include "time_events.h"
+#include "event_data.h"
+#include "field_weather.h"
+#include "pokemon.h"
+#include "random.h"
+#include "overworld.h"
+#include "rtc.h"
+#include "script.h"
+#include "task.h"
+
+static u32 GetMirageRnd(void)
+{
+    u32 hi = VarGet(VAR_MIRAGE_RND_H);
+    u32 lo = VarGet(VAR_MIRAGE_RND_L);
+    return (hi << 16) | lo;
+}
+
+static void SetMirageRnd(u32 rnd)
+{
+    VarSet(VAR_MIRAGE_RND_H, rnd >> 16);
+    VarSet(VAR_MIRAGE_RND_L, rnd);
+}
+
+// unused
+void InitMirageRnd(void)
+{
+    SetMirageRnd((Random() << 16) | Random());
+}
+
+void UpdateMirageRnd(u16 days)
+{
+    s32 rnd = GetMirageRnd();
+    while (days)
+    {
+        rnd = 1103515245 * rnd + 12345;
+        days--;
+    }
+    SetMirageRnd(rnd);
+}
+
+bool8 IsMirageIslandPresent(void)
+{
+    u16 rnd = GetMirageRnd() >> 16;
+    int i;
+
+    for (i = 0; i < PARTY_SIZE; i++)
+        if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) && (GetMonData(&gPlayerParty[i], MON_DATA_PERSONALITY) & 0xFFFF) == rnd)
+            return TRUE;
+
+    return FALSE;
+}
+
+void UpdateShoalTideFlag(void)
+{
+    static const u8 tide[] =
+    {
+        1, // 00
+        1, // 01
+        1, // 02
+        0, // 03
+        0, // 04
+        0, // 05
+        0, // 06
+        0, // 07
+        0, // 08
+        1, // 09
+        1, // 10
+        1, // 11
+        1, // 12
+        1, // 13
+        1, // 14
+        0, // 15
+        0, // 16
+        0, // 17
+        0, // 18
+        0, // 19
+        0, // 20
+        1, // 21
+        1, // 22
+        1, // 23
+    };
+
+    if (is_light_level_1_2_3_5_or_6(get_map_light_from_warp0()))
+    {
+        RtcCalcLocalTime();
+        if (tide[gLocalTime.hours])
+            FlagSet(FLAG_SYS_SHOAL_TIDE);
+        else
+            FlagClear(FLAG_SYS_SHOAL_TIDE);
+    }
+}
+
+static void Task_WaitWeather(u8 taskId)
+{
+    if (IsWeatherChangeComplete())
+    {
+        EnableBothScriptContexts();
+        DestroyTask(taskId);
+    }
+}
+
+void WaitWeather(void)
+{
+    CreateTask(Task_WaitWeather, 80);
+}
+
+void InitBirchState(void)
+{
+    *GetVarPointer(VAR_BIRCH_STATE) = 0;
+}
+
+void UpdateBirchState(u16 days)
+{
+    u16 *state = GetVarPointer(VAR_BIRCH_STATE);
+    *state += days;
+    *state %= 7;
+}

src/title_screen.c

@@ -0,0 +1,783 @@
+#include "global.h"
+#include "title_screen.h"
+#include "sprite.h"
+#include "gba/m4a_internal.h"
+#include "clear_save_data_menu.h"
+#include "decompress.h"
+#include "event_data.h"
+#include "intro.h"
+#include "m4a.h"
+#include "main.h"
+#include "main_menu.h"
+#include "palette.h"
+#include "reset_rtc_screen.h"
+#include "berry_fix_program.h"
+#include "sound.h"
+#include "sprite.h"
+#include "task.h"
+#include "scanline_effect.h"
+#include "gpu_regs.h"
+#include "trig.h"
+#include "constants/rgb.h"
+
+#define VERSION_BANNER_SHAPE 1
+#define VERSION_BANNER_RIGHT_TILEOFFSET 64
+#define VERSION_BANNER_BYTES 0x1000
+#define VERSION_BANNER_LEFT_X 98
+#define VERSION_BANNER_RIGHT_X 162
+#define VERSION_BANNER_Y 2
+#define VERSION_BANNER_Y_GOAL 66
+#define START_BANNER_X 128
+
+#define CLEAR_SAVE_BUTTON_COMBO (B_BUTTON | SELECT_BUTTON | DPAD_UP)
+#define RESET_RTC_BUTTON_COMBO (B_BUTTON | SELECT_BUTTON | DPAD_LEFT)
+#define BERRY_UPDATE_BUTTON_COMBO (B_BUTTON | SELECT_BUTTON)
+#define A_B_START_SELECT (A_BUTTON | B_BUTTON | START_BUTTON | SELECT_BUTTON)
+
+extern struct MusicPlayerInfo gMPlayInfo_BGM;
+extern u16 gBattle_BG1_X;
+extern u16 gBattle_BG1_Y;
+
+extern const u8 gTitleScreenEmeraldVersionGfx[];
+extern const u8 gTitleScreenPressStartGfx[];
+extern const u8 gTitleScreenPokemonLogoGfx[];
+extern const u8 gUnknown_08DE0644[];
+extern const u8 gUnknown_08DDE458[];
+extern const u16 gTitleScreenBgPalettes[];
+extern const u16 gTitleScreenPressStartPal[];
+extern const u16 gTitleScreenEmeraldVersionPal[];
+
+// this file's functions
+static void MainCB2(void);
+static void Task_TitleScreenPhase1(u8);
+static void Task_TitleScreenPhase2(u8);
+static void Task_TitleScreenPhase3(u8);
+static void CB2_GoToMainMenu(void);
+static void CB2_GoToClearSaveDataScreen(void);
+static void CB2_GoToResetRtcScreen(void);
+static void CB2_GoToBerryFixScreen(void);
+static void CB2_GoToCopyrightScreen(void);
+static void UpdateLegendaryMarkingColor(u8);
+
+static void SpriteCB_VersionBannerLeft(struct Sprite *sprite);
+static void SpriteCB_VersionBannerRight(struct Sprite *sprite);
+static void SpriteCB_PressStartCopyrightBanner(struct Sprite *sprite);
+static void SpriteCB_PokemonLogoShine(struct Sprite *sprite);
+
+// const rom data
+static const u16 sUnusedUnknownPal[] = INCBIN_U16("graphics/title_screen/unk_853EF78.gbapal");
+
+static const u8 sTitleScreenRayquazaGfx[] = INCBIN_U8("graphics/title_screen/rayquaza.4bpp.lz");
+static const u8 sTitleScreenRayquazaTilemap[] = INCBIN_U8("graphics/title_screen/rayquaza.bin.lz");
+static const u8 sTitleScreenLogoShineGfx[] = INCBIN_U8("graphics/title_screen/logo_shine.4bpp.lz");
+static const u8 sTitleScreenCloudsGfx[] = INCBIN_U8("graphics/title_screen/clouds.4bpp.lz");
+
+const u16 gUnknown_0853FF70[] =
+{
+	0x0010, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510, 0x0610, 0x0710,
+	0x0810, 0x0910, 0x0a10, 0x0b10, 0x0c10, 0x0d10, 0x0e10, 0x0f10,
+	0x100f, 0x100e, 0x100d, 0x100c, 0x100b, 0x100a, 0x1009, 0x1008,
+	0x1007, 0x1006, 0x1005, 0x1004, 0x1003, 0x1002, 0x1001, 0x1000,
+	0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+	0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+	0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+	0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+};
+
+static const struct OamData sVersionBannerLeftOamData =
+{
+    .y = 160,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 1,
+    .shape = VERSION_BANNER_SHAPE,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 3,
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+static const struct OamData sVersionBannerRightOamData =
+{
+    .y = 160,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 1,
+    .shape = VERSION_BANNER_SHAPE,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 3,
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+static const union AnimCmd sVersionBannerLeftAnimSequence[] =
+{
+    ANIMCMD_FRAME(0, 30),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd sVersionBannerRightAnimSequence[] =
+{
+    ANIMCMD_FRAME(VERSION_BANNER_RIGHT_TILEOFFSET, 30),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd *const sVersionBannerLeftAnimTable[] =
+{
+    sVersionBannerLeftAnimSequence,
+};
+
+static const union AnimCmd *const sVersionBannerRightAnimTable[] =
+{
+    sVersionBannerRightAnimSequence,
+};
+
+static const struct SpriteTemplate sVersionBannerLeftSpriteTemplate =
+{
+    .tileTag = 1000,
+    .paletteTag = 1000,
+    .oam = &sVersionBannerLeftOamData,
+    .anims = sVersionBannerLeftAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_VersionBannerLeft,
+};
+
+static const struct SpriteTemplate sVersionBannerRightSpriteTemplate =
+{
+    .tileTag = 1000,
+    .paletteTag = 1000,
+    .oam = &sVersionBannerRightOamData,
+    .anims = sVersionBannerRightAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_VersionBannerRight,
+};
+
+static const struct CompressedSpriteSheet sSpriteSheet_EmeraldVersion[] =
+{
+    {gTitleScreenEmeraldVersionGfx, VERSION_BANNER_BYTES, 1000},
+    {NULL},
+};
+
+static const struct OamData sOamData_CopyrightBanner =
+{
+    .y = 160,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 1,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 1,
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+static const union AnimCmd sCopyrightBannerAnim0[] =
+{
+    ANIMCMD_FRAME(1, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim1[] =
+{
+    ANIMCMD_FRAME(5, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim2[] =
+{
+    ANIMCMD_FRAME(9, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim3[] =
+{
+    ANIMCMD_FRAME(13, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim4[] =
+{
+    ANIMCMD_FRAME(17, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim5[] =
+{
+    ANIMCMD_FRAME(21, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim6[] =
+{
+    ANIMCMD_FRAME(25, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim7[] =
+{
+    ANIMCMD_FRAME(29, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim8[] =
+{
+    ANIMCMD_FRAME(33, 4),
+    ANIMCMD_END,
+};
+static const union AnimCmd sCopyrightBannerAnim9[] =
+{
+    ANIMCMD_FRAME(37, 4),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd *const sStartCopyrightBannerAnimTable[] =
+{
+    sCopyrightBannerAnim0,
+    sCopyrightBannerAnim1,
+    sCopyrightBannerAnim2,
+    sCopyrightBannerAnim3,
+    sCopyrightBannerAnim4,
+    sCopyrightBannerAnim5,
+    sCopyrightBannerAnim6,
+    sCopyrightBannerAnim7,
+    sCopyrightBannerAnim8,
+    sCopyrightBannerAnim9,
+};
+
+static const struct SpriteTemplate sStartCopyrightBannerSpriteTemplate =
+{
+    .tileTag = 1001,
+    .paletteTag = 1001,
+    .oam = &sOamData_CopyrightBanner,
+    .anims = sStartCopyrightBannerAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_PressStartCopyrightBanner,
+};
+
+static const struct CompressedSpriteSheet sSpriteSheet_PressStart[] =
+{
+    {gTitleScreenPressStartGfx, 0x520, 1001},
+    {NULL},
+};
+
+static const struct SpritePalette sSpritePalette_PressStart[] =
+{
+    {gTitleScreenPressStartPal, 1001},
+    {NULL},
+};
+
+static const struct OamData sPokemonLogoShineOamData =
+{
+    .y = 160,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 0,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 3,
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+static const union AnimCmd sPokemonLogoShineAnimSequence[] =
+{
+    ANIMCMD_FRAME(0, 4),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd *const sPokemonLogoShineAnimTable[] =
+{
+    sPokemonLogoShineAnimSequence,
+};
+
+static const struct SpriteTemplate sPokemonLogoShineSpriteTemplate =
+{
+    .tileTag = 1002,
+    .paletteTag = 1001,
+    .oam = &sPokemonLogoShineOamData,
+    .anims = sPokemonLogoShineAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_PokemonLogoShine,
+};
+
+static const struct CompressedSpriteSheet sPokemonLogoShineSpriteSheet[] =
+{
+    {sTitleScreenLogoShineGfx, 0x800, 1002},
+    {NULL},
+};
+
+// code
+static void SpriteCB_VersionBannerLeft(struct Sprite *sprite)
+{
+    if (gTasks[sprite->data[1]].data[1] != 0)
+    {
+        sprite->oam.objMode = 0;
+        sprite->pos1.y = VERSION_BANNER_Y_GOAL;
+    }
+    else
+    {
+        if (sprite->pos1.y != VERSION_BANNER_Y_GOAL)
+            sprite->pos1.y++;
+        if (sprite->data[0] != 0)
+            sprite->data[0]--;
+        SetGpuReg(REG_OFFSET_BLDALPHA, gUnknown_0853FF70[sprite->data[0]]);
+    }
+}
+
+static void SpriteCB_VersionBannerRight(struct Sprite *sprite)
+{
+    if (gTasks[sprite->data[1]].data[1] != 0)
+    {
+        sprite->oam.objMode = 0;
+        sprite->pos1.y = VERSION_BANNER_Y_GOAL;
+    }
+    else
+    {
+        if (sprite->pos1.y != VERSION_BANNER_Y_GOAL)
+            sprite->pos1.y++;
+    }
+}
+
+static void SpriteCB_PressStartCopyrightBanner(struct Sprite *sprite)
+{
+    if (sprite->data[0] == 1)
+    {
+        sprite->data[1]++;
+        // Alternate between hidden and shown every 16th frame
+        if (sprite->data[1] & 0x10)
+            sprite->invisible = FALSE;
+        else
+            sprite->invisible = TRUE;
+    }
+    else
+    {
+        sprite->invisible = FALSE;
+    }
+}
+
+static void CreatePressStartBanner(s16 x, s16 y)
+{
+    u8 i;
+    u8 spriteId;
+
+    x -= 64;
+    for (i = 0; i < 5; i++, x += 32)
+    {
+        spriteId = CreateSprite(&sStartCopyrightBannerSpriteTemplate, x, y, 0);
+        StartSpriteAnim(&gSprites[spriteId], i);
+        gSprites[spriteId].data[0] = 1;
+    }
+}
+
+static void CreateCopyrightBanner(s16 x, s16 y)
+{
+    u8 i;
+    u8 spriteId;
+
+    x -= 64;
+    for (i = 0; i < 5; i++, x += 32)
+    {
+        spriteId = CreateSprite(&sStartCopyrightBannerSpriteTemplate, x, y, 0);
+        StartSpriteAnim(&gSprites[spriteId], i + 5);
+    }
+}
+
+static void SpriteCB_PokemonLogoShine(struct Sprite *sprite)
+{
+    if (sprite->pos1.x < 272)
+    {
+        if (sprite->data[0]) // Flash background
+        {
+            u16 backgroundColor;
+
+            if (sprite->pos1.x < DISPLAY_WIDTH / 2)
+            {
+                // Brighten background color
+                if (sprite->data[1] < 31)
+                    sprite->data[1]++;
+                if (sprite->data[1] < 31)
+                    sprite->data[1]++;
+            }
+            else
+            {
+                // Darken background color
+                if (sprite->data[1] != 0)
+                    sprite->data[1]--;
+                if (sprite->data[1] != 0)
+                    sprite->data[1]--;
+            }
+
+            backgroundColor = _RGB(sprite->data[1], sprite->data[1], sprite->data[1]);
+            if (sprite->pos1.x == DISPLAY_WIDTH / 2 + 12
+                || sprite->pos1.x == DISPLAY_WIDTH / 2 + 16
+                || sprite->pos1.x == DISPLAY_WIDTH / 2 + 20
+                || sprite->pos1.x == DISPLAY_WIDTH / 2 + 24)
+                gPlttBufferFaded[0] = RGB(24, 31, 12);
+            else
+                gPlttBufferFaded[0] = backgroundColor;
+        }
+        sprite->pos1.x += 4;
+    }
+    else
+    {
+        gPlttBufferFaded[0] = RGB_BLACK;
+        DestroySprite(sprite);
+    }
+}
+
+static void SpriteCB_PokemonLogoShine2(struct Sprite *sprite)
+{
+    if (sprite->pos1.x < 272)
+        sprite->pos1.x += 8;
+    else
+        DestroySprite(sprite);
+}
+
+static void StartPokemonLogoShine(u8 flashBg)
+{
+    u8 spriteId;
+
+    switch (flashBg)
+    {
+    case 0:
+    case 2:
+        spriteId = CreateSprite(&sPokemonLogoShineSpriteTemplate, 0, 68, 0);
+        gSprites[spriteId].oam.objMode = 2;
+        gSprites[spriteId].data[0] = flashBg;
+        break;
+    case 1:
+        spriteId = CreateSprite(&sPokemonLogoShineSpriteTemplate, 0, 68, 0);
+        gSprites[spriteId].oam.objMode = 2;
+        gSprites[spriteId].data[0] = flashBg;
+        gSprites[spriteId].invisible = TRUE;
+
+        spriteId = CreateSprite(&sPokemonLogoShineSpriteTemplate, 0, 68, 0);
+        gSprites[spriteId].callback = SpriteCB_PokemonLogoShine2;
+        gSprites[spriteId].oam.objMode = 2;
+
+        spriteId = CreateSprite(&sPokemonLogoShineSpriteTemplate, -80, 68, 0);
+        gSprites[spriteId].callback = SpriteCB_PokemonLogoShine2;
+        gSprites[spriteId].oam.objMode = 2;
+        break;
+    }
+}
+
+static void VBlankCB(void)
+{
+    ScanlineEffect_InitHBlankDmaTransfer();
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+    SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y);
+}
+
+#define tCounter data[0]
+#define tSkipToNext data[1]
+
+void CB2_InitTitleScreen(void)
+{
+    switch (gMain.state)
+    {
+    default:
+    case 0:
+        SetVBlankCallback(NULL);
+        SetGpuReg(REG_OFFSET_BLDCNT, 0);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        *((u16 *)PLTT) = RGB_WHITE;
+        SetGpuReg(REG_OFFSET_DISPCNT, 0);
+        SetGpuReg(REG_OFFSET_BG2CNT, 0);
+        SetGpuReg(REG_OFFSET_BG1CNT, 0);
+        SetGpuReg(REG_OFFSET_BG0CNT, 0);
+        SetGpuReg(REG_OFFSET_BG2HOFS, 0);
+        SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG1HOFS, 0);
+        SetGpuReg(REG_OFFSET_BG1VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+        SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+        DmaFill16(3, 0, (void *)VRAM, VRAM_SIZE);
+        DmaFill32(3, 0, (void *)OAM, OAM_SIZE);
+        DmaFill16(3, 0, (void *)(PLTT + 2), PLTT_SIZE - 2);
+        ResetPaletteFade();
+        gMain.state = 1;
+        break;
+    case 1:
+        LZ77UnCompVram(gTitleScreenPokemonLogoGfx, (void *)VRAM);
+        LZ77UnCompVram(gUnknown_08DE0644, (void *)(VRAM + 0x4800));
+        LoadPalette(gTitleScreenBgPalettes, 0, 0x1E0);
+        LZ77UnCompVram(sTitleScreenRayquazaGfx, (void *)(VRAM + 0x8000));
+        LZ77UnCompVram(sTitleScreenRayquazaTilemap, (void *)(VRAM + 0xD000));
+        LZ77UnCompVram(sTitleScreenCloudsGfx, (void *)(VRAM + 0xC000));
+        LZ77UnCompVram(gUnknown_08DDE458, (void *)(VRAM + 0xD800));
+        ScanlineEffect_Stop();
+        ResetTasks();
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        gReservedSpritePaletteCount = 9;
+        LoadCompressedObjectPic(&sSpriteSheet_EmeraldVersion[0]);
+        LoadCompressedObjectPic(&sSpriteSheet_PressStart[0]);
+        LoadCompressedObjectPic(&sPokemonLogoShineSpriteSheet[0]);
+        LoadPalette(gTitleScreenEmeraldVersionPal, 0x100, 0x20);
+        LoadSpritePalette(&sSpritePalette_PressStart[0]);
+        gMain.state = 2;
+        break;
+    case 2:
+    {
+        u8 taskId = CreateTask(Task_TitleScreenPhase1, 0);
+
+        gTasks[taskId].tCounter = 256;
+        gTasks[taskId].tSkipToNext = FALSE;
+        gTasks[taskId].data[2] = -16;
+        gTasks[taskId].data[3] = -32;
+        gMain.state = 3;
+        break;
+    }
+    case 3:
+        BeginNormalPaletteFade(-1, 1, 0x10, 0, 0xFFFF);
+        SetVBlankCallback(VBlankCB);
+        gMain.state = 4;
+        break;
+    case 4:
+        sub_816F2A8(0x78, 0x50, 0x100, 0);
+        SetGpuReg(REG_OFFSET_BG2X_L, -29 * 256);
+        SetGpuReg(REG_OFFSET_BG2X_H, -1);
+        SetGpuReg(REG_OFFSET_BG2Y_L, -32 * 256);
+        SetGpuReg(REG_OFFSET_BG2Y_H, -1);
+        SetGpuReg(REG_OFFSET_WIN0H, 0);
+        SetGpuReg(REG_OFFSET_WIN0V, 0);
+        SetGpuReg(REG_OFFSET_WIN1H, 0);
+        SetGpuReg(REG_OFFSET_WIN1V, 0);
+        SetGpuReg(REG_OFFSET_WININ, 0x1F1F);
+        SetGpuReg(REG_OFFSET_WINOUT, 0x3F1F);
+        SetGpuReg(REG_OFFSET_BLDCNT, 0x84);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+        SetGpuReg(REG_OFFSET_BLDY, 0xC);
+        SetGpuReg(REG_OFFSET_BG0CNT, BGCNT_PRIORITY(3) | BGCNT_CHARBASE(2) | BGCNT_SCREENBASE(26) | BGCNT_16COLOR | BGCNT_TXT256x256);
+        SetGpuReg(REG_OFFSET_BG1CNT, BGCNT_PRIORITY(2) | BGCNT_CHARBASE(3) | BGCNT_SCREENBASE(27) | BGCNT_16COLOR | BGCNT_TXT256x256);
+        SetGpuReg(REG_OFFSET_BG2CNT, BGCNT_PRIORITY(1) | BGCNT_CHARBASE(0) | BGCNT_SCREENBASE(9) | BGCNT_256COLOR | BGCNT_AFF256x256);
+        EnableInterrupts(INTR_FLAG_VBLANK);
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_1
+                                    | DISPCNT_OBJ_1D_MAP
+                                    | DISPCNT_BG2_ON
+                                    | DISPCNT_OBJ_ON
+                                    | DISPCNT_WIN0_ON
+                                    | DISPCNT_OBJWIN_ON);
+        m4aSongNumStart(0x19D);
+        gMain.state = 5;
+        break;
+    case 5:
+        if (!UpdatePaletteFade())
+        {
+            StartPokemonLogoShine(0);
+            ScanlineEffect_InitWave(0, DISPLAY_HEIGHT, 4, 4, 0, SCANLINE_EFFECT_REG_BG1HOFS, TRUE);
+            SetMainCallback2(MainCB2);
+        }
+        break;
+    }
+}
+
+static void MainCB2(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+// Shine the Pokemon logo two more times, and fade in the version banner
+static void Task_TitleScreenPhase1(u8 taskId)
+{
+    // Skip to next phase when A, B, Start, or Select is pressed
+    if ((gMain.newKeys & A_B_START_SELECT) || gTasks[taskId].data[1] != 0)
+    {
+        gTasks[taskId].tSkipToNext = TRUE;
+        gTasks[taskId].tCounter = 0;
+    }
+
+    if (gTasks[taskId].tCounter != 0)
+    {
+        u16 frameNum = gTasks[taskId].tCounter;
+        if (frameNum == 176)
+            StartPokemonLogoShine(1);
+        else if (frameNum == 64)
+            StartPokemonLogoShine(2);
+
+        gTasks[taskId].tCounter--;
+    }
+    else
+    {
+        u8 spriteId;
+
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_1 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG2_ON | DISPCNT_OBJ_ON);
+        SetGpuReg(REG_OFFSET_WININ, 0);
+        SetGpuReg(REG_OFFSET_WINOUT, 0);
+        SetGpuReg(REG_OFFSET_BLDCNT, 0x3F50);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0x10);
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+
+        // Create left side of version banner
+        spriteId = CreateSprite(&sVersionBannerLeftSpriteTemplate, VERSION_BANNER_LEFT_X, VERSION_BANNER_Y, 0);
+        gSprites[spriteId].data[0] = 64;
+        gSprites[spriteId].data[1] = taskId;
+
+        // Create right side of version banner
+        spriteId = CreateSprite(&sVersionBannerRightSpriteTemplate, VERSION_BANNER_RIGHT_X, VERSION_BANNER_Y, 0);
+        gSprites[spriteId].data[1] = taskId;
+
+        gTasks[taskId].tCounter = 144;
+        gTasks[taskId].func = Task_TitleScreenPhase2;
+    }
+}
+
+// Create "Press Start" and copyright banners, and slide Pokemon logo up
+static void Task_TitleScreenPhase2(u8 taskId)
+{
+    u32 yPos;
+
+    // Skip to next phase when A, B, Start, or Select is pressed
+    if ((gMain.newKeys & A_B_START_SELECT) || gTasks[taskId].tSkipToNext)
+    {
+        gTasks[taskId].tSkipToNext = TRUE;
+        gTasks[taskId].tCounter = 0;
+    }
+
+    if (gTasks[taskId].tCounter != 0)
+    {
+        gTasks[taskId].tCounter--;
+    }
+    else
+    {
+        gTasks[taskId].tSkipToNext = TRUE;
+        SetGpuReg(REG_OFFSET_BLDCNT, 0x2142);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0xF06);
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_1
+                                    | DISPCNT_OBJ_1D_MAP
+                                    | DISPCNT_BG0_ON
+                                    | DISPCNT_BG1_ON
+                                    | DISPCNT_BG2_ON
+                                    | DISPCNT_OBJ_ON);
+        CreatePressStartBanner(START_BANNER_X, 108);
+        CreateCopyrightBanner(START_BANNER_X, 148);
+        gTasks[taskId].data[4] = 0;
+        gTasks[taskId].func = Task_TitleScreenPhase3;
+    }
+
+    if (!(gTasks[taskId].tCounter & 3) && gTasks[taskId].data[2] != 0)
+        gTasks[taskId].data[2]++;
+    if (!(gTasks[taskId].tCounter & 1) && gTasks[taskId].data[3] != 0)
+        gTasks[taskId].data[3]++;
+
+    // Slide Pokemon logo up
+    yPos = gTasks[taskId].data[3] * 256;
+    SetGpuReg(REG_OFFSET_BG2Y_L, yPos);
+    SetGpuReg(REG_OFFSET_BG2Y_H, yPos / 0x10000);
+
+    gTasks[taskId].data[5] = 15;
+    gTasks[taskId].data[6] = 6;
+}
+
+// Show Rayquaza silhouette and process main title screen input
+static void Task_TitleScreenPhase3(u8 taskId)
+{
+    if ((gMain.newKeys & A_BUTTON) || (gMain.newKeys & START_BUTTON))
+    {
+        FadeOutBGM(4);
+        BeginNormalPaletteFade(-1, 0, 0, 0x10, 0xFFFF);
+        SetMainCallback2(CB2_GoToMainMenu);
+    }
+    else if ((gMain.heldKeys & CLEAR_SAVE_BUTTON_COMBO) == CLEAR_SAVE_BUTTON_COMBO)
+    {
+        SetMainCallback2(CB2_GoToClearSaveDataScreen);
+    }
+    else if ((gMain.heldKeys & RESET_RTC_BUTTON_COMBO) == RESET_RTC_BUTTON_COMBO
+      && CanResetRTC() == TRUE)
+    {
+        FadeOutBGM(4);
+        BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
+        SetMainCallback2(CB2_GoToResetRtcScreen);
+    }
+    else if ((gMain.heldKeys & BERRY_UPDATE_BUTTON_COMBO) == BERRY_UPDATE_BUTTON_COMBO)
+    {
+        FadeOutBGM(4);
+        BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
+        SetMainCallback2(CB2_GoToBerryFixScreen);
+    }
+    else
+    {
+        SetGpuReg(REG_OFFSET_BG2Y_L, 0);
+        SetGpuReg(REG_OFFSET_BG2Y_H, 0);
+        gTasks[taskId].tCounter++;
+        if (gTasks[taskId].tCounter & 1)
+        {
+            gTasks[taskId].data[4]++;
+            gBattle_BG1_Y = gTasks[taskId].data[4] / 2;
+            gBattle_BG1_X = 0;
+        }
+        UpdateLegendaryMarkingColor(gTasks[taskId].tCounter);
+        if ((gMPlayInfo_BGM.status & 0xFFFF) == 0)
+        {
+            BeginNormalPaletteFade(-1, 0, 0, 0x10, 0xFFFF);
+            SetMainCallback2(CB2_GoToCopyrightScreen);
+        }
+    }
+}
+
+static void CB2_GoToMainMenu(void)
+{
+    if (!UpdatePaletteFade())
+        SetMainCallback2(CB2_InitMainMenu);
+}
+
+static void CB2_GoToCopyrightScreen(void)
+{
+    if (!UpdatePaletteFade())
+        SetMainCallback2(CB2_InitCopyrightScreenAfterTitleScreen);
+}
+
+static void CB2_GoToClearSaveDataScreen(void)
+{
+    if (!UpdatePaletteFade())
+        SetMainCallback2(CB2_InitClearSaveDataScreen);
+}
+
+static void CB2_GoToResetRtcScreen(void)
+{
+    if (!UpdatePaletteFade())
+        SetMainCallback2(CB2_InitResetRtcScreen);
+}
+
+static void CB2_GoToBerryFixScreen(void)
+{
+    if (!UpdatePaletteFade())
+    {
+        m4aMPlayAllStop();
+        SetMainCallback2(CB2_InitBerryFixProgram);
+    }
+}
+
+static void UpdateLegendaryMarkingColor(u8 frameNum)
+{
+    if ((frameNum % 4) == 0) // Change color every 4th frame
+    {
+        s32 intensity = Cos(frameNum, 128) + 128;
+        s32 r = 31 - ((intensity * 32 - intensity) / 256);
+        s32 g = 31 - (intensity * 22 / 256);
+        s32 b = 12;
+
+        u16 color = RGB(r, g, b);
+        LoadPalette(&color, 0xEF, sizeof(color));
+   }
+}

src/trainer_see.c

@@ -6,7 +6,7 @@
 #include "field_effect.h"
 #include "field_map_obj.h"
 #include "field_player_avatar.h"
-#include "map_obj_8097404.h"
+#include "field_map_obj_helpers.h"
 #include "pokenav.h"
 #include "task.h"
 #include "util.h"
@@ -639,7 +639,7 @@ void sub_80B45D0(void)
             gApproachingTrainerId++;
             gSpecialVar_Result = 1;
             UnfreezeMapObjects();
-            sub_80974D0(gApproachingTrainers[1].mapObjectId);
+            FreezeMapObjectsExceptOne(gApproachingTrainers[1].mapObjectId);
         }
         else
         {

src/tv.c

@@ -1208,7 +1208,7 @@ void PutPokemonTodayFailedOnTheAir(void)
         {
             ct = 0xFF;
         }
-        if (ct > 2 && (gBattleOutcome == BATTLE_POKE_FLED || gBattleOutcome == BATTLE_WON))
+        if (ct > 2 && (gBattleOutcome == B_OUTCOME_POKE_FLED || gBattleOutcome == B_OUTCOME_WON))
         {
             sCurTVShowSlot = FindEmptyTVSlotBeyondFirstFiveShowsOfArray(gSaveBlock1Ptr->tvShows);
             if (sCurTVShowSlot != -1 && HasMixableShowAlreadyBeenSpawnedWithPlayerID(TVSHOW_POKEMON_TODAY_FAILED, FALSE) != TRUE)
@@ -2402,23 +2402,23 @@ void sub_80EE184(void)
         show->breakingNews.poke1Species = gBattleResults.playerMon1Species;
         switch (gBattleOutcome)
         {
-            case BATTLE_LOST:
-            case BATTLE_DREW:
+            case B_OUTCOME_LOST:
+            case B_OUTCOME_DREW:
                 show->breakingNews.kind = TVSHOW_OFF_AIR;
                 return;
-            case BATTLE_CAUGHT:
+            case B_OUTCOME_CAUGHT_POKE:
                 show->breakingNews.outcome = 0;
                 break;
-            case BATTLE_WON:
+            case B_OUTCOME_WON:
                 show->breakingNews.outcome = 1;
                 break;
-            case BATTLE_RAN:
-            case BATTLE_PLAYER_TELEPORTED:
-            case BATTLE_SAFARI_OUT_OF_BALLS:
+            case B_OUTCOME_RAN:
+            case B_OUTCOME_PLAYER_TELEPORTED:
+            case B_OUTCOME_NO_SAFARI_BALLS:
                 show->breakingNews.outcome = 2;
                 break;
-            case BATTLE_POKE_FLED:
-            case BATTLE_OPPONENT_TELEPORTED:
+            case B_OUTCOME_POKE_FLED:
+            case B_OUTCOME_POKE_TELEPORTED:
                 show->breakingNews.outcome = 3;
                 break;
         }

src/use_pokeblock.c

@@ -4,7 +4,7 @@
 #include "malloc.h"
 #include "palette.h"
 #include "pokenav.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "text.h"
 #include "bg.h"
 #include "window.h"
@@ -131,7 +131,7 @@ void sub_8166340(void)
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
     sub_81D2108(gUnknown_0203BCAC->field_7C58);
-    sub_80BA0A8();
+    ScanlineEffect_InitHBlankDmaTransfer();
 }
 
 void sub_816636C(void (*func)(void))

src/wallclock.c

@@ -12,7 +12,7 @@
 #include "window.h"
 #include "text_window.h"
 #include "menu.h"
-#include "unknown_task.h"
+#include "scanline_effect.h"
 #include "task.h"
 #include "strings.h"
 #include "sound.h"