Merge pull request #561 from yenatch/battle-1

almost all of battle_1

10 files changed, 815 insertions, 173 deletions

diff --git a/src/battle/battle_2.c b/src/battle/battle_2.c
index 2bbae20dc..2d5b3c420 100644
--- a/src/battle/battle_2.c
+++ b/src/battle/battle_2.c
@@ -75,7 +75,7 @@ extern void sub_802BBD4();
 extern struct SpriteTemplate gUnknown_02024E8C;
 extern const u8 Str_821F7B8[];
 extern u8 gUnknown_02023A14_50;
-extern const u16 gUnknown_08D004E0[];
+extern const u16 gBattleTextboxPalette[];
 extern const struct MonCoords gCastformFrontSpriteCoords[];
 extern const u8 Str_821F7EA[];
 extern const u8 gUnknown_Debug_821F7F3[];
@@ -269,10 +269,10 @@ void InitBattle(void)
     Text_InitWindowWithTemplate(&gUnknown_030041D0, &gWindowTemplate_81E71D0);
     Text_InitWindowWithTemplate(&gUnknown_03004250, &gWindowTemplate_81E71EC);
     sub_800D6D4();
-    sub_800DAB8();
+    LoadBattleTextboxAndBackground();
     ResetSpriteData();
     ResetTasks();
-    sub_800E23C();
+    LoadBattleEntryBackground();
     FreeAllSpritePalettes();
     gReservedSpritePaletteCount = 4;
     SetVBlankCallback(sub_800FCFC);
@@ -788,16 +788,14 @@ void sub_800F298(void)
             ZeroPlayerPartyMons();
             ZeroEnemyPartyMons();
             gBattleCommunication[0]++;
-            goto step_2;
-        }
-        break;
+            // fallthrough
     case 2:
-      step_2:
-        if (IsLinkTaskFinished())
-        {
-            SendBlock(bitmask_all_link_players_but_self(), ewram1D000, sizeof(struct Pokemon) * 2);
-            gBattleCommunication[0]++;
-        }
+            if (IsLinkTaskFinished())
+            {
+                SendBlock(bitmask_all_link_players_but_self(), ewram1D000, sizeof(struct Pokemon) * 2);
+                gBattleCommunication[0]++;
+            }
+	}
         break;
     case 3:
         if ((GetBlockReceivedStatus() & 0xF) == 0xF)
@@ -1309,11 +1307,11 @@ void c2_8011A1C(void)
     Text_InitWindowWithTemplate(&gUnknown_030041D0, &gWindowTemplate_81E71D0);
     Text_InitWindowWithTemplate(&gUnknown_03004250, &gWindowTemplate_81E71EC);
     sub_800D6D4();
-    LoadCompressedPalette(gUnknown_08D004E0, 0, 64);
-    sub_800D74C();
+    LoadCompressedPalette(gBattleTextboxPalette, 0, 64);
+    ApplyPlayerChosenFrameToBattleMenu();
     ResetSpriteData();
     ResetTasks();
-    sub_800E23C();
+    LoadBattleEntryBackground();
     REG_WINOUT = 0x37;
     FreeAllSpritePalettes();
     gReservedSpritePaletteCount = 4;
@@ -2833,7 +2831,7 @@ void debug_sub_8012688(void)
 	gBattle_BG3_Y = 0;
 	gBattleTerrain = 9;
 	sub_800D6D4();
-	sub_800DAB8();
+	LoadBattleTextboxAndBackground();
 	ResetSpriteData();
 	ResetTasks();
 	FreeAllSpritePalettes();
diff --git a/src/battle/battle_bg.c b/src/battle/battle_bg.c
new file mode 100644
index 000000000..f97829833
--- /dev/null
+++ b/src/battle/battle_bg.c
@@ -0,0 +1,763 @@
+#include "global.h"
+#include "battle.h"
+#include "constants/songs.h"
+#include "decompress.h"
+#include "ewram.h"
+#include "link.h"
+#include "main.h"
+#include "palette.h"
+#include "task.h"
+#include "text.h"
+#include "text_window.h"
+#include "trainer.h"
+#include "trig.h"
+#include "sound.h"
+
+
+extern u16 gBattleTypeFlags;
+extern u8 gBattleOutcome;
+
+extern struct Window gUnknown_03004210;
+
+extern u8 BattleText_Win[];
+extern u8 BattleText_Loss[];
+extern u8 BattleText_Tie[];
+
+extern void sub_8032A38(void);
+
+#define GetCurrentMapBattleScene sav1_map_get_battletype
+//extern u8 GetCurrentMapBattleScene(void);
+
+extern const u8 gGameVersion;
+extern u8 gBattleTextboxTiles[];
+extern u16 gBattleTextboxTilemap[];
+extern u16 gBattleTextboxPalette[];
+extern u16 gBattleTypeFlags;
+extern struct Trainer gTrainers[];
+extern u16 gTrainerBattleOpponent;
+
+struct BattleBackground  {
+    void *tileset;
+    void *tilemap;
+    void *entryTiles;
+    void *entryTilemap;
+    void *palette;
+};
+extern struct BattleBackground gBattleTerrainTable[];
+
+extern u8 gBattleTerrain;
+
+extern u8 gBattleTerrainTiles_Cave[];
+extern u8 gBattleTerrainTiles_Water[];
+extern u8 gBattleTerrainTiles_Building[];
+extern u8 gBattleTerrainTiles_Stadium[];
+
+extern u16 gBattleTerrainTilemap_Cave[];
+extern u16 gBattleTerrainTilemap_Water[];
+extern u16 gBattleTerrainTilemap_Building[];
+extern u16 gBattleTerrainTilemap_Stadium[];
+
+extern u16 gBattleTerrainPalette_Groudon[];
+extern u16 gBattleTerrainPalette_Kyogre[];
+extern u16 gBattleTerrainPalette_BuildingLeader[];
+extern u16 gBattleTerrainPalette_StadiumSteven[];
+extern u16 gBattleTerrainPalette_BuildingGym[];
+extern u16 gBattleTerrainPalette_StadiumMagma[];
+extern u16 gBattleTerrainPalette_StadiumAqua[];
+extern u16 gBattleTerrainPalette_StadiumSidney[];
+extern u16 gBattleTerrainPalette_StadiumPhoebe[];
+extern u16 gBattleTerrainPalette_StadiumGlacia[];
+extern u16 gBattleTerrainPalette_StadiumDrake[];
+extern u16 gBattleTerrainPalette_BattleTower[];
+
+extern u8 gBattleTerrainAnimTiles_Building[];
+extern u16 gBattleTerrainAnimTilemap_Building[];
+extern u8 gBattleTerrainAnimTiles_Cave[];
+extern u16 gBattleTerrainAnimTilemap_Cave[];
+extern u8 gBattleTerrainAnimTiles_Underwater[];
+extern u16 gBattleTerrainAnimTilemap_Underwater[];
+extern u8 gVersusFrameGfx[];
+extern u16 gVersusFrameTilemap[];
+extern u8 gUnknown_08E5DC2C[];
+extern u16 gVersusFramePal[];
+
+extern u16 gBattle_BG1_Y;
+extern u16 gBattle_BG2_Y;
+extern struct CompressedSpriteSheet gUnknown_081F95A4;
+
+extern u8 sav1_map_get_battletype(void);
+
+struct LinkResultWindow {
+    struct Window *window;
+    u16 offset;
+    u8 left;
+    u8 top;
+    u8 *dest;
+};
+
+#define gLinkResultWindows gUnknown_081F9680
+extern const struct LinkResultWindow gLinkResultWindows[];
+extern void PrintLinkBattleWinLossTie(void);
+extern void sub_800DAF8(u8, u8, u8 *);
+
+extern struct SpriteTemplate gSpriteTemplate_81F9574;
+extern struct SpriteTemplate gSpriteTemplate_81F958C;
+extern struct SpriteTemplate gSpriteTemplate_81F96D0;
+
+extern u16 gBattle_BG1_X;
+extern u16 gBattle_BG2_X;
+
+
+void sub_800D6C4(void);
+
+
+void unref_sub_800D684(void)
+{
+    u8 spriteId;
+    ResetSpriteData();
+    spriteId = CreateSprite(&gSpriteTemplate_81F96D0, 0, 0, 0);
+    gSprites[spriteId].invisible = TRUE;
+    SetMainCallback2(sub_800D6C4);
+}
+
+void sub_800D6C4(void)
+{
+    AnimateSprites();
+    BuildOamBuffer();
+}
+
+void sub_800D6D4(void)
+{
+    u16 ime = REG_IME;
+    REG_IME = 0;
+    REG_IE |= INTR_FLAG_VBLANK;
+    REG_IME = ime;
+    REG_DISPSTAT = DISPSTAT_VBLANK_INTR;
+    REG_BG0CNT = 0x9800;
+    REG_BG1CNT = 0x9c04;
+    REG_BG2CNT = 0x5e05;
+    REG_BG3CNT = 0x5a0b;
+    REG_BLDCNT = 0;
+    REG_BLDALPHA = 0;
+    REG_BLDY = 0;
+    REG_DISPCNT = 0xbf40;
+}
+
+void ApplyPlayerChosenFrameToBattleMenu(void)
+{
+    TextWindow_SetBaseTileNum(0x12);
+    TextWindow_LoadStdFrameGraphicsOverridePal(&gUnknown_03004210, 1);
+    TextWindow_SetBaseTileNum(0x22);
+    TextWindow_LoadStdFrameGraphicsOverridePal(&gUnknown_03004210, 1);
+    gPlttBufferUnfaded[92] = 0x7fe0;
+    gPlttBufferUnfaded[93] = 0x2529;
+    gPlttBufferUnfaded[94] = 0x7fff;
+    gPlttBufferUnfaded[95] = 0x675a;
+    CpuSet(&gPlttBufferUnfaded[92], &gPlttBufferFaded[92], 4);
+    sub_8032A38();
+}
+
+void DrawMainBattleBackground(void)
+{
+    if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER /*| BATTLE_TYPE_x2000000*/))
+    {
+        LZDecompressVram(gBattleTerrainTiles_Building, (void*)(VRAM + 0x8000));
+        LZDecompressVram(gBattleTerrainTilemap_Building, (void*)(VRAM + 0xD000));
+        LoadCompressedPalette(gBattleTerrainPalette_BattleTower, 0x20, 0x60);
+    }
+    else if (gBattleTypeFlags & BATTLE_TYPE_KYOGRE_GROUDON)
+    {
+        if (gGameVersion == VERSION_RUBY)
+        {
+            LZDecompressVram(gBattleTerrainTiles_Cave, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Cave, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_Groudon, 0x20, 0x60);
+        }
+        else
+        {
+            LZDecompressVram(gBattleTerrainTiles_Water, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Water, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_Kyogre, 0x20, 0x60);
+        }
+    }
+    else
+    {
+        if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+        {
+            u8 trainerClass = gTrainers[gTrainerBattleOpponent].trainerClass;
+            if (trainerClass == TRAINER_CLASS_LEADER)
+            {
+                LZDecompressVram(gBattleTerrainTiles_Building, (void*)(VRAM + 0x8000));
+                LZDecompressVram(gBattleTerrainTilemap_Building, (void*)(VRAM + 0xD000));
+                LoadCompressedPalette(gBattleTerrainPalette_BuildingLeader, 0x20, 0x60);
+                return;
+            }
+            else if (trainerClass == TRAINER_CLASS_CHAMPION)
+            {
+                LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(VRAM + 0x8000));
+                LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(VRAM + 0xD000));
+                LoadCompressedPalette(gBattleTerrainPalette_StadiumSteven, 0x20, 0x60);
+                return;
+            }
+        }
+
+        switch (GetCurrentMapBattleScene())
+        {
+        case MAP_BATTLE_SCENE_NORMAL:
+            LZDecompressVram(gBattleTerrainTable[gBattleTerrain].tileset, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTable[gBattleTerrain].tilemap, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainTable[gBattleTerrain].palette, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_GYM:
+            LZDecompressVram(gBattleTerrainTiles_Building, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Building, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_BuildingGym, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_MAGMA:
+            LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_StadiumMagma, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_AQUA:
+            LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_StadiumAqua, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_SIDNEY:
+            LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_StadiumSidney, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_PHOEBE:
+            LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_StadiumPhoebe, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_GLACIA:
+            LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_StadiumGlacia, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_DRAKE:
+            LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_StadiumDrake, 0x20, 0x60);
+            break;
+        case MAP_BATTLE_SCENE_BATTLE_TOWER:
+            LZDecompressVram(gBattleTerrainTiles_Building, (void*)(VRAM + 0x8000));
+            LZDecompressVram(gBattleTerrainTilemap_Building, (void*)(VRAM + 0xD000));
+            LoadCompressedPalette(gBattleTerrainPalette_BattleTower, 0x20, 0x60);
+            break;
+        }
+    }
+}
+
+void LoadBattleTextboxAndBackground(void)
+{
+    LZDecompressVram(gBattleTextboxTiles, (void*)(BG_VRAM));
+    CpuSet(gBattleTextboxTilemap, (void *)(VRAM + 0xC000), 0x800);
+    LoadCompressedPalette(gBattleTextboxPalette, 0, 0x40);
+    ApplyPlayerChosenFrameToBattleMenu();
+    DrawMainBattleBackground();
+
+    #if DEBUG
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        debug_sub_8008218((void*)(VRAM + 0x600), 0, (void*)(VRAM + 0xC000), 1);
+        debug_sub_8008264(257, 3, 1, 3, 1);
+        debug_sub_8008264(257, 3, 21, 3, 1);
+        debug_sub_8008264(257, 3, 41, 3, 1);
+    }
+    #endif
+}
+
+void sub_800DAF8(u8 taskId, u8 windowId, u8 *dest)
+{
+    int i;
+    u16 r4 = 0;
+    u16 src[6];
+
+    if (gBattleTypeFlags & BATTLE_TYPE_MULTI) {
+        if (gTasks[taskId].data[5]) {
+            switch (windowId) {
+            case 0:
+                r4 = gTasks[taskId].data[3] & 0x3f;
+                break;
+            case 1:
+                r4 = (gTasks[taskId].data[4] & 0xfc0) >> 6;
+                break;
+            case 2:
+                r4 = (gTasks[taskId].data[3] & 0xfc0) >> 6;
+                break;
+            case 3:
+                r4 = gTasks[taskId].data[4] & 0x3f;
+                break;
+            }
+        } else {
+            switch (windowId) {
+            case 0:
+                r4 = gTasks[taskId].data[3] & 0x3f;
+                break;
+            case 1:
+                r4 = gTasks[taskId].data[4] & 0x3f;
+                break;
+            case 2:
+                r4 = (gTasks[taskId].data[3] & 0xfc0) >> 6;
+                break;
+            case 3:
+                r4 = (gTasks[taskId].data[4] & 0xfc0) >> 6;
+                break;
+            }
+        }
+        for (i = 0; i < 3; i++) {
+            src[i] = ((r4 & (3 << (i * 2))) >> (i * 2)) + 0x6001;
+        }
+        CpuSet(src, dest, 3);
+    } else {
+        if (windowId == gBattleStruct->linkPlayerIndex) {
+            r4 = gTasks[taskId].data[3];
+        } else {
+            r4 = gTasks[taskId].data[4];
+        }
+        for (i = 0; i < 6; i++) {
+            src[i] = ((r4 & (3 << (i * 2))) >> (i * 2)) + 0x6001;
+        }
+        CpuSet(src, dest, 6);
+    }
+}
+
+
+#if ENGLISH
+#define LEFT_MESSAGE_X 6
+#define RIGHT_MESSAGE_X 21
+#define TILE_OFFSET_LOSS 168
+#elif GERMAN
+#define LEFT_MESSAGE_X 5
+#define RIGHT_MESSAGE_X 20
+#define TILE_OFFSET_LOSS 172
+#endif
+#define TILE_OFFSET_WIN 160
+#define CENTER_MESSAGE_X 13
+#define MESSAGE_Y 2
+
+#define PRINT_MESSAGE(text, tileDataStartOffset, x)                             \
+{                                                                               \
+    Text_InitWindow(&gUnknown_03004210, text, tileDataStartOffset, x, MESSAGE_Y);    \
+    Text_PrintWindow8002F44(&gUnknown_03004210);                                            \
+}
+
+#define PRINT_MESSAGE_LEFT(text, tileDataStartOffset)       PRINT_MESSAGE(text, tileDataStartOffset, LEFT_MESSAGE_X)
+#define PRINT_MESSAGE_RIGHT(text, tileDataStartOffset)      PRINT_MESSAGE(text, tileDataStartOffset, RIGHT_MESSAGE_X)
+
+void PrintLinkBattleWinLossTie(void)
+{
+
+    if (gBattleOutcome == 3)
+    {
+        PRINT_MESSAGE(BattleText_Tie, TILE_OFFSET_WIN, CENTER_MESSAGE_X);
+        return;
+    }
+
+    if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+    {
+        // Double battle?
+
+        if (gBattleOutcome == 1)
+        {
+
+            // lp_field_18 = player position?
+            switch (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18)
+            {
+            case 0:
+            case 2:
+                PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
+                PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
+                return;
+
+            case 1:
+            case 3:
+                PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN)
+                PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS)
+                return;
+            }
+        }
+        else
+        {
+
+            switch (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18)
+            {
+            case 1:
+            case 3:
+                PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
+                PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
+                return;
+
+            case 0:
+            case 2:
+                PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN);
+                PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS);
+                return;
+            }
+        }
+
+        return;
+    }
+
+
+    if (gBattleOutcome == 1)
+    {
+        if (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18 != 0)
+        {
+            PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN);
+            PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS);
+        }
+        else
+        {
+            PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
+            PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
+        }
+    }
+    else
+    {
+        if (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18 != 0)
+        {
+            PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
+            PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
+        }
+        else
+        {
+            PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN);
+            PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS);
+        }
+    }
+}
+
+
+void sub_800DE30(u8 taskId)
+{
+    u8 palette;
+    int i;
+
+    switch (gTasks[taskId].data[0]) {
+
+    case 0:
+        if (gBattleTypeFlags & BATTLE_TYPE_MULTI) {
+            for (i = 0; i < 4; i++) {
+                u8 windowId = (gLinkPlayers[i].lp_field_18 & 3);
+                Text_InitWindow8002E4C(
+                    gLinkResultWindows[windowId].window,
+                    gLinkPlayers[i].name,
+                    gLinkResultWindows[windowId].offset,
+                    gLinkResultWindows[windowId].left,
+                    gLinkResultWindows[windowId].top,
+                    1);
+                Text_PrintWindow8002F44(gLinkResultWindows[windowId].window);
+                sub_800DAF8(taskId, windowId, gLinkResultWindows[windowId].dest);
+            }
+        } else {
+            u8 windowId = 4;
+
+            u8 playerId = gBattleStruct->linkPlayerIndex;
+            u8 opponentId = gBattleStruct->linkPlayerIndex ^ 1;
+            if (gLinkPlayers[playerId].lp_field_18) {
+                opponentId = gBattleStruct->linkPlayerIndex;
+                playerId = gBattleStruct->linkPlayerIndex ^ 1;
+            }
+
+            Text_InitWindow8002E4C(
+                gLinkResultWindows[windowId].window,
+                gLinkPlayers[playerId].name,
+                gLinkResultWindows[windowId].offset,
+                gLinkResultWindows[windowId].left,
+                gLinkResultWindows[windowId].top,
+                1);
+            Text_PrintWindow8002F44(gLinkResultWindows[windowId].window);
+            sub_800DAF8(taskId, playerId, gLinkResultWindows[windowId].dest);
+
+            Text_InitWindow8002E4C(
+                gLinkResultWindows[windowId + 1].window,
+                gLinkPlayers[opponentId].name,
+                gLinkResultWindows[windowId + 1].offset,
+                gLinkResultWindows[windowId + 1].left,
+                gLinkResultWindows[windowId + 1].top,
+                1);
+            Text_PrintWindow8002F44(gLinkResultWindows[windowId + 1].window);
+            sub_800DAF8(taskId, opponentId, gLinkResultWindows[windowId + 1].dest);
+        }
+        gTasks[taskId].data[0]++;
+        break;
+
+    case 1:
+        palette = AllocSpritePalette(10000);
+        gPlttBufferUnfaded[palette * 16 + 0x10f] = gPlttBufferFaded[palette * 16 + 0x10f] = 0x7fff;
+        gBattleStruct->unk1608A = CreateSprite(&gSpriteTemplate_81F9574, 108, 80, 0);
+        gBattleStruct->unk1608B = CreateSprite(&gSpriteTemplate_81F958C, 132, 80, 0);
+        gSprites[gBattleStruct->unk1608A].invisible = TRUE;
+        gSprites[gBattleStruct->unk1608B].invisible = TRUE;
+        gTasks[taskId].data[0]++;
+        break;
+
+    case 2:
+        if (gTasks[taskId].data[5]) {
+            gBattle_BG1_X = (-20) - (Sin2(gTasks[taskId].data[1]) / 32);
+            gBattle_BG2_X = (-140) - (Sin2(gTasks[taskId].data[2]) / 32);
+            gBattle_BG1_Y = -36;
+            gBattle_BG2_Y = -36;
+        } else {
+            gBattle_BG1_X = (-20) - (Sin2(gTasks[taskId].data[1]) / 32);
+            gBattle_BG1_Y = (-164) + (Cos2(gTasks[taskId].data[1]) / 32);
+            gBattle_BG2_X = (-140) - (Sin2(gTasks[taskId].data[2]) / 32);
+            gBattle_BG2_Y = (-164) + (Cos2(gTasks[taskId].data[2]) / 32);
+        }
+        if (gTasks[taskId].data[2]) {
+            gTasks[taskId].data[2] -= 2;
+            gTasks[taskId].data[1] += 2;
+        } else {
+            if (gTasks[taskId].data[5]) {
+                PrintLinkBattleWinLossTie();
+            }
+            PlaySE(SE_W231);
+            DestroyTask(taskId);
+            gSprites[gBattleStruct->unk1608A].invisible = FALSE;
+            gSprites[gBattleStruct->unk1608B].invisible = FALSE;
+            gSprites[gBattleStruct->unk1608B].oam.tileNum += 0x40;
+            gSprites[gBattleStruct->unk1608A].data[0] = 0;
+            gSprites[gBattleStruct->unk1608B].data[0] = 1;
+            gSprites[gBattleStruct->unk1608A].data[1] = gSprites[gBattleStruct->unk1608A].pos1.x;
+            gSprites[gBattleStruct->unk1608B].data[1] = gSprites[gBattleStruct->unk1608B].pos1.x;
+            gSprites[gBattleStruct->unk1608A].data[2] = 0;
+            gSprites[gBattleStruct->unk1608B].data[2] = 0;
+        }
+        break;
+    }
+}
+
+void LoadBattleEntryBackground(void) {
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK) {
+        LZDecompressVram(gVersusFrameGfx, (void *)0x6004000);
+        LZDecompressVram(gVersusFrameTilemap, (void *)0x600e000);
+        LZDecompressVram(gVersusFrameTilemap, (void *)0x600f000);
+        LZDecompressVram(gUnknown_08E5DC2C, (void *)0x6010000);
+        LoadCompressedPalette(gVersusFramePal, 0x60, 0x20);
+        REG_BG1CNT = 0x5c04;
+        REG_WININ = 0x36;
+        REG_WINOUT = 0x36;
+        gBattle_BG1_Y = 0xff5c;
+        gBattle_BG2_Y = 0xff5c;
+        LoadCompressedObjectPic(&gUnknown_081F95A4);
+        return;
+    } else if (gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK)) {
+        LZDecompressVram(gBattleTerrainAnimTiles_Building, (void *)0x6004000);
+        LZDecompressVram(gBattleTerrainAnimTilemap_Building, (void *)0x600e000);
+        return;
+    } else if (gBattleTypeFlags & BATTLE_TYPE_KYOGRE_GROUDON) {
+        if (gGameVersion == VERSION_RUBY) {
+            LZDecompressVram(gBattleTerrainAnimTiles_Cave, (void *)0x6004000);
+            LZDecompressVram(gBattleTerrainAnimTilemap_Cave, (void *)0x600e000);
+            return;
+        } else {
+            LZDecompressVram(gBattleTerrainAnimTiles_Underwater, (void *)0x6004000);
+            LZDecompressVram(gBattleTerrainAnimTilemap_Underwater, (void *)0x600e000);
+            return;
+        }
+    } else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) {
+        if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x19) {
+            LZDecompressVram(gBattleTerrainAnimTiles_Building, (void *)0x6004000);
+            LZDecompressVram(gBattleTerrainAnimTilemap_Building, (void *)0x600e000);
+            return;
+        } else if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x20) {
+            LZDecompressVram(gBattleTerrainAnimTiles_Building, (void *)0x6004000);
+            LZDecompressVram(gBattleTerrainAnimTilemap_Building, (void *)0x600e000);
+            return;
+        }
+    }
+    if (sav1_map_get_battletype() == 0) {
+        LZDecompressVram(gBattleTerrainTable[gBattleTerrain].entryTiles, (void *)0x6004000);
+        LZDecompressVram(gBattleTerrainTable[gBattleTerrain].entryTilemap, (void *)0x600e000);
+        return;
+    }
+    LZDecompressVram(gBattleTerrainAnimTiles_Building, (void *)0x6004000);
+    LZDecompressVram(gBattleTerrainAnimTilemap_Building, (void *)0x600e000);
+}
+
+int LoadChosenBattleElement(u8 type) {
+    int ret = 0;
+    switch (type) {
+    case 0:
+        LZDecompressVram(&gBattleTextboxTiles, (void *)0x6000000);
+        break;
+    case 1:
+        CpuCopy16(gBattleTextboxTilemap, (void *)0x600c000, 0x1000);
+        break;
+    case 2:
+        LoadCompressedPalette(gBattleTextboxPalette, 0, 0x40);
+        break;
+    case 3: // tiles
+        if (!(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK))) {
+            if (gBattleTypeFlags & BATTLE_TYPE_KYOGRE_GROUDON) {
+                if (gGameVersion == VERSION_RUBY) {
+                    LZDecompressVram(gBattleTerrainTiles_Cave, (void *)0x6008000);
+                    break;
+                } else {
+                    LZDecompressVram(gBattleTerrainTiles_Water, (void *)0x6008000);
+                    break;
+                }
+            } else {
+                if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) {
+                    if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x19) {
+                        LZDecompressVram(gBattleTerrainTiles_Building, (void *)0x6008000);
+                        break;
+                    } else if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x20) {
+                        LZDecompressVram(gBattleTerrainTiles_Stadium, (void *)0x6008000);
+                        break;
+                    }
+                }
+                switch (sav1_map_get_battletype()) {
+                case 0:
+                    LZDecompressVram(gBattleTerrainTable[gBattleTerrain].tileset, (void *)0x6008000);
+                    break;
+                case 2:
+                    LZDecompressVram(gBattleTerrainTiles_Stadium, (void *)0x6008000);
+                    break;
+                case 3:
+                    LZDecompressVram(gBattleTerrainTiles_Stadium, (void *)0x6008000);
+                    break;
+                case 4:
+                    LZDecompressVram(gBattleTerrainTiles_Stadium, (void *)0x6008000);
+                    break;
+                case 5:
+                    LZDecompressVram(gBattleTerrainTiles_Stadium, (void *)0x6008000);
+                    break;
+                case 6:
+                    LZDecompressVram(gBattleTerrainTiles_Stadium, (void *)0x6008000);
+                    break;
+                case 7:
+                    LZDecompressVram(gBattleTerrainTiles_Stadium, (void *)0x6008000);
+                    break;
+                case 1:
+                case 8:
+                    LZDecompressVram(gBattleTerrainTiles_Building, (void *)0x6008000);
+                    break;
+                }
+                break;
+            }
+        } else {
+            LZDecompressVram(gBattleTerrainTiles_Building, (void *)0x6008000);
+            break;
+        }
+    case 4: // tilemap
+        if (!(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK))) {
+            if (gBattleTypeFlags & BATTLE_TYPE_KYOGRE_GROUDON) {
+                if (gGameVersion == 2) {
+                    LZDecompressVram(gBattleTerrainTilemap_Cave, (void *)0x600d000);
+                    break;
+                } else {
+                    LZDecompressVram(gBattleTerrainTilemap_Water, (void *)0x600d000);
+                    break;
+                }
+            } else {
+                if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) {
+                    if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x19) {
+                        LZDecompressVram(gBattleTerrainTilemap_Building, (void *)0x600d000);
+                        break;
+                    } else if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x20) {
+                        LZDecompressVram(gBattleTerrainTilemap_Stadium, (void *)0x600d000);
+                        break;
+                    }
+                }
+                switch (sav1_map_get_battletype()) {
+                case 0:
+                    LZDecompressVram(gBattleTerrainTable[gBattleTerrain].tilemap, (void *)0x600d000);
+                    break;
+                case 2:
+                    LZDecompressVram(gBattleTerrainTilemap_Stadium, (void *)0x600d000);
+                    break;
+                case 3:
+                    LZDecompressVram(gBattleTerrainTilemap_Stadium, (void *)0x600d000);
+                    break;
+                case 4:
+                    LZDecompressVram(gBattleTerrainTilemap_Stadium, (void *)0x600d000);
+                    break;
+                case 5:
+                    LZDecompressVram(gBattleTerrainTilemap_Stadium, (void *)0x600d000);
+                    break;
+                case 6:
+                    LZDecompressVram(gBattleTerrainTilemap_Stadium, (void *)0x600d000);
+                    break;
+                case 7:
+                    LZDecompressVram(gBattleTerrainTilemap_Stadium, (void *)0x600d000);
+                    break;
+                case 1:
+                case 8:
+                    LZDecompressVram(gBattleTerrainTilemap_Building, (void *)0x600d000);
+                    break;
+                }
+                break;
+            }
+        } else {
+            LZDecompressVram(gBattleTerrainTilemap_Building, (void *)0x600d000);
+            break;
+        }
+    case 5: // palette
+        if (!(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK))) {
+            if (gBattleTypeFlags & BATTLE_TYPE_KYOGRE_GROUDON) {
+                if (gGameVersion == 2) {
+                    LoadCompressedPalette(gBattleTerrainPalette_Groudon, 0x20, 0x60);
+                    break;
+                } else {
+                    LoadCompressedPalette(gBattleTerrainPalette_Kyogre, 0x20, 0x60);
+                    break;
+                }
+            } else {
+                if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) {
+                    if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x19) {
+                        LoadCompressedPalette(gBattleTerrainPalette_BuildingLeader, 0x20, 0x60);
+                        break;
+                    } else if (gTrainers[gTrainerBattleOpponent].trainerClass == 0x20) {
+                        LoadCompressedPalette(gBattleTerrainPalette_StadiumSteven, 0x20, 0x60);
+                        break;
+                    }
+                }
+                switch (sav1_map_get_battletype()) {
+                case 0:
+                    LoadCompressedPalette(gBattleTerrainTable[gBattleTerrain].palette, 0x20, 0x60);
+                    break;
+                case 1:
+                    LoadCompressedPalette(gBattleTerrainPalette_BuildingGym, 0x20, 0x60);
+                    break;
+                case 2:
+                    LoadCompressedPalette(gBattleTerrainPalette_StadiumMagma, 0x20, 0x60);
+                    break;
+                case 3:
+                    LoadCompressedPalette(gBattleTerrainPalette_StadiumAqua, 0x20, 0x60);
+                    break;
+                case 4:
+                    LoadCompressedPalette(gBattleTerrainPalette_StadiumSidney, 0x20, 0x60);
+                    break;
+                case 5:
+                    LoadCompressedPalette(gBattleTerrainPalette_StadiumPhoebe, 0x20, 0x60);
+                    break;
+                case 6:
+                    LoadCompressedPalette(gBattleTerrainPalette_StadiumGlacia, 0x20, 0x60);
+                    break;
+                case 7:
+                    LoadCompressedPalette(gBattleTerrainPalette_StadiumDrake, 0x20, 0x60);
+                    break;
+                case 8:
+                    LoadCompressedPalette(gBattleTerrainPalette_BattleTower, 0x20, 0x60);
+                    break;
+                }
+                break;
+            }
+        } else {
+            LoadCompressedPalette(gBattleTerrainPalette_BattleTower, 0x20, 0x60);
+            break;
+        }
+    case 6:
+        ApplyPlayerChosenFrameToBattleMenu();
+        break;
+    default:
+        ret = 1;
+    }
+    return ret;
+}
diff --git a/src/battle/battle_setup.c b/src/battle/battle_setup.c
index ec4a26bc5..86b272bcb 100644
--- a/src/battle/battle_setup.c
+++ b/src/battle/battle_setup.c
@@ -801,25 +801,25 @@ static u8 GetTrainerBattleTransition(void)
     u8 enemyLevel;
     u8 playerLevel;
 
-    if (gTrainerBattleOpponent == SECRET_BASE_OPPONENT) // link battle?
+    if (gTrainerBattleOpponent == SECRET_BASE_OPPONENT)
         return B_TRANSITION_STEVEN;
 
     trainer = gTrainers;
 
-    if (trainer[gTrainerBattleOpponent].trainerClass == 24) // league?
+    if (trainer[gTrainerBattleOpponent].trainerClass == TRAINER_CLASS_ELITE_FOUR)
     {
-        if (gTrainerBattleOpponent == 261)
+        if (gTrainerBattleOpponent == OPPONENT_SIDNEY)
             return B_TRANSITION_SYDNEY;
-        if (gTrainerBattleOpponent == 262)
+        if (gTrainerBattleOpponent == OPPONENT_PHOEBE)
             return B_TRANSITION_PHOEBE;
-        if (gTrainerBattleOpponent == 263)
+        if (gTrainerBattleOpponent == OPPONENT_GLACIA)
             return B_TRANSITION_GLACIA;
-        if (gTrainerBattleOpponent == 264)
+        if (gTrainerBattleOpponent == OPPONENT_DRAKE)
             return B_TRANSITION_DRAKE;
         return B_TRANSITION_STEVEN;
     }
 
-    if (trainer[gTrainerBattleOpponent].trainerClass == 32) // team leader?
+    if (trainer[gTrainerBattleOpponent].trainerClass == TRAINER_CLASS_CHAMPION)
         return B_TRANSITION_STEVEN;
 
     if (trainer[gTrainerBattleOpponent].doubleBattle == TRUE)
@@ -1095,7 +1095,7 @@ void CB2_EndTrainerBattle(void)
 {
     if (gTrainerBattleOpponent == SECRET_BASE_OPPONENT)
     {
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music); // link battle?
+        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
     }
     else if (IsPlayerDefeated(gBattleOutcome) == TRUE)
     {
@@ -1112,7 +1112,7 @@ void CB2_EndTrainerEyeRematchBattle(void)
 {
     if (gTrainerBattleOpponent == SECRET_BASE_OPPONENT)
     {
-        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music); // link battle?
+        SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music);
     }
     else if (IsPlayerDefeated(gBattleOutcome) == TRUE)
     {
diff --git a/src/battle/reshow_battle_screen.c b/src/battle/reshow_battle_screen.c
index 0da29441e..85aa78ca0 100644
--- a/src/battle/reshow_battle_screen.c
+++ b/src/battle/reshow_battle_screen.c
@@ -29,7 +29,7 @@ extern u8 gBankSpriteIds[4];
 extern u8 gBattleMonForms[4];
 extern u8 gHealthboxIDs[4];
 
-bool8 sub_800E414(u8 a0);
+bool8 LoadChosenBattleElement(u8 a0);
 bool8 sub_8031C30(u8 a0);
 void sub_8031EE8(void);
 void sub_80327CC(void);
@@ -97,7 +97,7 @@ static void CB2_ReshowBattleScreenAfterMenu(void)
         }
         break;
     case 2:
-        if (!sub_800E414(gHelperState))
+        if (!LoadChosenBattleElement(gHelperState))
         {
             gHelperState++;
             gReshowState--;
diff --git a/src/egg_hatch.c b/src/egg_hatch.c
index 282ad31fb..5bba69f86 100644
--- a/src/egg_hatch.c
+++ b/src/egg_hatch.c
@@ -40,9 +40,9 @@ struct EggHatchData
 
 struct EggHatchData* gEggHatchData;
 
-extern const u32 gUnknown_08D00000[];
-extern const u32 gUnknown_08D00524[];
-extern const u16 gUnknown_08D004E0[]; //palette
+extern const u32 gBattleTextboxTiles[];
+extern const u32 gBattleTextboxTilemap[];
+extern const u16 gBattleTextboxPalette[]; //palette
 extern const struct SpriteSheet sUnknown_0820A3B0;
 extern const struct SpriteSheet sUnknown_0820A3B8;
 extern const struct SpritePalette sUnknown_0820A3C0;
@@ -478,10 +478,10 @@ static void CB2_EggHatch_0(void)
         gMain.state++;
         break;
     case 2:
-        LZDecompressVram(&gUnknown_08D00000, (void*)(VRAM));
-        CpuSet(&gUnknown_08D00524, ewram0_7, 0x800);
+        LZDecompressVram(&gBattleTextboxTiles, (void*)(VRAM));
+        CpuSet(&gBattleTextboxTilemap, ewram0_7, 0x800);
         DmaCopy16(3, ewram0_7, (void*)(VRAM + 0x2800), 0x500);
-        LoadCompressedPalette(&gUnknown_08D004E0, 0, 0x20);
+        LoadCompressedPalette(&gBattleTextboxPalette, 0, 0x20);
         gMain.state++;
         break;
     case 3:
diff --git a/src/evolution_scene.c b/src/evolution_scene.c
index 3ba325574..a3a5dbcec 100644
--- a/src/evolution_scene.c
+++ b/src/evolution_scene.c
@@ -212,7 +212,7 @@ void EvolutionScene(struct Pokemon* mon, u16 speciesToEvolve, bool8 canStopEvo,
     gBattleTerrain = BATTLE_TERRAIN_PLAIN;
 
     sub_800D6D4();
-    sub_800DAB8();
+    LoadBattleTextboxAndBackground();
     ResetSpriteData();
     ScanlineEffect_Stop();
     ResetTasks();
@@ -320,7 +320,7 @@ static void CB2_EvolutionSceneLoadGraphics(void)
     gBattleTerrain = BATTLE_TERRAIN_PLAIN;
 
     sub_800D6D4();
-    sub_800DAB8();
+    LoadBattleTextboxAndBackground();
     ResetSpriteData();
     FreeAllSpritePalettes();
     gReservedSpritePaletteCount = 4;
diff --git a/src/pokedex.c b/src/pokedex.c
index 711dc69fa..f7baced63 100644
--- a/src/pokedex.c
+++ b/src/pokedex.c
@@ -3922,8 +3922,8 @@ static void sub_8090B8C(u8 taskId)
         const u8 *lzPaletteData;
 
         REG_DISPCNT = DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON | DISPCNT_BG3_ON | DISPCNT_OBJ_ON;
-        CpuCopy16(gUnknown_08D00524, (void *)(VRAM + 0xC000), 0x1000);
-        sub_800D74C();
+        CpuCopy16(gBattleTextboxTilemap, (void *)(VRAM + 0xC000), 0x1000);
+        ApplyPlayerChosenFrameToBattleMenu();
         species = NationalPokedexNumToSpecies(gTasks[taskId].data[1]);
         otId = ((u16)gTasks[taskId].data[13] << 16) | (u16)gTasks[taskId].data[12];
         personality = ((u16)gTasks[taskId].data[15] << 16) | (u16)gTasks[taskId].data[14];
diff --git a/src/pokemon_2.c b/src/pokemon_2.c
index 7fd1aa7b2..17f073815 100644
--- a/src/pokemon_2.c
+++ b/src/pokemon_2.c
@@ -1102,8 +1102,8 @@ void CreateSecretBaseEnemyParty(struct SecretBaseRecord *secretBaseRecord)
         }
     }
 
-    gBattleTypeFlags = 8;
-    gTrainerBattleOpponent = 1024;
+    gBattleTypeFlags = BATTLE_TYPE_TRAINER;
+    gTrainerBattleOpponent = SECRET_BASE_OPPONENT;
 }
 
 const u8 gSecretBaseTrainerClasses[][5] = {
diff --git a/src/rom_800D42C.c b/src/rom_800D42C.c
deleted file mode 100644
index a1b0f5ecb..000000000
--- a/src/rom_800D42C.c
+++ /dev/null
@@ -1,119 +0,0 @@
-#include "global.h"
-#include "battle.h"
-#include "link.h"
-#include "text.h"
-#include "ewram.h"
-
-extern u16 gBattleTypeFlags;
-extern u8 gBattleOutcome;
-
-extern struct Window gUnknown_03004210;
-
-extern u8 BattleText_Win[];
-extern u8 BattleText_Loss[];
-extern u8 BattleText_Tie[];
-
-#if ENGLISH
-#define LEFT_MESSAGE_X 6
-#define RIGHT_MESSAGE_X 21
-#define TILE_OFFSET_LOSS 168
-#elif GERMAN
-#define LEFT_MESSAGE_X 5
-#define RIGHT_MESSAGE_X 20
-#define TILE_OFFSET_LOSS 172
-#endif
-#define TILE_OFFSET_WIN 160
-#define CENTER_MESSAGE_X 13
-#define MESSAGE_Y 2
-
-#define PRINT_MESSAGE(text, tileDataStartOffset, x)                             \
-{                                                                               \
-    Text_InitWindow(&gUnknown_03004210, text, tileDataStartOffset, x, MESSAGE_Y);    \
-    Text_PrintWindow8002F44(&gUnknown_03004210);                                            \
-}
-
-#define PRINT_MESSAGE_LEFT(text, tileDataStartOffset)       PRINT_MESSAGE(text, tileDataStartOffset, LEFT_MESSAGE_X)
-#define PRINT_MESSAGE_RIGHT(text, tileDataStartOffset)      PRINT_MESSAGE(text, tileDataStartOffset, RIGHT_MESSAGE_X)
-
-void PrintLinkBattleWinLossTie(void)
-{
-
-    if (gBattleOutcome == 3)
-    {
-        PRINT_MESSAGE(BattleText_Tie, TILE_OFFSET_WIN, CENTER_MESSAGE_X);
-        return;
-    }
-
-    if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
-    {
-        // Double battle?
-
-        if (gBattleOutcome == 1)
-        {
-
-            // lp_field_18 = player position?
-            switch (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18)
-            {
-            case 0:
-            case 2:
-                PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
-                PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
-                return;
-
-            case 1:
-            case 3:
-                PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN)
-                PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS)
-                return;
-            }
-        }
-        else
-        {
-
-            switch (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18)
-            {
-            case 1:
-            case 3:
-                PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
-                PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
-                return;
-
-            case 0:
-            case 2:
-                PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN);
-                PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS);
-                return;
-            }
-        }
-
-        return;
-    }
-
-
-    if (gBattleOutcome == 1)
-    {
-        if (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18 != 0)
-        {
-            PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN);
-            PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS);
-        }
-        else
-        {
-            PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
-            PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
-        }
-    }
-    else
-    {
-        if (gLinkPlayers[gBattleStruct->linkPlayerIndex].lp_field_18 != 0)
-        {
-            PRINT_MESSAGE_LEFT(BattleText_Win, TILE_OFFSET_WIN);
-            PRINT_MESSAGE_RIGHT(BattleText_Loss, TILE_OFFSET_LOSS);
-        }
-        else
-        {
-            PRINT_MESSAGE_RIGHT(BattleText_Win, TILE_OFFSET_WIN);
-            PRINT_MESSAGE_LEFT(BattleText_Loss, TILE_OFFSET_LOSS);
-        }
-    }
-}
diff --git a/src/trade.c b/src/trade.c
index 36e6fc757..a05bddee4 100644
--- a/src/trade.c
+++ b/src/trade.c
@@ -4018,10 +4018,10 @@ static void sub_804B41C(void)
             Menu_EraseScreen();
             gLinkType = 0x1144;
             gMain.state ++;
-            LZDecompressVram(gUnknown_08D00000, (void *)VRAM);
-            CpuCopy16(gUnknown_08D00524, ewram, 0x1000);
+            LZDecompressVram(gBattleTextboxTiles, (void *)VRAM);
+            CpuCopy16(gBattleTextboxTilemap, ewram, 0x1000);
             DmaCopy16Defvars(3, ewram, BG_SCREEN_ADDR(5), 0x500);
-            LoadCompressedPalette(gUnknown_08D004E0, 0, 32);
+            LoadCompressedPalette(gBattleTextboxPalette, 0, 32);
             gUnknown_03004828->unk_00b6 = 0;
             gUnknown_03004828->unk_00c4 = 0;
             gUnknown_03004828->isLinkTrade = TRUE;
@@ -4191,11 +4191,11 @@ static __attribute__((naked)) void sub_804B41C(void)
                     "\tldrb r0, [r1]\n"
                     "\tadds r0, 0x1\n"
                     "\tstrb r0, [r1]\n"
-                    "\tldr r0, _0804B590 @ =gUnknown_08D00000\n"
+                    "\tldr r0, _0804B590 @ =gBattleTextboxTiles\n"
                     "\tmovs r1, 0xC0\n"
                     "\tlsls r1, 19\n"
                     "\tbl LZDecompressVram\n"
-                    "\tldr r0, _0804B594 @ =gUnknown_08D00524\n"
+                    "\tldr r0, _0804B594 @ =gBattleTextboxTilemap\n"
                     "\tldr r1, _0804B598 @ =0xfffe1000\n"
                     "\tadds r5, r1\n"
                     "\tmovs r2, 0x80\n"
@@ -4209,7 +4209,7 @@ static __attribute__((naked)) void sub_804B41C(void)
                     "\tldr r1, _0804B5A4 @ =0x80000280\n"
                     "\tstr r1, [r0, 0x8]\n"
                     "\tldr r0, [r0, 0x8]\n"
-                    "\tldr r0, _0804B5A8 @ =gUnknown_08D004E0\n"
+                    "\tldr r0, _0804B5A8 @ =gBattleTextboxPalette\n"
                     "\tmovs r1, 0\n"
                     "\tmovs r2, 0x20\n"
                     "\tbl LoadCompressedPalette\n"
@@ -4267,13 +4267,13 @@ static __attribute__((naked)) void sub_804B41C(void)
                     "_0804B584: .4byte 0x00001144\n"
                     "_0804B588: .4byte gMain\n"
                     "_0804B58C: .4byte 0x0000043c\n"
-                    "_0804B590: .4byte gUnknown_08D00000\n"
-                    "_0804B594: .4byte gUnknown_08D00524\n"
+                    "_0804B590: .4byte gBattleTextboxTiles\n"
+                    "_0804B594: .4byte gBattleTextboxTilemap\n"
                     "_0804B598: .4byte 0xfffe1000\n"
                     "_0804B59C: .4byte 0x06002800\n"
                     "_0804B5A0: .4byte 0x040000d4\n"
                     "_0804B5A4: .4byte 0x80000280\n"
-                    "_0804B5A8: .4byte gUnknown_08D004E0\n"
+                    "_0804B5A8: .4byte gBattleTextboxPalette\n"
                     "_0804B5AC_case01:\n"
                     "\tbl OpenLink\n"
                     "\tldr r1, _0804B5C8 @ =gMain\n"
@@ -4709,9 +4709,9 @@ static void sub_804BBE8(u8 a0)
             gUnknown_03004828->bg1vofs = 0;
             gUnknown_03004828->bg1hofs = 0;
             REG_BG1CNT = BGCNT_PRIORITY(2) | BGCNT_CHARBASE(0) | BGCNT_SCREENBASE(5);
-            LZDecompressVram(gUnknown_08D00000, BG_CHAR_ADDR(0));
-            CpuCopy16(gUnknown_08D00524, buffer = (u16 *)gSharedMem, 0x1000);
-            LoadCompressedPalette(gUnknown_08D004E0, 0x70, 0x20);
+            LZDecompressVram(gBattleTextboxTiles, BG_CHAR_ADDR(0));
+            CpuCopy16(gBattleTextboxTilemap, buffer = (u16 *)gSharedMem, 0x1000);
+            LoadCompressedPalette(gBattleTextboxPalette, 0x70, 0x20);
             FillPalette(0, 0, 2);
             for (i = 0; i < 0x280; i ++)
                 buffer[i] |= 0x7000;
@@ -5684,9 +5684,9 @@ static void sub_804E1DC(void)
 
 void sub_804E22C(void)
 {
-    LZDecompressVram(gUnknown_08D00000, (void *)VRAM);
-    CpuCopy16(gUnknown_08D00524, gSharedMem, 0x1000);
+    LZDecompressVram(gBattleTextboxTiles, (void *)VRAM);
+    CpuCopy16(gBattleTextboxTilemap, gSharedMem, 0x1000);
     DmaCopy16Defvars(3, gSharedMem, BG_SCREEN_ADDR(5), 0x500);
-    LoadCompressedPalette(gUnknown_08D004E0, 0, 32);
+    LoadCompressedPalette(gBattleTextboxPalette, 0, 32);
     REG_BG1CNT = BGCNT_PRIORITY(2) | BGCNT_SCREENBASE(5);
 }