Merge pull request #142 from PikalaxALT/dism_more_data

Dism more data still

20 files changed, 1748 insertions, 439 deletions

diff --git a/src/cereader_tool.c b/src/cereader_tool.c
index 066702fe0..654a70b48 100644
--- a/src/cereader_tool.c
+++ b/src/cereader_tool.c
@@ -47,11 +47,11 @@ static bool32 CEReaderTool_SaveTrainerTower_r(struct EReaderTrainerHillSet * ttd
     memset(buffer, 0, 0x1000);
     memcpy(buffer, ttdata, SEC30_SIZE);
     buffer[1] = sub_815D654();
-    if (TryWriteSpecialSaveSection(30, buffer) != TRUE)
+    if (TryWriteSpecialSaveSection(SECTOR_TTOWER(0), buffer) != TRUE)
         return FALSE;
     memset(buffer, 0, 0x1000);
     memcpy(buffer, (u8 *)ttdata + SEC30_SIZE, SEC31_SIZE);
-    if (TryWriteSpecialSaveSection(31, buffer) != TRUE)
+    if (TryWriteSpecialSaveSection(SECTOR_TTOWER(1), buffer) != TRUE)
         return FALSE;
     return TRUE;
 }
@@ -66,11 +66,11 @@ bool32 CEReaderTool_SaveTrainerTower(struct EReaderTrainerHillSet * ttdata)
 
 static bool32 CEReaderTool_LoadTrainerTower_r(struct EReaderTrainerHillSet * ttdata, void * buffer)
 {
-    if (TryCopySpecialSaveSection(30, buffer) != 1)
+    if (TryCopySpecialSaveSection(SECTOR_TTOWER(0), buffer) != 1)
         return FALSE;
     memcpy(ttdata + 0x000, buffer, SEC30_SIZE);
 
-    if (TryCopySpecialSaveSection(31, buffer) != 1)
+    if (TryCopySpecialSaveSection(SECTOR_TTOWER(1), buffer) != 1)
         return FALSE;
     memcpy((u8 *)ttdata + SEC30_SIZE, buffer, SEC31_SIZE);
 
diff --git a/src/credits.c b/src/credits.c
index ad78d875c..a0138e57a 100644
--- a/src/credits.c
+++ b/src/credits.c
@@ -188,6 +188,7 @@ struct CreditsTaskData
 };
 
 static EWRAM_DATA struct CreditsResources * sCreditsMgr = NULL;
+EWRAM_DATA bool8 gHasHallOfFameRecords = FALSE;
 
 static void CB2_Credits(void);
 static s32 RollCredits(void);
diff --git a/src/easy_chat.c b/src/easy_chat.c
index fd96f6a30..be617133b 100644
--- a/src/easy_chat.c
+++ b/src/easy_chat.c
@@ -485,10 +485,10 @@ void InitEasyChatPhrases(void)
         gSaveBlock1Ptr->additionalPhrases[i] = 0;
 }
 
-void ResetSomeMEventECBuffer_3120_338(void)
+void EC_ResetMEventProfileMaybe(void)
 {
     s32 i;
-    u16 *ptr = sub_8143DA8();
+    u16 *ptr = GetMEventProfileECWordsMaybe();
     for (i = 0; i < 4; i++)
         ptr[i] = EC_WORD_UNDEFINED;
 }
diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c
new file mode 100644
index 000000000..4ed0d3f04
--- /dev/null
+++ b/src/hall_of_fame.c
@@ -0,0 +1,1293 @@
+#include "global.h"
+#include "palette.h"
+#include "malloc.h"
+#include "decompress.h"
+#include "bg.h"
+#include "scanline_effect.h"
+#include "gpu_regs.h"
+#include "task.h"
+#include "text.h"
+#include "main.h"
+#include "sound.h"
+#include "save.h"
+#include "data.h"
+#include "m4a.h"
+#include "help_system.h"
+#include "hall_of_fame.h"
+#include "quest_log.h"
+#include "pc_screen_effect.h"
+#include "new_menu_helpers.h"
+#include "strings.h"
+#include "credits.h"
+#include "event_data.h"
+#include "overworld.h"
+#include "trainer_pokemon_sprites.h"
+#include "text_window.h"
+#include "field_fadetransition.h"
+#include "menu.h"
+#include "string_util.h"
+#include "trig.h"
+#include "random.h"
+#include "graphics.h"
+#include "constants/songs.h"
+#include "constants/species.h"
+#include "constants/flags.h"
+#include "constants/vars.h"
+#include "constants/maps.h"
+
+struct HallofFameMon
+{
+    u32 tid;
+    u32 personality;
+    u16 species:9;
+    u16 lvl:7;
+    u8 nick[10];
+};
+
+struct HallofFameTeam
+{
+    struct HallofFameMon mon[PARTY_SIZE];
+};
+
+struct HofGfx
+{
+    u16 state;
+    u8 field_2[4];
+    u8 tilemap1[0x1000];
+    u8 tilemap2[0x1000];
+};
+
+static EWRAM_DATA u32 sSelectedPaletteIndices = 0;
+static EWRAM_DATA struct HallofFameTeam * sHofMonPtr = NULL;
+static EWRAM_DATA struct HofGfx * sHofGfxPtr = NULL;
+
+#define HALL_OF_FAME_MAX_TEAMS 50
+#define HALL_OF_FAME_BG_PAL    (RGB(22, 24, 29))
+
+static void Task_Hof_InitMonData(u8 taskId);
+static void Task_Hof_InitTeamSaveData(u8 taskId);
+static void Task_Hof_TrySaveData(u8 taskId);
+static void Task_Hof_DelayAfterSave(u8 taskId);
+static void Task_Hof_StartDisplayingMons(u8 taskId);
+static void Task_Hof_DisplayMon(u8 taskId);
+static void Task_Hof_PlayMonCryAndPrintInfo(u8 taskId);
+static void Task_Hof_TryDisplayAnotherMon(u8 taskId);
+static void Task_Hof_PaletteFadeAndPrintWelcomeText(u8 taskId);
+static void Task_Hof_ApplauseAndConfetti(u8 taskId);
+static void Task_Hof_WaitBorderFadeAway(u8 taskId);
+static void Task_Hof_SpawnPlayerPic(u8 taskId);
+static void Task_Hof_WaitAndPrintPlayerInfo(u8 taskId);
+static void Task_Hof_ExitOnKeyPressed(u8 taskId);
+static void Task_Hof_HandlePaletteOnExit(u8 taskId);
+static void Task_Hof_HandleExit(u8 taskId);
+static void SetWarpsToRollCredits(void);
+static void Task_HofPC_CopySaveData(u8 taskId);
+static void Task_HofPC_DrawSpritesPrintText(u8 taskId);
+static void Task_HofPC_PrintMonInfo(u8 taskId);
+static void Task_HofPC_HandleInput(u8 taskId);
+static void Task_HofPC_HandlePaletteOnExit(u8 taskId);
+static void Task_HofPC_HandleExit(u8 taskId);
+static void Task_HofPC_PrintDataIsCorrupted(u8 taskId);
+static void Task_HofPC_ExitOnButtonPress(u8 taskId);
+static void HallOfFame_PrintWelcomeText(u8 a0, u8 a1);
+static void HallOfFame_PrintMonInfo(struct HallofFameMon * hofMon, u8 a1, u8 a2);
+static void HallOfFame_PrintPlayerInfo(u8 a0, u8 a1);
+static void ClearVramOamPltt_LoadHofPal(void);
+static void HofInit_ResetGpuBuffersAndLoadConfettiGfx(void);
+static void Hof_InitBgs(void);
+static bool8 DrawHofBackground(void);
+static void SpriteCB_GetOnScreen(struct Sprite * sprite);
+static void SpriteCB_Confetti(struct Sprite * sprite);
+static bool8 Hof_SpawnConfetti(void);
+
+static const struct BgTemplate sHof_BgTemplates[] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0x000
+    },
+    {
+        .bg = 1,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0x000
+    },
+    {
+        .bg = 3,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 29,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0x000
+    }
+};
+
+static const struct WindowTemplate sWindowTemplate = {
+    .bg = 0,
+    .tilemapLeft = 2,
+    .tilemapTop = 2,
+    .width = 17,
+    .height = 6,
+    .paletteNum = 13,
+    .baseBlock = 0x001
+};
+
+static const u8 sTextColors[][4] = {
+    { 0, 1, 2 },
+    { 0, 2, 3 },
+    { 4, 5, 0 }
+};
+
+static const struct CompressedSpriteSheet sHallOfFame_ConfettiSpriteSheet[] = {
+    {gFile_graphics_misc_confetti_sheet, 0x220, 1001},
+    {}
+};
+
+static const struct CompressedSpritePalette sHallOfFame_ConfettiSpritePalette[] = {
+    {gFile_graphics_misc_confetti_palette, 1001},
+    {}
+};
+
+static const s16 sHallOfFame_MonFullTeamPositions[6][4] =
+{
+    {120,   210,    120,    40},
+    {326,   220,    56,     40},
+    {-86,   220,    184,    40},
+    {120,   -62,    120,    88},
+    {-70,   -92,    200,    88},
+    {310,   -92,    40,     88}
+};
+
+static const s16 sHallOfFame_MonHalfTeamPositions[3][4] =
+{
+    {120,   234,    120,    64},
+    {326,   244,    56,     64},
+    {-86,   244,    184,    64}
+};
+
+static const struct OamData sOamData_Confetti = {
+    .shape = SPRITE_SHAPE(8x8),
+    .size = SPRITE_SIZE(8x8)
+};
+
+static const union AnimCmd sAnimCmd_Frame00[] = {
+    ANIMCMD_FRAME( 0, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame01[] = {
+    ANIMCMD_FRAME( 1, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame02[] = {
+    ANIMCMD_FRAME( 2, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame03[] = {
+    ANIMCMD_FRAME( 3, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame04[] = {
+    ANIMCMD_FRAME( 4, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame05[] = {
+    ANIMCMD_FRAME( 5, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame06[] = {
+    ANIMCMD_FRAME( 6, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame07[] = {
+    ANIMCMD_FRAME( 7, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame08[] = {
+    ANIMCMD_FRAME( 8, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame09[] = {
+    ANIMCMD_FRAME( 9, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame10[] = {
+    ANIMCMD_FRAME(10, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame11[] = {
+    ANIMCMD_FRAME(11, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame12[] = {
+    ANIMCMD_FRAME(12, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame13[] = {
+    ANIMCMD_FRAME(13, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame14[] = {
+    ANIMCMD_FRAME(14, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame15[] = {
+    ANIMCMD_FRAME(15, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_Frame16[] = {
+    ANIMCMD_FRAME(16, 30),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_Confetti[] = {
+    sAnimCmd_Frame00,
+    sAnimCmd_Frame01,
+    sAnimCmd_Frame02,
+    sAnimCmd_Frame03,
+    sAnimCmd_Frame04,
+    sAnimCmd_Frame05,
+    sAnimCmd_Frame06,
+    sAnimCmd_Frame07,
+    sAnimCmd_Frame08,
+    sAnimCmd_Frame09,
+    sAnimCmd_Frame10,
+    sAnimCmd_Frame11,
+    sAnimCmd_Frame12,
+    sAnimCmd_Frame13,
+    sAnimCmd_Frame14,
+    sAnimCmd_Frame15,
+    sAnimCmd_Frame16
+};
+
+static const struct SpriteTemplate sSpriteTemplate_Confetti = {
+    .tileTag = 1001,
+    .paletteTag = 1001,
+    .oam = &sOamData_Confetti,
+    .anims = sSpriteAnimTable_Confetti,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_Confetti
+};
+
+static const u16 sHallOfFame_Pal[] = INCBIN_U16("graphics/hall_of_fame/unk_840C3BC.gbapal");
+static const u32 sHallOfFame_Gfx[] = INCBIN_U32("graphics/hall_of_fame/unk_840C3BC.4bpp.lz");
+
+static const struct HallofFameMon sDummyHofMon = {
+    .tid = 0x03EA03EA, // (u16[]){1002, 1002} corrupted sprite template?
+    .personality = 0,
+    .species = SPECIES_NONE,
+    .lvl = 0,
+    .nick = __("          ")
+};
+
+static const u8 sUnused[] = {2, 1, 3, 6, 4, 5};
+
+static void VBlankCB_HofIdle(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static void CB2_HofIdle(void)
+{
+    RunTasks();
+    RunTextPrinters();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static bool8 InitHallOfFameScreen(void)
+{
+    switch (gMain.state)
+    {
+    case 0:
+        gHelpSystemEnabled = FALSE;
+        SetVBlankCallback(NULL);
+        ClearVramOamPltt_LoadHofPal();
+        sHofGfxPtr = AllocZeroed(sizeof(struct HofGfx));
+        gMain.state = 1;
+        break;
+    case 1:
+        HofInit_ResetGpuBuffersAndLoadConfettiGfx();
+        gMain.state++;
+        break;
+    case 2:
+        SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL);
+        SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 7));
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        Hof_InitBgs();
+        sHofGfxPtr->state = 0;
+        gMain.state++;
+        break;
+    case 3:
+        if (!DrawHofBackground())
+        {
+            SetVBlankCallback(VBlankCB_HofIdle);
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+            gMain.state++;
+        }
+        break;
+    case 4:
+        UpdatePaletteFade();
+        if (!gPaletteFade.active)
+        {
+            SetMainCallback2(CB2_HofIdle);
+            PlayBGM(MUS_DENDOU);
+            return FALSE;
+        }
+        break;
+    }
+    return TRUE;
+}
+
+void CB2_DoHallOfFameScreen(void)
+{
+    u8 taskId;
+    if (!InitHallOfFameScreen())
+    {
+        taskId = CreateTask(Task_Hof_InitMonData, 0);
+        gTasks[taskId].data[0] = FALSE;
+        sHofMonPtr = AllocZeroed(sizeof(struct HallofFameTeam));
+    }
+}
+
+void CB2_DoHallOfFameScreenDontSaveData(void)
+{
+    u8 taskId;
+    if (!InitHallOfFameScreen())
+    {
+        taskId = CreateTask(Task_Hof_InitMonData, 0);
+        gTasks[taskId].data[0] = TRUE;
+    }
+}
+
+static void Task_Hof_InitMonData(u8 taskId)
+{
+    u16 i;
+    u16 j;
+    u8 nick[11];
+
+    gTasks[taskId].data[2] = 0;
+    for (i = 0; i < PARTY_SIZE; i++)
+    {
+        if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE)
+        {
+            sHofMonPtr[0].mon[i].species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2);
+            sHofMonPtr[0].mon[i].tid = GetMonData(&gPlayerParty[i], MON_DATA_OT_ID);
+            sHofMonPtr[0].mon[i].personality = GetMonData(&gPlayerParty[i], MON_DATA_PERSONALITY);
+            sHofMonPtr[0].mon[i].lvl = GetMonData(&gPlayerParty[i], MON_DATA_LEVEL);
+            GetMonData(&gPlayerParty[i], MON_DATA_NICKNAME, nick);
+            for (j = 0; j < 10; j++)
+                sHofMonPtr[0].mon[i].nick[j] = nick[j];
+            gTasks[taskId].data[2]++;
+        }
+        else
+        {
+            sHofMonPtr[0].mon[i].species = SPECIES_NONE;
+            sHofMonPtr[0].mon[i].tid = 0;
+            sHofMonPtr[0].mon[i].personality = 0;
+            sHofMonPtr[0].mon[i].lvl = 0;
+            sHofMonPtr[0].mon[i].nick[0] = EOS;
+        }
+    }
+    sSelectedPaletteIndices = 0;
+    gTasks[taskId].data[1] = 0;
+    gTasks[taskId].data[4] = 0xFF;
+    for (i = 0; i < 6; i++)
+        gTasks[taskId].data[i + 5] = 0xFF;
+    if (gTasks[taskId].data[0])
+        gTasks[taskId].func = Task_Hof_StartDisplayingMons;
+    else
+        gTasks[taskId].func = Task_Hof_InitTeamSaveData;
+}
+
+static void Task_Hof_InitTeamSaveData(u8 taskId)
+{
+    u16 i;
+    struct HallofFameTeam* lastSavedTeam = (struct HallofFameTeam *)(gDecompressionBuffer);
+
+    sub_8112450();
+    if (!gHasHallOfFameRecords)
+    {
+        memset(gDecompressionBuffer, 0, 0x2000);
+    }
+    else
+    {
+        if (Save_LoadGameData(SAVE_HALL_OF_FAME) != TRUE)
+            memset(gDecompressionBuffer, 0, 0x2000);
+    }
+
+    for (i = 0; i < HALL_OF_FAME_MAX_TEAMS; i++, lastSavedTeam++)
+    {
+        if (lastSavedTeam[0].mon[0].species == SPECIES_NONE)
+            break;
+    }
+    if (i >= HALL_OF_FAME_MAX_TEAMS)
+    {
+        struct HallofFameTeam *afterTeam = (struct HallofFameTeam*)(gDecompressionBuffer);
+        struct HallofFameTeam *beforeTeam = (struct HallofFameTeam*)(gDecompressionBuffer);
+        afterTeam++;
+        for (i = 0; i < HALL_OF_FAME_MAX_TEAMS - 1; i++, beforeTeam++, afterTeam++)
+        {
+            *beforeTeam = *afterTeam;
+        }
+        lastSavedTeam--;
+    }
+    *lastSavedTeam = *sHofMonPtr;
+
+    DrawDialogueFrame(0, 0);
+    AddTextPrinterParameterized2(0, 2, gText_SavingDontTurnOffThePower2, 0, NULL, 2, 1, 3);
+    CopyWindowToVram(0, 3);
+    gTasks[taskId].func = Task_Hof_TrySaveData;
+}
+
+static void Task_Hof_TrySaveData(u8 taskId)
+{
+    gGameContinueCallback = CB2_DoHallOfFameScreenDontSaveData;
+    TrySavingData(SAVE_HALL_OF_FAME);
+    PlaySE(SE_SAVE);
+    gTasks[taskId].func = Task_Hof_DelayAfterSave;
+    gTasks[taskId].data[3] = 32;
+}
+
+static void Task_Hof_DelayAfterSave(u8 taskId)
+{
+    if (gTasks[taskId].data[3] != 0)
+        gTasks[taskId].data[3]--;
+    else
+        gTasks[taskId].func = Task_Hof_StartDisplayingMons;
+}
+
+static void Task_Hof_StartDisplayingMons(u8 taskId)
+{
+    gTasks[taskId].func = Task_Hof_DisplayMon;
+}
+
+static void Task_Hof_DisplayMon(u8 taskId)
+{
+    u8 spriteId;
+    s16 srcX;
+    s16 srcY;
+    s16 dstX;
+    s16 dstY;
+
+    u16 currMonId = gTasks[taskId].data[1];
+    struct HallofFameMon* currMon = &sHofMonPtr[0].mon[currMonId];
+
+
+    if (gTasks[taskId].data[2] > 3)
+    {
+        srcX = sHallOfFame_MonFullTeamPositions[currMonId][0];
+        srcY = sHallOfFame_MonFullTeamPositions[currMonId][1];
+        dstX = sHallOfFame_MonFullTeamPositions[currMonId][2];
+        dstY = sHallOfFame_MonFullTeamPositions[currMonId][3];
+    }
+    else
+    {
+        srcX = sHallOfFame_MonHalfTeamPositions[currMonId][0];
+        srcY = sHallOfFame_MonHalfTeamPositions[currMonId][1];
+        dstX = sHallOfFame_MonHalfTeamPositions[currMonId][2];
+        dstY = sHallOfFame_MonHalfTeamPositions[currMonId][3];
+    }
+
+    spriteId = CreateMonPicSprite_HandleDeoxys(currMon->species, currMon->tid, currMon->personality, 1, srcX, srcY, currMonId, 0xFFFF);
+    gSprites[spriteId].data[1] = dstX;
+    gSprites[spriteId].data[2] = dstY;
+    gSprites[spriteId].data[0] = 0;
+    gSprites[spriteId].callback = SpriteCB_GetOnScreen;
+    gTasks[taskId].data[5 + currMonId] = spriteId;
+    ClearDialogWindowAndFrame(0, TRUE);
+    gTasks[taskId].func = Task_Hof_PlayMonCryAndPrintInfo;
+}
+
+static void Task_Hof_PlayMonCryAndPrintInfo(u8 taskId)
+{
+    u16 currMonId = gTasks[taskId].data[1];
+    struct HallofFameMon* currMon = &sHofMonPtr[0].mon[currMonId];
+    if (gSprites[gTasks[taskId].data[5 + currMonId]].data[0])
+    {
+        if (currMon->species != SPECIES_EGG)
+            PlayCry1(currMon->species, 0);
+        HallOfFame_PrintMonInfo(currMon, 0, 14);
+        gTasks[taskId].data[3] = 120;
+        gTasks[taskId].func = Task_Hof_TryDisplayAnotherMon;
+    }
+}
+
+static void Task_Hof_TryDisplayAnotherMon(u8 taskId)
+{
+    u16 currPokeId = gTasks[taskId].data[1];
+    struct HallofFameMon* currMon = &sHofMonPtr[0].mon[currPokeId];
+
+    if (gTasks[taskId].data[3] != 0)
+    {
+        gTasks[taskId].data[3]--;
+    }
+    else
+    {
+        sSelectedPaletteIndices |= (0x10000 << gSprites[gTasks[taskId].data[5 + currPokeId]].oam.paletteNum);
+        if (gTasks[taskId].data[1] < PARTY_SIZE - 1 && currMon[1].species != SPECIES_NONE) // there is another pokemon to display
+        {
+            gTasks[taskId].data[1]++;
+            BeginNormalPaletteFade(sSelectedPaletteIndices, 0, 12, 12, HALL_OF_FAME_BG_PAL);
+            gSprites[gTasks[taskId].data[5 + currPokeId]].oam.priority = 1;
+            gTasks[taskId].func = Task_Hof_DisplayMon;
+        }
+        else
+        {
+            gTasks[taskId].func = Task_Hof_PaletteFadeAndPrintWelcomeText;
+        }
+    }
+}
+
+static void Task_Hof_PaletteFadeAndPrintWelcomeText(u8 taskId)
+{
+    u16 i;
+
+    BeginNormalPaletteFade(0xFFFF0000, 0, 0, 0, RGB_BLACK);
+    for (i = 0; i < PARTY_SIZE; i++)
+    {
+        if (gTasks[taskId].data[5 + i] != 0xFF)
+            gSprites[gTasks[taskId].data[5 + i]].oam.priority = 0;
+    }
+
+    HallOfFame_PrintWelcomeText(0, 15);
+    PlaySE(SE_DENDOU);
+    gTasks[taskId].data[3] = 400;
+    gTasks[taskId].func = Task_Hof_ApplauseAndConfetti;
+}
+
+static void Task_Hof_ApplauseAndConfetti(u8 taskId)
+{
+    if (gTasks[taskId].data[3] != 0)
+    {
+        gTasks[taskId].data[3]--;
+        if ((gTasks[taskId].data[3] & 3) == 0 && gTasks[taskId].data[3] > 110)
+            Hof_SpawnConfetti();
+    }
+    else
+    {
+        u16 i;
+        for (i = 0; i < PARTY_SIZE; i++)
+        {
+            if (gTasks[taskId].data[5 + i] != 0xFF)
+                gSprites[gTasks[taskId].data[5 + i]].oam.priority = 1;
+        }
+        BeginNormalPaletteFade(sSelectedPaletteIndices, 0, 12, 12, HALL_OF_FAME_BG_PAL);
+        FillWindowPixelBuffer(0, PIXEL_FILL(0));
+        CopyWindowToVram(0, 3);
+        gTasks[taskId].data[3] = 7;
+        gTasks[taskId].func = Task_Hof_WaitBorderFadeAway;
+    }
+}
+
+static void Task_Hof_WaitBorderFadeAway(u8 taskId)
+{
+    if (gTasks[taskId].data[3] > 15)
+    {
+        gTasks[taskId].func = Task_Hof_SpawnPlayerPic;
+    }
+    else
+    {
+        gTasks[taskId].data[3]++;
+        SetGpuReg(REG_OFFSET_BLDALPHA, 256 * gTasks[taskId].data[3]);
+    }
+}
+
+static void Task_Hof_SpawnPlayerPic(u8 taskId)
+{
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
+    ShowBg(0);
+    ShowBg(1);
+    ShowBg(3);
+    gTasks[taskId].data[4] = CreateTrainerPicSprite(PlayerGenderToFrontTrainerPicId_Debug(gSaveBlock2Ptr->playerGender, TRUE), TRUE, 0x78, 0x48, 6, 0xFFFF);
+    AddWindow(&sWindowTemplate);
+    TextWindow_SetStdFrame0_WithPal(1, 0x21D, 0xD0);
+    gTasks[taskId].data[3] = 120;
+    gTasks[taskId].func = Task_Hof_WaitAndPrintPlayerInfo;
+}
+
+static void Task_Hof_WaitAndPrintPlayerInfo(u8 taskId)
+{
+    if (gTasks[taskId].data[3] != 0)
+    {
+        gTasks[taskId].data[3]--;
+    }
+    else if (gSprites[gTasks[taskId].data[4]].pos1.x != 192)
+    {
+        gSprites[gTasks[taskId].data[4]].pos1.x++;
+    }
+    else
+    {
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
+        HallOfFame_PrintPlayerInfo(1, 2);
+        DrawDialogueFrame(0, 0);
+        AddTextPrinterParameterized2(0, 2, gText_LeagueChamp, 0, NULL, 2, 1, 3);
+        CopyWindowToVram(0, 3);
+        gTasks[taskId].func = Task_Hof_ExitOnKeyPressed;
+    }
+}
+
+static void Task_Hof_ExitOnKeyPressed(u8 taskId)
+{
+    if (JOY_NEW(A_BUTTON))
+    {
+        FadeOutBGM(4);
+        gTasks[taskId].func = Task_Hof_HandlePaletteOnExit;
+    }
+}
+
+static void Task_Hof_HandlePaletteOnExit(u8 taskId)
+{
+    CpuCopy16(gPlttBufferFaded, gPlttBufferUnfaded, PLTT_BUFFER_SIZE * sizeof(u16));
+    BeginNormalPaletteFade(0xFFFFFFFF, 8, 0, 16, RGB_BLACK);
+    gTasks[taskId].func = Task_Hof_HandleExit;
+}
+
+static void Task_Hof_HandleExit(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        s32 i;
+
+        for (i = 0; i < PARTY_SIZE; i++)
+        {
+            u8 spriteId = gTasks[taskId].data[5 + i];
+            if (spriteId != 0xFF)
+            {
+                FreeAndDestroyMonPicSprite(spriteId);
+            }
+        }
+
+        FreeAndDestroyTrainerPicSprite(gTasks[taskId].data[4]);
+        HideBg(0);
+        HideBg(1);
+        HideBg(3);
+        FreeAllWindowBuffers();
+        UnsetBgTilemapBuffer(1);
+        UnsetBgTilemapBuffer(3);
+        ResetBgsAndClearDma3BusyFlags(0);
+        DestroyTask(taskId);
+
+        if (sHofGfxPtr != NULL)
+        FREE_AND_SET_NULL(sHofGfxPtr);
+        if (sHofMonPtr != NULL)
+        FREE_AND_SET_NULL(sHofMonPtr);
+
+        SetWarpsToRollCredits();
+    }
+}
+
+static void SetWarpsToRollCredits(void)
+{
+    VarSet(VAR_MAP_SCENE_INDIGO_PLATEAU_EXTERIOR, 1);
+    FlagSet(FLAG_SPECIAL_FLAG_0x4000);
+    gDisableMapMusicChangeOnMapLoad = 2;
+    SetWarpDestination(MAP_GROUP(INDIGO_PLATEAU_EXTERIOR), MAP_NUM(INDIGO_PLATEAU_EXTERIOR), -1, 11, 6);
+    DoWarp();
+    ResetInitialPlayerAvatarState();
+}
+
+void CB2_InitHofPC(void)
+{
+    switch (gMain.state)
+    {
+    default:
+    case 0:
+        SetVBlankCallback(NULL);
+        ClearVramOamPltt_LoadHofPal();
+        sHofGfxPtr = AllocZeroed(sizeof(struct HofGfx));
+        gMain.state = 1;
+        break;
+    case 1:
+        HofInit_ResetGpuBuffersAndLoadConfettiGfx();
+        gMain.state++;
+        break;
+    case 2:
+        SetGpuReg(REG_OFFSET_BLDCNT, 0);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        Hof_InitBgs();
+        gMain.state++;
+        break;
+    case 3:
+        if (!DrawHofBackground())
+        {
+            sub_80A0A48(0, 0, 0);
+            SetVBlankCallback(VBlankCB_HofIdle);
+            gMain.state++;
+        }
+        break;
+    case 4:
+        RunTasks();
+        AnimateSprites();
+        BuildOamBuffer();
+        UpdatePaletteFade();
+        if (!sub_80A0A98())
+            gMain.state++;
+        break;
+    case 5:
+        SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL);
+        SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 7));
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        CreateTask(Task_HofPC_CopySaveData, 0);
+        sHofMonPtr = AllocZeroed(0x2000);
+        SetMainCallback2(CB2_HofIdle);
+        break;
+    }
+}
+
+static void Task_HofPC_CopySaveData(u8 taskId)
+{
+    u16 i;
+    struct HallofFameTeam* savedTeams;
+
+    CreateTopBarWindowLoadPalette(0, 30, 0, 0x0C, 0x226);
+    if (Save_LoadGameData(SAVE_HALL_OF_FAME) != SAVE_STATUS_OK)
+    {
+        gTasks[taskId].func = Task_HofPC_PrintDataIsCorrupted;
+    }
+    else
+    {
+        CpuCopy16(gDecompressionBuffer, sHofMonPtr, 0x2000);
+        savedTeams = sHofMonPtr;
+        for (i = 0; i < HALL_OF_FAME_MAX_TEAMS; i++, savedTeams++)
+        {
+            if (savedTeams->mon[0].species == SPECIES_NONE)
+                break;
+        }
+
+        if (i < HALL_OF_FAME_MAX_TEAMS)
+            gTasks[taskId].data[0] = i - 1;
+        else
+            gTasks[taskId].data[0] = HALL_OF_FAME_MAX_TEAMS - 1;
+
+        gTasks[taskId].data[1] = GetGameStat(GAME_STAT_ENTERED_HOF);
+
+        gTasks[taskId].func = Task_HofPC_DrawSpritesPrintText;
+    }
+}
+
+static void Task_HofPC_DrawSpritesPrintText(u8 taskId)
+{
+    struct HallofFameTeam *savedTeams = sHofMonPtr;
+    struct HallofFameMon *currMon;
+    u16 i;
+
+    for (i = 0; i < gTasks[taskId].data[0]; i++)
+        savedTeams++;
+
+    currMon = &savedTeams->mon[0];
+    sSelectedPaletteIndices = 0;
+    gTasks[taskId].data[2] = 0;
+    gTasks[taskId].data[4] = 0;
+
+    for (i = 0; i < PARTY_SIZE; i++, currMon++)
+    {
+        if (currMon->species != SPECIES_NONE)
+            gTasks[taskId].data[4]++;
+    }
+
+    currMon = &savedTeams->mon[0];
+
+    for (i = 0; i < PARTY_SIZE; i++, currMon++)
+    {
+        if (currMon->species != SPECIES_NONE)
+        {
+            u16 spriteId;
+            s16 posX, posY;
+
+            if (gTasks[taskId].data[4] > 3)
+            {
+                posX = sHallOfFame_MonFullTeamPositions[i][2];
+                posY = sHallOfFame_MonFullTeamPositions[i][3];
+            }
+            else
+            {
+                posX = sHallOfFame_MonHalfTeamPositions[i][2];
+                posY = sHallOfFame_MonHalfTeamPositions[i][3];
+            }
+
+            spriteId = CreateMonPicSprite_HandleDeoxys(currMon->species, currMon->tid, currMon->personality, TRUE, posX,
+                                                       posY, i, 0xFFFF);
+            gSprites[spriteId].oam.priority = 1;
+            gTasks[taskId].data[5 + i] = spriteId;
+        }
+        else
+        {
+            gTasks[taskId].data[5 + i] = 0xFF;
+        }
+    }
+
+    BlendPalettes(0xFFFF0000, 0xC, HALL_OF_FAME_BG_PAL);
+
+    ConvertIntToDecimalStringN(gStringVar1, gTasks[taskId].data[1], STR_CONV_MODE_LEFT_ALIGN, 3);
+    StringExpandPlaceholders(gStringVar4, gText_HOFNumber);
+
+    if (gTasks[taskId].data[0] <= 0)
+        TopBarWindowPrintTwoStrings(gStringVar4, gText_UPDOWNPick_ABUTTONBBUTTONCancel, 0, 0, TRUE);
+    else
+        TopBarWindowPrintTwoStrings(gStringVar4, gText_UPDOWNPick_ABUTTONNext_BBUTTONBack, 0, 0, TRUE);
+
+    gTasks[taskId].func = Task_HofPC_PrintMonInfo;
+}
+
+static void Task_HofPC_PrintMonInfo(u8 taskId)
+{
+    struct HallofFameTeam* savedTeams = sHofMonPtr;
+    struct HallofFameMon* currMon;
+    u16 i;
+    u16 currMonId;
+
+    for (i = 0; i < gTasks[taskId].data[0]; i++)
+        savedTeams++;
+
+    for (i = 0; i < PARTY_SIZE; i++)
+    {
+        u16 spriteId = gTasks[taskId].data[5 + i];
+        if (spriteId != 0xFF)
+            gSprites[spriteId].oam.priority = 1;
+    }
+
+    currMonId = gTasks[taskId].data[5 + gTasks[taskId].data[2]];
+    gSprites[currMonId].oam.priority = 0;
+    sSelectedPaletteIndices = (0x10000 << gSprites[currMonId].oam.paletteNum) ^ 0xFFFF0000;
+    BlendPalettesUnfaded(sSelectedPaletteIndices, 0xC, HALL_OF_FAME_BG_PAL);
+
+    currMon = &savedTeams->mon[gTasks[taskId].data[2]];
+    if (currMon->species != SPECIES_EGG)
+    {
+        StopCryAndClearCrySongs();
+        PlayCry1(currMon->species, 0);
+    }
+    HallOfFame_PrintMonInfo(currMon, 0, 14);
+
+    gTasks[taskId].func = Task_HofPC_HandleInput;
+}
+
+static void Task_HofPC_HandleInput(u8 taskId)
+{
+    u16 i;
+
+    if (JOY_NEW(A_BUTTON))
+    {
+        if (gTasks[taskId].data[0] != 0) // prepare another team to view
+        {
+            gTasks[taskId].data[0]--;
+            for (i = 0; i < 6; i++)
+            {
+                u8 spriteId = gTasks[taskId].data[5 + i];
+                if (spriteId != 0xFF)
+                {
+                    FreeAndDestroyMonPicSprite(spriteId);
+                }
+            }
+            if (gTasks[taskId].data[1] != 0)
+                gTasks[taskId].data[1]--;
+            gTasks[taskId].func = Task_HofPC_DrawSpritesPrintText;
+        }
+        else // no more teams to view, turn off hall of fame PC
+        {
+            if (IsCryPlayingOrClearCrySongs())
+            {
+                StopCryAndClearCrySongs();
+                m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0x100);
+            }
+            gTasks[taskId].func = Task_HofPC_HandlePaletteOnExit;
+        }
+    }
+    else if (JOY_NEW(B_BUTTON)) // turn off hall of fame PC
+    {
+        if (IsCryPlayingOrClearCrySongs())
+        {
+            StopCryAndClearCrySongs();
+            m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0x100);
+        }
+        gTasks[taskId].func = Task_HofPC_HandlePaletteOnExit;
+    }
+    else if (JOY_NEW(DPAD_UP) && gTasks[taskId].data[2] != 0) // change mon -1
+    {
+        gTasks[taskId].data[2]--;
+        gTasks[taskId].func = Task_HofPC_PrintMonInfo;
+    }
+    else if (JOY_NEW(DPAD_DOWN) && gTasks[taskId].data[2] < gTasks[taskId].data[4] - 1) // change mon +1
+    {
+        gTasks[taskId].data[2]++;
+        gTasks[taskId].func = Task_HofPC_PrintMonInfo;
+    }
+}
+static void Task_HofPC_HandlePaletteOnExit(u8 taskId)
+{
+    struct HallofFameTeam* fameTeam;
+
+    CpuCopy16(gPlttBufferFaded, gPlttBufferUnfaded, 0x400);
+    sub_80A0A70(0, 0, 0);
+    gTasks[taskId].func = Task_HofPC_HandleExit;
+}
+
+static void Task_HofPC_HandleExit(u8 taskId)
+{
+    if (!sub_80A0AAC())
+    {
+        HideBg(0);
+        HideBg(1);
+        HideBg(3);
+        DestroyTopBarWindow();
+        FreeAllWindowBuffers();
+        UnsetBgTilemapBuffer(1);
+        UnsetBgTilemapBuffer(3);
+        ResetBgsAndClearDma3BusyFlags(FALSE);
+        DestroyTask(taskId);
+
+        if (sHofGfxPtr != NULL)
+            FREE_AND_SET_NULL(sHofGfxPtr);
+        if (sHofMonPtr != NULL)
+            FREE_AND_SET_NULL(sHofMonPtr);
+
+        ReturnFromHallOfFamePC();
+    }
+}
+
+static void Task_HofPC_PrintDataIsCorrupted(u8 taskId)
+{
+    TopBarWindowPrintString(gText_ABUTTONExit, 8, TRUE);
+    DrawDialogueFrame(0, 0);
+    AddTextPrinterParameterized2(0, 2, gText_HOFCorrupted, 0, NULL, 2, 1, 3);
+    CopyWindowToVram(0, 3);
+    gTasks[taskId].func = Task_HofPC_ExitOnButtonPress;
+}
+
+static void Task_HofPC_ExitOnButtonPress(u8 taskId)
+{
+    if (JOY_NEW(A_BUTTON))
+        gTasks[taskId].func = Task_HofPC_HandlePaletteOnExit;
+}
+
+static void HallOfFame_PrintWelcomeText(u8 not, u8 used)
+{
+    u8 x = (0xD0 - GetStringWidth(2, gText_WelcomeToHOF, 0)) / 2;
+    FillWindowPixelBuffer(0, PIXEL_FILL(0));
+    PutWindowTilemap(0);
+    AddTextPrinterParameterized3(0, 2, x, 1, sTextColors[0], 0, gText_WelcomeToHOF);
+    CopyWindowToVram(0, 3);
+}
+
+static void HallOfFame_PrintMonInfo(struct HallofFameMon* currMon, u8 unused1, u8 unused2)
+{
+    u8 text[16];
+    u8 text2[24];
+    u16 i;
+    u8 *stringPtr;
+    u16 dexNumber;
+    u8 gender;
+    s32 width;
+    s32 x;
+
+    FillWindowPixelBuffer(0, PIXEL_FILL(0));
+    PutWindowTilemap(0);
+
+    // dex number
+    if (currMon->species != SPECIES_EGG)
+    {
+        StringCopy(text2, gText_Number);
+        dexNumber = SpeciesToPokedexNum(currMon->species);
+        if (dexNumber != 0xFFFF)
+        {
+            text[0] = (dexNumber / 100) + CHAR_0;
+            text[1] = ((dexNumber %= 100) / 10) + CHAR_0;
+            text[2] = (dexNumber % 10) + CHAR_0;
+        }
+        else
+        {
+            text[0] = text[1] = text[2] = CHAR_QUESTION_MARK;
+        }
+        text[3] = EOS;
+        StringAppend(text2, text);
+        AddTextPrinterParameterized3(0, 2, 0x10, 1, sTextColors[0], 0, text2);
+    }
+
+    // nick, species names, gender and lvl
+    i = 0;
+    if (currMon->nick[0] != EOS)
+    {
+        for (i = 0; i < 10 && currMon->nick[i] != EOS; i++)
+        {
+            text[i] = currMon->nick[i];
+        }
+    }
+    text[i] = EOS;
+    width = GetStringWidth(2, text, GetFontAttribute(2, FONTATTR_LETTER_SPACING));
+    if (currMon->species == SPECIES_EGG)
+        x = 0x80 - width / 2;
+    else
+        x = 0x80 - width;
+    AddTextPrinterParameterized3(0, 2, x, 1, sTextColors[0], 0, text);
+    if (currMon->species != SPECIES_EGG)
+    {
+        text[0] = CHAR_SLASH;
+        stringPtr = StringCopy(text + 1, gSpeciesNames[currMon->species]);
+
+        if (currMon->species == SPECIES_NIDORAN_M || currMon->species == SPECIES_NIDORAN_F)
+            gender = MON_GENDERLESS;
+        else
+            gender = GetGenderFromSpeciesAndPersonality(currMon->species, currMon->personality);
+        switch (gender)
+        {
+        case MON_MALE:
+            *stringPtr++ = CHAR_MALE;
+            break;
+        case MON_FEMALE:
+            *stringPtr++ = CHAR_FEMALE;
+            break;
+        default:
+            *stringPtr++ = CHAR_SPACE;
+            break;
+        }
+        *stringPtr = EOS;
+
+        AddTextPrinterParameterized3(0, 2, 0x80, 1, sTextColors[0], 0, text);
+
+        stringPtr = StringCopy(text, gText_Level);
+        ConvertIntToDecimalStringN(stringPtr, currMon->lvl, STR_CONV_MODE_LEFT_ALIGN, 3);
+        AddTextPrinterParameterized3(0, 2, 0x20, 0x11, sTextColors[0], 0, text);
+
+        stringPtr = StringCopy(text, gText_IDNumber);
+        ConvertIntToDecimalStringN(stringPtr, (u16)(currMon->tid), STR_CONV_MODE_LEADING_ZEROS, 5);
+        AddTextPrinterParameterized3(0, 2, 0x60, 0x11, sTextColors[0], 0, text);
+
+    }
+    CopyWindowToVram(0, 3);
+}
+
+static void HallOfFame_PrintPlayerInfo(u8 unused1, u8 unused2)
+{
+    u8 text[20];
+    u16 trainerId;
+    s32 textWidth = sWindowTemplate.width * 8 - 6;
+    
+    FillWindowPixelBuffer(1, PIXEL_FILL(1));
+    PutWindowTilemap(1);
+    DrawStdFrameWithCustomTileAndPalette(1, FALSE, 0x21D, 0xD);
+    AddTextPrinterParameterized4(1, 2, 4, 3, 0, 0, sTextColors[1], 0, gText_Name);
+
+    AddTextPrinterParameterized3(1, 2, textWidth - GetStringWidth(2, gSaveBlock2Ptr->playerName, 0), 3, sTextColors[1], 0, gSaveBlock2Ptr->playerName);
+
+    trainerId = (gSaveBlock2Ptr->playerTrainerId[0]) | (gSaveBlock2Ptr->playerTrainerId[1] << 8);
+    AddTextPrinterParameterized3(1, 2, 4, 18, sTextColors[1], 0, gText_IDNumber);
+    text[0] = (trainerId % 100000) / 10000 + CHAR_0;
+    text[1] = (trainerId % 10000) / 1000 + CHAR_0;
+    text[2] = (trainerId % 1000) / 100 + CHAR_0;
+    text[3] = (trainerId % 100) / 10 + CHAR_0;
+    text[4] = (trainerId % 10) / 1 + CHAR_0;
+    text[5] = EOS;
+    AddTextPrinterParameterized3(1, 2, textWidth - 30, 18, sTextColors[1], 0, text);
+
+    AddTextPrinterParameterized3(1, 2, 4, 32, sTextColors[1], 0, gText_MainMenuTime);
+    text[0] = (gSaveBlock2Ptr->playTimeHours / 100) + CHAR_0;
+    text[1] = (gSaveBlock2Ptr->playTimeHours % 100) / 10 + CHAR_0;
+    text[2] = (gSaveBlock2Ptr->playTimeHours % 10) + CHAR_0;
+
+    if (text[0] == CHAR_0)
+        text[0] = CHAR_SPACE;
+    if (text[0] == CHAR_SPACE && text[1] == CHAR_0)
+        text[1] = CHAR_SPACE;
+
+    text[3] = CHAR_COLON;
+    text[4] = (gSaveBlock2Ptr->playTimeMinutes % 100) / 10 + CHAR_0;
+    text[5] = (gSaveBlock2Ptr->playTimeMinutes % 10) + CHAR_0;
+    text[6] = EOS;
+
+    AddTextPrinterParameterized3(1, 2, textWidth - 36, 32, sTextColors[1], 0, text);
+
+    CopyWindowToVram(1, 3);
+}
+
+static void ClearVramOamPltt_LoadHofPal(void)
+{
+    u32 vramOffset, oamOffset, plttOffset;
+    u32 vramSize, oamSize, plttSize;
+
+    vramOffset = (VRAM);
+    vramSize = VRAM_SIZE;
+    while (TRUE)
+    {
+        DmaFill16(3, 0, vramOffset, 0x1000);
+        vramOffset += 0x1000;
+        vramSize -= 0x1000;
+        if (vramSize <= 0x1000)
+        {
+            DmaFill16(3, 0, vramOffset, vramSize);
+            break;
+        }
+    }
+
+    oamOffset = OAM;
+    oamSize = OAM_SIZE;
+    DmaFill32(3, 0, oamOffset, oamSize);
+
+    plttOffset = PLTT;
+    plttSize = PLTT_SIZE;
+    DmaFill16(3, 0, plttOffset, plttSize);
+
+    ResetPaletteFade();
+    LoadPalette(sHallOfFame_Pal, 0, 0x20);
+}
+
+static void HofInit_ResetGpuBuffersAndLoadConfettiGfx(void)
+{
+    ScanlineEffect_Stop();
+    ResetTasks();
+    ResetSpriteData();
+    ResetTempTileDataBuffers();
+    ResetAllPicSprites();
+    FreeAllSpritePalettes();
+    gReservedSpritePaletteCount = 8;
+    LoadCompressedSpriteSheet(sHallOfFame_ConfettiSpriteSheet);
+    LoadCompressedSpritePalette(sHallOfFame_ConfettiSpritePalette);
+}
+
+static void Hof_InitBgs(void)
+{
+    ResetBgsAndClearDma3BusyFlags(0);
+    InitBgsFromTemplates(0, sHof_BgTemplates, NELEMS(sHof_BgTemplates));
+    SetBgTilemapBuffer(1, sHofGfxPtr->tilemap1);
+    SetBgTilemapBuffer(3, sHofGfxPtr->tilemap2);
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+}
+
+static bool8 DrawHofBackground(void)
+{
+    switch (sHofGfxPtr->state)
+    {
+    case 0:
+        DecompressAndCopyTileDataToVram(1, sHallOfFame_Gfx, 0, 0, 0);
+        break;
+    case 1:
+        if (FreeTempTileDataBuffersIfPossible())
+            return TRUE;
+        break;
+    case 2:
+        FillBgTilemapBufferRect_Palette0(1, 1, 0, 0, 0x20, 2);
+        FillBgTilemapBufferRect_Palette0(1, 0, 0, 3, 0x20, 0xB);
+        FillBgTilemapBufferRect_Palette0(1, 1, 0, 0xE, 0x20, 6);
+        FillBgTilemapBufferRect_Palette0(3, 2, 0, 0, 0x20, 0x20);
+
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(3);
+        break;
+    case 3:
+        InitStandardTextBoxWindows();
+        ResetBg0();
+        break;
+    case 4:
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
+        ShowBg(0);
+        ShowBg(1);
+        ShowBg(3);
+        sHofGfxPtr->state = 0;
+        return FALSE;
+    }
+
+    sHofGfxPtr->state++;
+    return TRUE;
+}
+
+static void SpriteCB_EndGetOnScreen(struct Sprite * sprite)
+{
+
+}
+
+static void SpriteCB_GetOnScreen(struct Sprite * sprite)
+{
+    if (sprite->pos1.x != sprite->data[1]
+        || sprite->pos1.y != sprite->data[2])
+    {
+        if (sprite->pos1.x < sprite->data[1])
+            sprite->pos1.x += 15;
+        if (sprite->pos1.x > sprite->data[1])
+            sprite->pos1.x -= 15;
+
+        if (sprite->pos1.y < sprite->data[2])
+            sprite->pos1.y += 10;
+        if (sprite->pos1.y > sprite->data[2])
+            sprite->pos1.y -= 10;
+    }
+    else
+    {
+        sprite->data[0] = 1;
+        sprite->callback = SpriteCB_EndGetOnScreen;
+    }
+}
+
+static void SpriteCB_Confetti(struct Sprite* sprite)
+{
+    if (sprite->pos2.y > 120)
+    {
+        DestroySprite(sprite);
+    }
+    else
+    {
+        u16 rand;
+        u8 tableID;
+
+        sprite->pos2.y++;
+        sprite->pos2.y += sprite->data[1];
+
+        tableID = sprite->data[0];
+        rand = (Random() % 4) + 8;
+        sprite->pos2.x = rand * gSineTable[tableID] / 256;
+
+        sprite->data[0] += 4;
+    }
+}
+
+static bool8 Hof_SpawnConfetti(void)
+{
+    u8 spriteId;
+    struct Sprite* sprite;
+
+    s16 posX = Random() % 240;
+    s16 posY = -(Random() % 8);
+
+    spriteId = CreateSprite(&sSpriteTemplate_Confetti, posX, posY, 0);
+    sprite = &gSprites[spriteId];
+
+    StartSpriteAnim(sprite, Random() % 17);
+
+    if (Random() & 3)
+        sprite->data[1] = 0;
+    else
+        sprite->data[1] = 1;
+
+    return FALSE;
+}
diff --git a/src/hof_pc.c b/src/hof_pc.c
index 241fbc4f3..76fd06abf 100644
--- a/src/hof_pc.c
+++ b/src/hof_pc.c
@@ -19,7 +19,7 @@ static void Task_WaitFadeAndSetCallback(u8 taskId)
         FreeAllWindowBuffers();
         ResetBgsAndClearDma3BusyFlags(0);
         DestroyTask(taskId);
-        SetMainCallback2(sub_80F2978);
+        SetMainCallback2(CB2_InitHofPC);
     }
 }
 
diff --git a/src/intro.c b/src/intro.c
index e2432b6a2..33a03a389 100644
--- a/src/intro.c
+++ b/src/intro.c
@@ -574,7 +574,7 @@ void c2_copyright_1(void)
     {
         ResetMenuAndMonGlobals();
         Save_ResetSaveCounters();
-        Save_LoadGameData(0);
+        Save_LoadGameData(SAVE_NORMAL);
         if (gSaveFileStatus == SAVE_STATUS_EMPTY || gSaveFileStatus == SAVE_STATUS_INVALID)
             Sav2_ClearSetDefault();
         SetPokemonCryStereo(gSaveBlock2Ptr->optionsSound);
diff --git a/src/link.c b/src/link.c
index ac9cf9cfe..dfbc9fcb2 100644
--- a/src/link.c
+++ b/src/link.c
@@ -464,7 +464,7 @@ void LinkTestProcessKeyInput(void)
     }
     if (JOY_NEW(R_BUTTON))
     {
-        TrySavingData(1);
+        TrySavingData(SAVE_LINK);
     }
     if (JOY_NEW(SELECT_BUTTON))
     {
@@ -1581,7 +1581,7 @@ static void CB2_PrintErrorMessage(void)
                 PlaySE(SE_PIN);
                 gWirelessCommType = 0;
                 sLinkErrorBuffer.unk_06 = 0;
-                sub_8079B7C();
+                ResetSaveHeap();
             }
         }
         else if (gWirelessCommType == 2)
diff --git a/src/mevent.c b/src/mevent.c
index 00bffdfc3..846ccbaa8 100644
--- a/src/mevent.c
+++ b/src/mevent.c
@@ -39,12 +39,12 @@ struct MEventTaskData1
 };
 
 void sub_8143910(u8 taskId);
-bool32 sub_8143E64(const struct MEventBuffer_3120_Sub * src);
+bool32 sub_8143E64(const struct MEWonderNewsData * src);
 void sub_8143E9C(void);
 void sub_8143ED0(void);
-bool32 sub_8144018(const struct MEventBuffer_32E0_Sub * src);
-void sub_814407C(void);
-void sub_81440B4(void);
+bool32 sub_8144018(const struct MEWonderCardData * src);
+void BlankSavedWonderCard(void);
+void BlankMEventBuffer2(void);
 void sub_8144824(u32, u32, u32 *, s32);
 void sub_8144790(void);
 
@@ -485,34 +485,34 @@ void sub_8143910(u8 taskId)
 
 void sub_8143D24(void)
 {
-    CpuFill32(0, &gSaveBlock1Ptr->unk_3120, sizeof(gSaveBlock1Ptr->unk_3120));
+    CpuFill32(0, &gSaveBlock1Ptr->mysteryEventBuffers, sizeof(gSaveBlock1Ptr->mysteryEventBuffers));
     sub_8143ED0();
-    ResetSomeMEventECBuffer_3120_338();
+    EC_ResetMEventProfileMaybe();
 }
 
-struct MEventBuffer_3120_Sub * GetSavedWonderNews(void)
+struct MEWonderNewsData * GetSavedWonderNews(void)
 {
-    return &gSaveBlock1Ptr->unk_3120.buffer_000.data;
+    return &gSaveBlock1Ptr->mysteryEventBuffers.menews.data;
 }
 
-struct MEventBuffer_32E0_Sub * GetSavedWonderCard(void)
+struct MEWonderCardData * GetSavedWonderCard(void)
 {
-    return &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+    return &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
 }
 
 struct MEventBuffer_3430_Sub * sav1_get_mevent_buffer_2(void)
 {
-    return &gSaveBlock1Ptr->unk_3120.buffer_310.data;
+    return &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
 }
 
 struct MENewsJisanStruct * GetMENewsJisanStructPtr(void)
 {
-    return &gSaveBlock1Ptr->unk_3120.unk_340;
+    return &gSaveBlock1Ptr->mysteryEventBuffers.me_jisan;
 }
 
-u16 * sub_8143DA8(void)
+u16 * GetMEventProfileECWordsMaybe(void)
 {
-    return gSaveBlock1Ptr->unk_3120.unk_338;
+    return gSaveBlock1Ptr->mysteryEventBuffers.ec_profile_maybe;
 }
 
 void DestroyWonderNews(void)
@@ -520,26 +520,26 @@ void DestroyWonderNews(void)
     sub_8143E9C();
 }
 
-bool32 sub_8143DC8(const struct MEventBuffer_3120_Sub * src)
+bool32 sub_8143DC8(const struct MEWonderNewsData * src)
 {
     if (!sub_8143E64(src))
         return FALSE;
     sub_8143E9C();
-    gSaveBlock1Ptr->unk_3120.buffer_000.data = *src;
-    gSaveBlock1Ptr->unk_3120.buffer_000.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->unk_3120.buffer_000.data, sizeof(struct MEventBuffer_3120_Sub));
+    gSaveBlock1Ptr->mysteryEventBuffers.menews.data = *src;
+    gSaveBlock1Ptr->mysteryEventBuffers.menews.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data, sizeof(struct MEWonderNewsData));
     return TRUE;
 }
 
 bool32 ValidateReceivedWonderNews(void)
 {
-    if (CalcCRC16WithTable((void *)&gSaveBlock1Ptr->unk_3120.buffer_000.data, sizeof(struct MEventBuffer_3120_Sub)) != gSaveBlock1Ptr->unk_3120.buffer_000.crc)
+    if (CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data, sizeof(struct MEWonderNewsData)) != gSaveBlock1Ptr->mysteryEventBuffers.menews.crc)
         return FALSE;
-    if (!sub_8143E64(&gSaveBlock1Ptr->unk_3120.buffer_000.data))
+    if (!sub_8143E64(&gSaveBlock1Ptr->mysteryEventBuffers.menews.data))
         return FALSE;
     return TRUE;
 }
 
-bool32 sub_8143E64(const struct MEventBuffer_3120_Sub * data)
+bool32 sub_8143E64(const struct MEWonderNewsData * data)
 {
     if (data->unk_00 == 0)
         return FALSE;
@@ -548,7 +548,7 @@ bool32 sub_8143E64(const struct MEventBuffer_3120_Sub * data)
 
 bool32 WonderNews_Test_Unk_02(void)
 {
-    const struct MEventBuffer_3120_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_000.data;
+    const struct MEWonderNewsData * data = &gSaveBlock1Ptr->mysteryEventBuffers.menews.data;
     if (data->unk_02 == 0)
         return FALSE;
     return TRUE;
@@ -556,8 +556,8 @@ bool32 WonderNews_Test_Unk_02(void)
 
 void sub_8143E9C(void)
 {
-    CpuFill32(0, GetSavedWonderNews(), sizeof(gSaveBlock1Ptr->unk_3120.buffer_000.data));
-    gSaveBlock1Ptr->unk_3120.buffer_000.crc = 0;
+    CpuFill32(0, GetSavedWonderNews(), sizeof(gSaveBlock1Ptr->mysteryEventBuffers.menews.data));
+    gSaveBlock1Ptr->mysteryEventBuffers.menews.crc = 0;
 }
 
 void sub_8143ED0(void)
@@ -568,11 +568,11 @@ void sub_8143ED0(void)
 
 bool32 sub_8143EF4(const u8 * src)
 {
-    const u8 * r5 = (const u8 *)&gSaveBlock1Ptr->unk_3120.buffer_000.data;
+    const u8 * r5 = (const u8 *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data;
     u32 i;
     if (!ValidateReceivedWonderNews())
         return FALSE;
-    for (i = 0; i < sizeof(struct MEventBuffer_3120_Sub); i++)
+    for (i = 0; i < sizeof(struct MEWonderNewsData); i++)
     {
         if (r5[i] != src[i])
             return FALSE;
@@ -582,8 +582,8 @@ bool32 sub_8143EF4(const u8 * src)
 
 void DestroyWonderCard(void)
 {
-    sub_814407C();
-    sub_81440B4();
+    BlankSavedWonderCard();
+    BlankMEventBuffer2();
     sub_8144790();
     ClearRamScript();
     sub_806E2D0();
@@ -591,33 +591,33 @@ void DestroyWonderCard(void)
     sub_80E7524(&gSaveBlock2Ptr->unk_B0.field_3F0);
 }
 
-bool32 sub_8143F68(const struct MEventBuffer_32E0_Sub * data)
+bool32 sub_8143F68(const struct MEWonderCardData * data)
 {
     struct MEventBuffer_3430_Sub * r2;
-    struct MEventBuffer_32E0_Sub * r1;
+    struct MEWonderCardData * r1;
     if (!sub_8144018(data))
         return FALSE;
     DestroyWonderCard();
-    memcpy(&gSaveBlock1Ptr->unk_3120.buffer_1c0.data, data, sizeof(struct MEventBuffer_32E0_Sub));
-    gSaveBlock1Ptr->unk_3120.buffer_1c0.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->unk_3120.buffer_1c0.data, sizeof(struct MEventBuffer_32E0_Sub));
-    r2 = &gSaveBlock1Ptr->unk_3120.buffer_310.data;
-    r1 = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+    memcpy(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, data, sizeof(struct MEWonderCardData));
+    gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData));
+    r2 = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
+    r1 = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     r2->unk_06 = r1->unk_02;
     return TRUE;
 }
 
 bool32 ValidateReceivedWonderCard(void)
 {
-    if (gSaveBlock1Ptr->unk_3120.buffer_1c0.crc != CalcCRC16WithTable((void *)&gSaveBlock1Ptr->unk_3120.buffer_1c0.data, sizeof(struct MEventBuffer_32E0_Sub)))
+    if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc != CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData)))
         return FALSE;
-    if (!sub_8144018(&gSaveBlock1Ptr->unk_3120.buffer_1c0.data))
+    if (!sub_8144018(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data))
         return FALSE;
     if (!sub_8069DFC())
         return FALSE;
     return TRUE;
 }
 
-bool32 sub_8144018(const struct MEventBuffer_32E0_Sub * data)
+bool32 sub_8144018(const struct MEWonderCardData * data)
 {
     if (data->unk_00 == 0)
         return FALSE;
@@ -634,32 +634,32 @@ bool32 sub_8144018(const struct MEventBuffer_32E0_Sub * data)
 
 bool32 WonderCard_Test_Unk_08_6(void)
 {
-    const struct MEventBuffer_32E0_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+    const struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     if (data->unk_08_6 == 0)
         return FALSE;
     return TRUE;
 }
 
-void sub_814407C(void)
+void BlankSavedWonderCard(void)
 {
-    CpuFill32(0, &gSaveBlock1Ptr->unk_3120.buffer_1c0.data, sizeof(struct MEventBuffer_32E0_Sub));
-    gSaveBlock1Ptr->unk_3120.buffer_1c0.crc = 0;
+    CpuFill32(0, &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData));
+    gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc = 0;
 }
 
-void sub_81440B4(void)
+void BlankMEventBuffer2(void)
 {
     CpuFill32(0, sav1_get_mevent_buffer_2(), 18 * sizeof(u16));
-    gSaveBlock1Ptr->unk_3120.buffer_310.crc = 0;
+    gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.crc = 0;
 }
 
 u16 sub_81440E8(void)
 {
     if (ValidateReceivedWonderCard())
-        return gSaveBlock1Ptr->unk_3120.buffer_1c0.data.unk_00;
+        return gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.unk_00;
     return 0;
 }
 
-void sub_814410C(struct MEventBuffer_32E0_Sub * buffer)
+void sub_814410C(struct MEWonderCardData * buffer)
 {
     if (buffer->unk_08_6 == 1)
         buffer->unk_08_6 = 0;
@@ -707,11 +707,11 @@ bool32 sub_81441AC(const struct MEventBuffer_3430_Sub * data1, const u16 * data2
     return FALSE;
 }
 
-bool32 sub_81441F0(const u16 * data)
+static bool32 IsWonderCardSpeciesValid(const u16 * data)
 {
     if (data[1] == 0)
         return FALSE;
-    if (data[0] == 0)
+    if (data[0] == SPECIES_NONE)
         return FALSE;
     if (data[0] >= NUM_SPECIES)
         return FALSE;
@@ -720,64 +720,72 @@ bool32 sub_81441F0(const u16 * data)
 
 s32 sub_8144218(void)
 {
-    struct MEventBuffer_32E0_Sub * data;
+    struct MEWonderCardData * data;
     if (!ValidateReceivedWonderCard())
         return 0;
-    data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+    data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     if (data->unk_08_0 != 1)
         return 0;
-    return sub_8144184(&gSaveBlock1Ptr->unk_3120.buffer_310.data, data->unk_09);
+    return sub_8144184(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data->unk_09);
 }
 
 bool32 sub_8144254(const u16 * data)
 {
-    struct MEventBuffer_32E0_Sub * buffer = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+    struct MEWonderCardData * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     s32 size = buffer->unk_09;
     s32 i;
-    if (!sub_81441F0(data))
+    if (!IsWonderCardSpeciesValid(data))
         return FALSE;
-    if (sub_81441AC(&gSaveBlock1Ptr->unk_3120.buffer_310.data, data, size))
+    if (sub_81441AC(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data, size))
         return FALSE;
     for (i = 0; i < size; i++)
     {
-        if (gSaveBlock1Ptr->unk_3120.buffer_310.data.unk_08[1][i] == 0 && gSaveBlock1Ptr->unk_3120.buffer_310.data.unk_08[0][i] == 0)
+        if (gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[1][i] == 0 && gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[0][i] == 0)
         {
-            gSaveBlock1Ptr->unk_3120.buffer_310.data.unk_08[1][i] = data[1];
-            gSaveBlock1Ptr->unk_3120.buffer_310.data.unk_08[0][i] = data[0];
+            gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[1][i] = data[1];
+            gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[0][i] = data[0];
             return TRUE;
         }
     }
     return FALSE;
 }
 
-void sub_81442CC(struct MEventStruct_Unk1442CC * data)
+void BuildMEventClientHeader(struct MEventClientHeaderStruct * data)
 {
     s32 i;
-    CpuFill32(0, data, sizeof(struct MEventStruct_Unk1442CC));
+    CpuFill32(0, data, sizeof(struct MEventClientHeaderStruct));
+    // Magic
     data->unk_00 = 0x101;
     data->unk_04 = 1;
     data->unk_08 = 1;
     data->unk_0C = 1;
     data->unk_10 = 1;
+
+    // Check whether a card already exists
     if (ValidateReceivedWonderCard())
     {
-        data->unk_14 = GetSavedWonderCard()->unk_00;
+        // Populate fields
+        data->id = GetSavedWonderCard()->unk_00;
         data->unk_20 = *sav1_get_mevent_buffer_2();
         data->unk_44 = GetSavedWonderCard()->unk_09;
     }
     else
-        data->unk_14 = 0;
+        data->id = 0;
+
+    // Get something
     for (i = 0; i < 4; i++)
-        data->unk_16[i] = gSaveBlock1Ptr->unk_3120.unk_338[i];
-    CopyTrainerId(data->unk_4C, gSaveBlock2Ptr->playerTrainerId);
-    StringCopy(data->unk_45, gSaveBlock2Ptr->playerName);
+        data->unk_16[i] = gSaveBlock1Ptr->mysteryEventBuffers.ec_profile_maybe[i];
+
+    // Get player ID
+    CopyTrainerId(data->playerTrainerId, gSaveBlock2Ptr->playerTrainerId);
+    StringCopy(data->playerName, gSaveBlock2Ptr->playerName);
     for (i = 0; i < 6; i++)
-        data->unk_50[i] = gSaveBlock1Ptr->easyChatProfile[i];
-    memcpy(data->unk_5C, RomHeaderGameCode, 4);
-    data->unk_60 = RomHeaderSoftwareVersion;
+        data->easyChatProfile[i] = gSaveBlock1Ptr->easyChatProfile[i];
+    memcpy(data->gameCode, RomHeaderGameCode, 4);
+    data->version = RomHeaderSoftwareVersion;
 }
 
-bool32 sub_81443D4(const struct MEventStruct_Unk1442CC * data)
+bool32 ValidateMEventClientHeader(const struct MEventClientHeaderStruct * data)
 {
     if (data->unk_00 != 0x101)
         return FALSE;
@@ -792,16 +800,16 @@ bool32 sub_81443D4(const struct MEventStruct_Unk1442CC * data)
     return TRUE;
 }
 
-u32 sub_8144418(const u16 * a0, const struct MEventStruct_Unk1442CC * a1, void * unused)
+u32 sub_8144418(const u16 * a0, const struct MEventClientHeaderStruct * a1, void * unused)
 {
-    if (a1->unk_14 == 0)
+    if (a1->id == 0)
         return 0;
-    if (*a0 == a1->unk_14)
+    if (*a0 == a1->id)
         return 1;
     return 2;
 }
 
-u32 sub_8144434(const u16 * a0, const struct MEventStruct_Unk1442CC * a1, void * unused)
+u32 sub_8144434(const u16 * a0, const struct MEventClientHeaderStruct * a1, void * unused)
 {
     s32 r4 = a1->unk_44 - sub_8144184(&a1->unk_20, a1->unk_44);
     if (r4 == 0)
@@ -813,7 +821,7 @@ u32 sub_8144434(const u16 * a0, const struct MEventStruct_Unk1442CC * a1, void *
     return 2;
 }
 
-bool32 sub_8144474(const struct MEventStruct_Unk1442CC * a0, const u16 * a1)
+bool32 sub_8144474(const struct MEventClientHeaderStruct * a0, const u16 * a1)
 {
     s32 i;
     for (i = 0; i < 4; i++)
@@ -824,12 +832,12 @@ bool32 sub_8144474(const struct MEventStruct_Unk1442CC * a0, const u16 * a1)
     return TRUE;
 }
 
-s32 sub_814449C(const struct MEventStruct_Unk1442CC * a0)
+s32 sub_814449C(const struct MEventClientHeaderStruct * a0)
 {
     return sub_8144184(&a0->unk_20, a0->unk_44);
 }
 
-u16 sub_81444B0(const struct MEventStruct_Unk1442CC * a0, u32 command)
+u16 sub_81444B0(const struct MEventClientHeaderStruct * a0, u32 command)
 {
     switch (command)
     {
@@ -851,20 +859,20 @@ u16 sub_81444B0(const struct MEventStruct_Unk1442CC * a0, u32 command)
 
 void sub_814451C(u32 command)
 {
-    struct MEventBuffer_32E0_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+    struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     if (data->unk_08_0 == 2)
     {
         u16 * dest = NULL;
         switch (command)
         {
             case 0:
-                dest = &gSaveBlock1Ptr->unk_3120.buffer_310.data.unk_00;
+                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_00;
                 break;
             case 1:
-                dest = &gSaveBlock1Ptr->unk_3120.buffer_310.data.unk_02;
+                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_02;
                 break;
             case 2:
-                dest = &gSaveBlock1Ptr->unk_3120.buffer_310.data.unk_04;
+                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_04;
                 break;
             case 3:
                 break;
@@ -888,44 +896,44 @@ u16 sub_81445C0(u32 command)
     {
         case 0:
         {
-            struct MEventBuffer_32E0_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+            struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
             if (data->unk_08_0 == 2)
             {
-                struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->unk_3120.buffer_310.data;
+                struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
                 return buffer->unk_00;
             }
             break;
         }
         case 1:
         {
-            struct MEventBuffer_32E0_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+            struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
             if (data->unk_08_0 == 2)
             {
-                struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->unk_3120.buffer_310.data;
+                struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
                 return buffer->unk_02;
             }
             break;
         }
         case 2:
         {
-            struct MEventBuffer_32E0_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+            struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
             if (data->unk_08_0 == 2)
             {
-                struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->unk_3120.buffer_310.data;
+                struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
                 return buffer->unk_04;
             }
             break;
         }
         case 3:
         {
-            struct MEventBuffer_32E0_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+            struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
             if (data->unk_08_0 == 1)
                 return sub_8144218();
             break;
         }
         case 4:
         {
-            struct MEventBuffer_32E0_Sub * data = &gSaveBlock1Ptr->unk_3120.buffer_1c0.data;
+            struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
             if (data->unk_08_0 == 1)
                 return data->unk_09;
             break;
@@ -947,7 +955,7 @@ bool32 sub_81446D0(u16 a0)
         return FALSE;
     if (!ValidateReceivedWonderCard())
         return FALSE;
-    if (gSaveBlock1Ptr->unk_3120.buffer_1c0.data.unk_00 != a0)
+    if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.unk_00 != a0)
         return FALSE;
     gUnknown_203F3BC = TRUE;
     return TRUE;
@@ -960,13 +968,13 @@ void sub_8144714(u32 a0, u32 a1)
         switch (a0)
         {
             case 2:
-                sub_8144824(2, a1, gSaveBlock1Ptr->unk_3120.unk_344[1], 5);
+                sub_8144824(2, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[1], 5);
                 break;
             case 0:
-                sub_8144824(0, a1, gSaveBlock1Ptr->unk_3120.unk_344[0], 5);
+                sub_8144824(0, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5);
                 break;
             case 1:
-                sub_8144824(1, a1, gSaveBlock1Ptr->unk_3120.unk_344[0], 5);
+                sub_8144824(1, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5);
                 break;
             default:
                  AGB_ASSERT_EX(0, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent.c", 988);
@@ -976,7 +984,7 @@ void sub_8144714(u32 a0, u32 a1)
 
 void sub_8144790(void)
 {
-    CpuFill32(0, gSaveBlock1Ptr->unk_3120.unk_344, sizeof(gSaveBlock1Ptr->unk_3120.unk_344));
+    CpuFill32(0, gSaveBlock1Ptr->mysteryEventBuffers.unk_344, sizeof(gSaveBlock1Ptr->mysteryEventBuffers.unk_344));
 }
 
 bool32 sub_81447BC(u32 a0, u32 * a1, s32 size)
diff --git a/src/mevent_8145654.c b/src/mevent_8145654.c
index e42b49627..44a40c6ec 100644
--- a/src/mevent_8145654.c
+++ b/src/mevent_8145654.c
@@ -34,7 +34,7 @@ struct UnkStruct_203F3C8_02DC
 
 struct UnkStruct_203F3C8
 {
-    /*0000*/ struct MEventBuffer_32E0_Sub unk_0000;
+    /*0000*/ struct MEWonderCardData unk_0000;
     /*014c*/ struct MEventBuffer_3430_Sub unk_014C;
     /*0170*/ const struct UnkStruct_8467FB8 * unk_0170;
     /*0174*/ u8 unk_0174;
@@ -127,7 +127,7 @@ const struct UnkStruct_8467FB8 gUnknown_8467FB8[8] = {
     {1, 0, 0, 7, gUnknown_8467A7C, gUnknown_8467CAC, gUnknown_846716C}
 };
 
-bool32 InitWonderCardResources(struct MEventBuffer_32E0_Sub * r5, struct MEventBuffer_3430_Sub * r6)
+bool32 InitWonderCardResources(struct MEWonderCardData * r5, struct MEventBuffer_3430_Sub * r6)
 {
     if (r5 == NULL || r6 == NULL)
         return FALSE;
@@ -446,7 +446,7 @@ void sub_81461D8(void)
 
 struct UnkStruct_203F3CC
 {
-    /*0000*/ struct MEventBuffer_3120_Sub unk_0000;
+    /*0000*/ struct MEWonderNewsData unk_0000;
     /*01bc*/ const struct UnkStruct_8467FB8 * unk_01BC;
     /*01c0*/ u8 unk_01C0_0:1;
              u8 unk_01C0_1:7;
@@ -509,7 +509,7 @@ const struct UnkStruct_8467FB8 gUnknown_8468720[] = {
     {1, 0, 0, 0, gUnknown_84685B4, gUnknown_8468644, gUnknown_84680A0}
 };
 
-bool32 InitWonderNewsResources(const struct MEventBuffer_3120_Sub * a0)
+bool32 InitWonderNewsResources(const struct MEWonderNewsData * a0)
 {
     if (a0 == NULL)
         return FALSE;
diff --git a/src/mevent_client.c b/src/mevent_client.c
new file mode 100644
index 000000000..f4432cc11
--- /dev/null
+++ b/src/mevent_client.c
@@ -0,0 +1,289 @@
+#include "global.h"
+#include "malloc.h"
+#include "decompress.h"
+#include "overworld.h"
+#include "script.h"
+#include "battle_tower.h"
+#include "mystery_event_script.h"
+#include "mevent.h"
+#include "mevent_server.h"
+
+static EWRAM_DATA struct mevent_client * s_mevent_client_ptr = NULL;
+
+static void mevent_client_init(struct mevent_client *, u32, u32);
+static u32 mevent_client_exec(struct mevent_client *);
+static void mevent_client_free_resources(struct mevent_client *);
+
+extern const struct mevent_client_cmd gMEventClientScript_InotialListen[];
+
+void mevent_client_do_init(void)
+{
+    s_mevent_client_ptr = AllocZeroed(sizeof(struct mevent_client));
+    mevent_client_init(s_mevent_client_ptr, 1, 0);
+}
+
+u32 mevent_client_do_exec(u16 * a0)
+{
+    u32 result;
+    if (s_mevent_client_ptr == NULL)
+        return 6;
+    result = mevent_client_exec(s_mevent_client_ptr);
+    if (result == 6)
+    {
+        *a0 = s_mevent_client_ptr->param;
+        mevent_client_free_resources(s_mevent_client_ptr);
+        Free(s_mevent_client_ptr);
+        s_mevent_client_ptr = NULL;
+    }
+    return result;
+}
+
+void mevent_client_inc_flag(void)
+{
+    s_mevent_client_ptr->flag++;
+}
+
+void * mevent_client_get_buffer(void)
+{
+    return s_mevent_client_ptr->buffer;
+}
+
+void mevent_client_set_param(u32 a0)
+{
+    s_mevent_client_ptr->param = a0;
+}
+
+static void mevent_client_init(struct mevent_client * svr, u32 sendPlayerNo, u32 recvPlayerNo)
+{
+    svr->unk_00 = 0;
+    svr->mainseqno = 0;
+    svr->flag = 0;
+    svr->sendBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
+    svr->recvBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
+    svr->cmdBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
+    svr->buffer = AllocZeroed(0x40);
+    mevent_srv_sub_init(&svr->manager, sendPlayerNo, recvPlayerNo);
+}
+
+static void mevent_client_free_resources(struct mevent_client * svr)
+{
+    Free(svr->sendBuffer);
+    Free(svr->recvBuffer);
+    Free(svr->cmdBuffer);
+    Free(svr->buffer);
+}
+
+static void mevent_client_jmp_buffer(struct mevent_client * svr)
+{
+    memcpy(svr->cmdBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE);
+    svr->cmdidx = 0;
+}
+
+static void mevent_client_send_word(struct mevent_client * svr, u32 ident, u32 word)
+{
+    CpuFill32(0, svr->sendBuffer, ME_SEND_BUF_SIZE);
+    *(u32 *)svr->sendBuffer = word;
+    mevent_srv_sub_init_send(&svr->manager, ident, svr->sendBuffer, sizeof(u32));
+}
+
+static u32 client_mainseq_0(struct mevent_client * svr)
+{
+    // init
+    memcpy(svr->cmdBuffer, gMEventClientScript_InotialListen, ME_SEND_BUF_SIZE);
+    svr->cmdidx = 0;
+    svr->mainseqno = 4;
+    svr->flag = 0;
+    return 0;
+}
+
+static u32 client_mainseq_1(struct mevent_client * svr)
+{
+    // done
+    return 6;
+}
+
+static u32 client_mainseq_2(struct mevent_client * svr)
+{
+    // do recv
+    if (mevent_srv_sub_recv(&svr->manager))
+    {
+        svr->mainseqno = 4;
+        svr->flag = 0;
+    }
+    return 1;
+}
+
+static u32 client_mainseq_3(struct mevent_client * svr)
+{
+    // do send
+    if (mevent_srv_sub_send(&svr->manager))
+    {
+        svr->mainseqno = 4;
+        svr->flag = 0;
+    }
+    return 1;
+}
+
+static u32 client_mainseq_4(struct mevent_client * svr)
+{
+    // process command
+    struct mevent_client_cmd * cmd = &svr->cmdBuffer[svr->cmdidx];
+    ++svr->cmdidx;
+    switch (cmd->instr)
+    {
+    case 0:
+        break;
+    case 1:
+        svr->param = cmd->parameter;
+        svr->mainseqno = 1;
+        svr->flag = 0;
+        break;
+    case 2:
+        mevent_srv_sub_init_recv(&svr->manager, cmd->parameter, svr->recvBuffer);
+        svr->mainseqno = 2;
+        svr->flag = 0;
+        break;
+    case 3:
+        svr->mainseqno = 3;
+        svr->flag = 0;
+        break;
+    case 20:
+        mevent_srv_sub_init_send(&svr->manager, 0x14, svr->sendBuffer, 0);
+        svr->mainseqno = 3;
+        svr->flag = 0;
+        break;
+    case 19:
+        mevent_client_send_word(svr, 0x12, GetGameStat(cmd->parameter));
+        svr->mainseqno = 3;
+        svr->flag = 0;
+        break;
+    case 6:
+        if (svr->param == 0)
+            mevent_client_jmp_buffer(svr);
+        break;
+    case 7:
+        if (svr->param == 1)
+            mevent_client_jmp_buffer(svr);
+        break;
+    case 4:
+        mevent_client_jmp_buffer(svr);
+        break;
+    case 5:
+        memcpy(svr->buffer, svr->recvBuffer, 0x40);
+        svr->mainseqno = 5;
+        svr->flag = 0;
+        return 2;
+    case 11:
+        memcpy(svr->buffer, svr->recvBuffer, 0x40);
+        svr->mainseqno = 5;
+        svr->flag = 0;
+        return 3;
+    case 12:
+        memcpy(svr->buffer, svr->recvBuffer, 0x40);
+        svr->mainseqno = 5;
+        svr->flag = 0;
+        return 5;
+    case 13:
+        svr->mainseqno = 5;
+        svr->flag = 0;
+        return 4;
+    case 8:
+        BuildMEventClientHeader(svr->sendBuffer);
+        mevent_srv_sub_init_send(&svr->manager, 0x11, svr->sendBuffer, sizeof(struct MEventClientHeaderStruct));
+        break;
+    case 14:
+        mevent_client_send_word(svr, 0x13, svr->param);
+        break;
+    case 10:
+        sub_8143F68(svr->recvBuffer);
+        break;
+    case 9:
+        if (!sub_8143EF4(svr->recvBuffer))
+        {
+            sub_8143DC8(svr->recvBuffer);
+            mevent_client_send_word(svr, 0x13, 0);
+        }
+        else
+            mevent_client_send_word(svr, 0x13, 1);
+        break;
+    case 15:
+        svr->mainseqno = 6;
+        svr->flag = 0;
+        break;
+    case 16:
+        sub_8144254(svr->recvBuffer);
+        break;
+    case 17:
+        MEventSetRamScript(svr->recvBuffer, 1000);
+        break;
+    case 18:
+        memcpy(&gSaveBlock2Ptr->unk_B0.field_3F0, svr->recvBuffer, sizeof(struct BattleTowerEReaderTrainer));
+        ValidateEReaderTrainer();
+        break;
+    case 21:
+        memcpy(gDecompressionBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE);
+        svr->mainseqno = 7;
+        svr->flag = 0;
+        break;
+    }
+
+    return 1;
+}
+
+static u32 client_mainseq_5(struct mevent_client * svr)
+{
+    // wait flag
+    if (svr->flag)
+    {
+        svr->mainseqno = 4;
+        svr->flag = 0;
+    }
+    return 1;
+}
+
+static u32 client_mainseq_6(struct mevent_client * svr)
+{
+    // Run mevent buffer script
+    switch (svr->flag)
+    {
+    case 0:
+        MEventScript_InitContext(svr->recvBuffer);
+        ++svr->flag;
+        break;
+    case 1:
+        if (!MEventScript_Run(&svr->param))
+        {
+            svr->mainseqno = 4;
+            svr->flag = 0;
+        }
+        break;
+    }
+    return 1;
+}
+
+static u32 client_mainseq_7(struct mevent_client * svr)
+{
+    // exec arbitrary code
+    u32 (*func)(u32 *, struct SaveBlock2 *, struct SaveBlock1 *) = (void *)gDecompressionBuffer;
+    if (func(&svr->param, gSaveBlock2Ptr, gSaveBlock1Ptr) == 1)
+    {
+        svr->mainseqno = 4;
+        svr->flag = 0;
+    }
+    return 1;
+}
+
+static u32 mevent_client_exec(struct mevent_client * svr)
+{
+    u32 (*funcs[])(struct mevent_client *) = {
+        client_mainseq_0,
+        client_mainseq_1,
+        client_mainseq_2,
+        client_mainseq_3,
+        client_mainseq_4,
+        client_mainseq_5,
+        client_mainseq_6,
+        client_mainseq_7
+    };
+    return funcs[svr->mainseqno](svr);
+}
diff --git a/src/mevent_server.c b/src/mevent_server.c
index 9fe9e9e79..252a8885f 100644
--- a/src/mevent_server.c
+++ b/src/mevent_server.c
@@ -1,9 +1,6 @@
 #include "global.h"
 #include "malloc.h"
 #include "decompress.h"
-#include "util.h"
-#include "link.h"
-#include "link_rfu.h"
 #include "overworld.h"
 #include "script.h"
 #include "battle_tower.h"
@@ -11,302 +8,25 @@
 #include "mevent.h"
 #include "mevent_server.h"
 
-EWRAM_DATA struct mevent_client * s_mevent_client_ptr = NULL;
 EWRAM_DATA struct mevent_srv_common * s_mevent_srv_common_ptr = NULL;
 
-static void mevent_client_init(struct mevent_client *, u32, u32);
-static u32 mevent_client_exec(struct mevent_client *);
-static void mevent_client_free_resources(struct mevent_client *);
 static void mevent_srv_init_common(struct mevent_srv_common *, const void *, u32, u32);
 static void mevent_srv_free_resources(struct mevent_srv_common *);
 static u32 mevent_srv_exec_common(struct mevent_srv_common *);
 
-extern const u8 gUnknown_84687E0[];
-extern const struct mevent_cmd gUnknown_8468B6C[];
-extern const struct mevent_cmd gUnknown_8468BCC[];
-
-void mevent_client_do_init(void)
-{
-    s_mevent_client_ptr = AllocZeroed(sizeof(struct mevent_client));
-    mevent_client_init(s_mevent_client_ptr, 1, 0);
-}
-
-u32 mevent_client_do_exec(u16 * a0)
-{
-    u32 result;
-    if (s_mevent_client_ptr == NULL)
-        return 6;
-    result = mevent_client_exec(s_mevent_client_ptr);
-    if (result == 6)
-    {
-        *a0 = s_mevent_client_ptr->param;
-        mevent_client_free_resources(s_mevent_client_ptr);
-        Free(s_mevent_client_ptr);
-        s_mevent_client_ptr = NULL;
-    }
-    return result;
-}
-
-void mevent_client_inc_flag(void)
-{
-    s_mevent_client_ptr->flag++;
-}
-
-void * mevent_client_get_buffer(void)
-{
-    return s_mevent_client_ptr->buffer;
-}
-
-void mevent_client_set_param(u32 a0)
-{
-    s_mevent_client_ptr->param = a0;
-}
-
-static void mevent_client_init(struct mevent_client * svr, u32 sendPlayerNo, u32 recvPlayerNo)
-{
-    svr->unk_00 = 0;
-    svr->mainseqno = 0;
-    svr->flag = 0;
-    svr->sendBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->recvBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->cmdBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->buffer = AllocZeroed(0x40);
-    mevent_srv_sub_init(&svr->manager, sendPlayerNo, recvPlayerNo);
-}
-
-static void mevent_client_free_resources(struct mevent_client * svr)
-{
-    Free(svr->sendBuffer);
-    Free(svr->recvBuffer);
-    Free(svr->cmdBuffer);
-    Free(svr->buffer);
-}
-
-static void mevent_client_jmp_buffer(struct mevent_client * svr)
-{
-    memcpy(svr->cmdBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE);
-    svr->cmdidx = 0;
-}
-
-static void mevent_client_send_word(struct mevent_client * svr, u32 ident, u32 word)
-{
-    CpuFill32(0, svr->sendBuffer, ME_SEND_BUF_SIZE);
-    *(u32 *)svr->sendBuffer = word;
-    mevent_srv_sub_init_send(&svr->manager, ident, svr->sendBuffer, sizeof(u32));
-}
-
-static u32 ish_mainseq_0(struct mevent_client * svr)
-{
-    // init
-    memcpy(svr->cmdBuffer, gUnknown_84687E0, ME_SEND_BUF_SIZE);
-    svr->cmdidx = 0;
-    svr->mainseqno = 4;
-    svr->flag = 0;
-    return 0;
-}
-
-static u32 ish_mainseq_1(struct mevent_client * svr)
-{
-    // done
-    return 6;
-}
-
-static u32 ish_mainseq_2(struct mevent_client * svr)
-{
-    // do recv
-    if (mevent_srv_sub_recv(&svr->manager))
-    {
-        svr->mainseqno = 4;
-        svr->flag = 0;
-    }
-    return 1;
-}
-
-static u32 ish_mainseq_3(struct mevent_client * svr)
-{
-    // do send
-    if (mevent_srv_sub_send(&svr->manager))
-    {
-        svr->mainseqno = 4;
-        svr->flag = 0;
-    }
-    return 1;
-}
-
-static u32 ish_mainseq_4(struct mevent_client * svr)
-{
-    // process command
-    struct mevent_cmd_ish * cmd = &svr->cmdBuffer[svr->cmdidx];
-    ++svr->cmdidx;
-    switch (cmd->instr)
-    {
-        case 0:
-            break;
-        case 1:
-            svr->param = cmd->parameter;
-            svr->mainseqno = 1;
-            svr->flag = 0;
-            break;
-        case 2:
-            mevent_srv_sub_init_recv(&svr->manager, cmd->parameter, svr->recvBuffer);
-            svr->mainseqno = 2;
-            svr->flag = 0;
-            break;
-        case 3:
-            svr->mainseqno = 3;
-            svr->flag = 0;
-            break;
-        case 20:
-            mevent_srv_sub_init_send(&svr->manager, 0x14, svr->sendBuffer, 0);
-            svr->mainseqno = 3;
-            svr->flag = 0;
-            break;
-        case 19:
-            mevent_client_send_word(svr, 0x12, GetGameStat(cmd->parameter));
-            svr->mainseqno = 3;
-            svr->flag = 0;
-            break;
-        case 6:
-            if (svr->param == 0)
-                mevent_client_jmp_buffer(svr);
-            break;
-        case 7:
-            if (svr->param == 1)
-                mevent_client_jmp_buffer(svr);
-            break;
-        case 4:
-            mevent_client_jmp_buffer(svr);
-            break;
-        case 5:
-            memcpy(svr->buffer, svr->recvBuffer, 0x40);
-            svr->mainseqno = 5;
-            svr->flag = 0;
-            return 2;
-        case 11:
-            memcpy(svr->buffer, svr->recvBuffer, 0x40);
-            svr->mainseqno = 5;
-            svr->flag = 0;
-            return 3;
-        case 12:
-            memcpy(svr->buffer, svr->recvBuffer, 0x40);
-            svr->mainseqno = 5;
-            svr->flag = 0;
-            return 5;
-        case 13:
-            svr->mainseqno = 5;
-            svr->flag = 0;
-            return 4;
-        case 8:
-            sub_81442CC(svr->sendBuffer);
-            mevent_srv_sub_init_send(&svr->manager, 0x11, svr->sendBuffer, sizeof(struct MEventStruct_Unk1442CC));
-            break;
-        case 14:
-            mevent_client_send_word(svr, 0x13, svr->param);
-            break;
-        case 10:
-            sub_8143F68(svr->recvBuffer);
-            break;
-        case 9:
-            if (!sub_8143EF4(svr->recvBuffer))
-            {
-                sub_8143DC8(svr->recvBuffer);
-                mevent_client_send_word(svr, 0x13, 0);
-            }
-            else
-                mevent_client_send_word(svr, 0x13, 1);
-            break;
-        case 15:
-            svr->mainseqno = 6;
-            svr->flag = 0;
-            break;
-        case 16:
-            sub_8144254(svr->recvBuffer);
-            break;
-        case 17:
-            sub_8069EA4(svr->recvBuffer, 1000);
-            break;
-        case 18:
-            memcpy(&gSaveBlock2Ptr->unk_B0.field_3F0, svr->recvBuffer, sizeof(struct BattleTowerEReaderTrainer));
-            ValidateEReaderTrainer();
-            break;
-        case 21:
-            memcpy(gDecompressionBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE);
-            svr->mainseqno = 7;
-            svr->flag = 0;
-            break;
-    }
-
-    return 1;
-}
-
-static u32 ish_mainseq_5(struct mevent_client * svr)
-{
-    // wait flag
-    if (svr->flag)
-    {
-        svr->mainseqno = 4;
-        svr->flag = 0;
-    }
-    return 1;
-}
-
-static u32 ish_mainseq_6(struct mevent_client * svr)
-{
-    // ???
-    switch (svr->flag)
-    {
-        case 0:
-            sub_80DA89C(svr->recvBuffer);
-            ++svr->flag;
-            break;
-        case 1:
-            if (!sub_80DA8B0(&svr->param))
-            {
-                svr->mainseqno = 4;
-                svr->flag = 0;
-            }
-            break;
-    }
-    return 1;
-}
-
-static u32 ish_mainseq_7(struct mevent_client * svr)
-{
-    // exec arbitrary code
-    u32 (*func)(u32 *, struct SaveBlock2 *, struct SaveBlock1 *) = (void *)gDecompressionBuffer;
-    if (func(&svr->param, gSaveBlock2Ptr, gSaveBlock1Ptr) == 1)
-    {
-        svr->mainseqno = 4;
-        svr->flag = 0;
-    }
-    return 1;
-}
-
-static u32 mevent_client_exec(struct mevent_client * svr)
-{
-    u32 (*funcs[])(struct mevent_client *) = {
-        ish_mainseq_0,
-        ish_mainseq_1,
-        ish_mainseq_2,
-        ish_mainseq_3,
-        ish_mainseq_4,
-        ish_mainseq_5,
-        ish_mainseq_6,
-        ish_mainseq_7
-    };
-    return funcs[svr->mainseqno](svr);
-}
+extern const struct mevent_server_cmd gMEventSrvScript_SendNews[];
+extern const struct mevent_server_cmd gMEventSrvScript_SendCard[];
 
 void mevent_srv_init_wnews(void)
 {
     s_mevent_srv_common_ptr = AllocZeroed(sizeof(struct mevent_srv_common));
-    mevent_srv_init_common(s_mevent_srv_common_ptr, gUnknown_8468B6C, 0, 1);
+    mevent_srv_init_common(s_mevent_srv_common_ptr, gMEventSrvScript_SendNews, 0, 1);
 }
 
 void mevent_srv_new_wcard(void)
 {
     s_mevent_srv_common_ptr = AllocZeroed(sizeof(struct mevent_srv_common));
-    mevent_srv_init_common(s_mevent_srv_common_ptr, gUnknown_8468BCC, 0, 1);
+    mevent_srv_init_common(s_mevent_srv_common_ptr, gMEventSrvScript_SendCard, 0, 1);
 }
 
 u32 mevent_srv_common_do_exec(u16 * a0)
@@ -329,10 +49,10 @@ static void mevent_srv_init_common(struct mevent_srv_common * svr, const void *
 {
     svr->unk_00 = 0;
     svr->mainseqno = 0;
-    svr->mevent_32e0 = AllocZeroed(sizeof(struct MEventBuffer_32E0_Sub));
-    svr->mevent_3120 = AllocZeroed(sizeof(struct MEventBuffer_3120_Sub));
+    svr->card = AllocZeroed(sizeof(struct MEWonderCardData));
+    svr->news = AllocZeroed(sizeof(struct MEWonderNewsData));
     svr->recvBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->mevent_unk1442cc = AllocZeroed(sizeof(struct MEventStruct_Unk1442CC));
+    svr->mevent_unk1442cc = AllocZeroed(sizeof(struct MEventClientHeaderStruct));
     svr->cmdBuffer = cmdBuffer;
     svr->cmdidx = 0;
     mevent_srv_sub_init(&svr->manager, sendPlayerNo, recvPlayerNo);
@@ -340,8 +60,8 @@ static void mevent_srv_init_common(struct mevent_srv_common * svr, const void *
 
 static void mevent_srv_free_resources(struct mevent_srv_common * svr)
 {
-    Free(svr->mevent_32e0);
-    Free(svr->mevent_3120);
+    Free(svr->card);
+    Free(svr->news);
     Free(svr->recvBuffer);
     Free(svr->mevent_unk1442cc);
 }
@@ -402,7 +122,7 @@ static u32 common_mainseq_3(struct mevent_srv_common * svr)
 static u32 common_mainseq_4(struct mevent_srv_common * svr)
 {
     // process command
-    const struct mevent_cmd * cmd = &svr->cmdBuffer[svr->cmdidx];
+    const struct mevent_server_cmd * cmd = &svr->cmdBuffer[svr->cmdidx];
     void * ptr;
     svr->cmdidx++;
 
@@ -429,12 +149,12 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr)
         case 5:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 376);
             AGB_ASSERT_EX(cmd->parameter == NULL, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 377);
-            memcpy(svr->mevent_unk1442cc, svr->recvBuffer, sizeof(struct MEventStruct_Unk1442CC));
+            memcpy(svr->mevent_unk1442cc, svr->recvBuffer, sizeof(struct MEventClientHeaderStruct));
             break;
         case 6:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 382);
             AGB_ASSERT_EX(cmd->parameter == NULL, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 383);
-            svr->param = sub_81443D4(svr->mevent_unk1442cc);
+            svr->param = ValidateMEventClientHeader(svr->mevent_unk1442cc);
             break;
         case 4:
             if (svr->param == cmd->flag)
@@ -445,7 +165,7 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr)
             break;
         case 7:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 396);
-            ptr = mevent_first_if_not_null_else_second(cmd->parameter, svr->mevent_32e0);
+            ptr = mevent_first_if_not_null_else_second(cmd->parameter, svr->card);
             svr->param = sub_8144418(ptr, svr->mevent_unk1442cc, ptr);
             break;
         case 8:
@@ -472,11 +192,11 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr)
             break;
         case 14:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 432);
-            mevent_srv_common_init_send(svr, 0x17, mevent_first_if_not_null_else_second(cmd->parameter, svr->mevent_3120), sizeof(struct MEventBuffer_3120_Sub));
+            mevent_srv_common_init_send(svr, 0x17, mevent_first_if_not_null_else_second(cmd->parameter, svr->news), sizeof(struct MEWonderNewsData));
             break;
         case 13:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 438);
-            mevent_srv_common_init_send(svr, 0x16, mevent_first_if_not_null_else_second(cmd->parameter, svr->mevent_32e0), sizeof(struct MEventBuffer_32E0_Sub));
+            mevent_srv_common_init_send(svr, 0x16, mevent_first_if_not_null_else_second(cmd->parameter, svr->card), sizeof(struct MEWonderCardData));
             break;
         case 16:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 444);
@@ -506,11 +226,11 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr)
             break;
         case 22:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 481);
-            memcpy(svr->mevent_32e0, cmd->parameter, 332);
+            memcpy(svr->card, cmd->parameter, 332);
             break;
         case 23:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 486);
-            memcpy(svr->mevent_3120, cmd->parameter, 444);
+            memcpy(svr->news, cmd->parameter, 444);
             break;
         case 21:
             AGB_ASSERT_EX(cmd->flag == FALSE, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 491);
@@ -526,12 +246,12 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr)
             break;
         case 26:
             AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 506);
-            memcpy(svr->mevent_32e0, GetSavedWonderCard(), 332);
-            sub_814410C(svr->mevent_32e0);
+            memcpy(svr->card, GetSavedWonderCard(), 332);
+            sub_814410C(svr->card);
             break;
         case 27:
             AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 512);
-            memcpy(svr->mevent_3120, GetSavedWonderNews(), 444);
+            memcpy(svr->news, GetSavedWonderNews(), 444);
             break;
         case 28:
             AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/mevent_server.c", 517);
diff --git a/src/mystery_event_script.c b/src/mystery_event_script.c
index 146595272..68a045f2c 100644
--- a/src/mystery_event_script.c
+++ b/src/mystery_event_script.c
@@ -67,12 +67,12 @@ static bool32 RunMysteryEventScriptCommand(struct ScriptContext *ctx)
         return FALSE;
 }
 
-void sub_80DA89C(u8 *script)
+void MEventScript_InitContext(u8 *script)
 {
     InitMysteryEventScript(&sMysteryEventScriptContext, script);
 }
 
-bool32 sub_80DA8B0(u32 *a0)
+bool32 MEventScript_Run(u32 *a0)
 {
     bool32 ret = RunMysteryEventScriptCommand(&sMysteryEventScriptContext);
     *a0 = sMysteryEventScriptContext.data[2];
@@ -83,8 +83,8 @@ bool32 sub_80DA8B0(u32 *a0)
 u32 RunMysteryEventScript(u8 *script)
 {
     u32 ret;
-    sub_80DA89C(script);
-    while (sub_80DA8B0(&ret));
+    MEventScript_InitContext(script);
+    while (MEventScript_Run(&ret));
 
     return ret;
 }
diff --git a/src/mystery_gift_menu.c b/src/mystery_gift_menu.c
index 13a6d37e2..8384d211d 100644
--- a/src/mystery_gift_menu.c
+++ b/src/mystery_gift_menu.c
@@ -1,6 +1,5 @@
 #include "global.h"
 #include "palette.h"
-#include "dma3.h"
 #include "gpu_regs.h"
 #include "bg.h"
 #include "task.h"
@@ -915,7 +914,7 @@ bool32 mevent_save_game(u8 * state)
         (*state)++;
         break;
     case 1:
-        TrySavingData(0);
+        TrySavingData(SAVE_NORMAL);
         (*state)++;
         break;
     case 2:
@@ -1095,7 +1094,7 @@ const u8 * mevent_message_stamp_card_etc_send_status(u32 * a0, u8 unused, u32 ms
     return result;
 }
 
-bool32 PrintMGSendStatus(u8 * state, u16 * arg1, u8 arg2, u32 msgId)
+static bool32 PrintMGSendStatus(u8 * state, u16 * arg1, u8 arg2, u32 msgId)
 {
     u32 flag;
     const u8 * str = mevent_message_stamp_card_etc_send_status(&flag, arg2, msgId);
@@ -1278,7 +1277,7 @@ void task00_mystery_gift(u8 taskId)
     case  8:
         switch (mevent_client_do_exec(&data->curPromptWindowId))
         {
-        case 6:
+        case 6: // done
             task_add_05_task_del_08FA224_when_no_RfuFunc();
             data->prevPromptWindowId = data->curPromptWindowId;
             data->state = 13;
diff --git a/src/pokemon.c b/src/pokemon.c
index fb7a8c626..c4ae0c4da 100644
--- a/src/pokemon.c
+++ b/src/pokemon.c
@@ -5624,8 +5624,7 @@ u8 GetNumberOfRelearnableMoves(struct Pokemon *mon)
     return numMoves;
 }
 
-// SpeciesToPokedexNum?
-u16 sub_8043F90(u16 species)
+u16 SpeciesToPokedexNum(u16 species)
 {
     species = SpeciesToNationalPokedexNum(species);
 
diff --git a/src/quest_log.c b/src/quest_log.c
index 7ce3ede12..dfb3bad5b 100644
--- a/src/quest_log.c
+++ b/src/quest_log.c
@@ -1067,7 +1067,7 @@ static void QuestLog_EndPlayback(void)
 {
     ResetSpecialVars();
     Save_ResetSaveCounters();
-    Save_LoadGameData(0);
+    Save_LoadGameData(SAVE_NORMAL);
     SetMainCallback2(sub_8057430);
     gFieldCallback2 = sub_8111F60;
     FreeAllWindowBuffers();
diff --git a/src/reset_save_heap.c b/src/reset_save_heap.c
index 428f7b88d..7b9d30c06 100644
--- a/src/reset_save_heap.c
+++ b/src/reset_save_heap.c
@@ -8,7 +8,7 @@
 #include "overworld.h"
 #include "malloc.h"
 
-void sub_8079B7C(void)
+void ResetSaveHeap(void)
 {
     u16 imeBackup = REG_IME;
     
@@ -20,8 +20,8 @@ void sub_8079B7C(void)
     SetSaveBlocksPointers();
     ResetMenuAndMonGlobals();
     Save_ResetSaveCounters();
-    Save_LoadGameData(0);
-    if (gSaveFileStatus == 0 || gSaveFileStatus == 2)
+    Save_LoadGameData(SAVE_NORMAL);
+    if (gSaveFileStatus == SAVE_STATUS_EMPTY || gSaveFileStatus == SAVE_STATUS_INVALID)
         Sav2_ClearSetDefault();
     SetPokemonCryStereo(gSaveBlock2Ptr->optionsSound);
     InitHeap(gHeap, HEAP_SIZE);
diff --git a/src/save.c b/src/save.c
index 57364b10b..a2d365886 100644
--- a/src/save.c
+++ b/src/save.c
@@ -672,7 +672,7 @@ u8 HandleSavingData(u8 saveType)
         for(i = 0; i < 5; i++)
             save_write_to_flash(i, gRamSaveSectionLocations);
         break;
-    case EREADER_SAVE:
+    case SAVE_EREADER:
         SaveSerializedGame();
         save_write_to_flash(0, gRamSaveSectionLocations);
         break;
@@ -719,7 +719,7 @@ bool8 sub_80DA3D8(void)
 {
     u8 retVal = sub_80D9AA4(0xE, gRamSaveSectionLocations);
     if (gDamagedSaveSectors)
-        DoSaveFailedScreen(0);
+        DoSaveFailedScreen(SAVE_NORMAL);
     if (retVal == 0xFF)
         return 1;
     else
@@ -730,7 +730,7 @@ u8 sub_80DA40C(void)
 {
     sub_80D9B04(0xE, gRamSaveSectionLocations);
     if (gDamagedSaveSectors)
-        DoSaveFailedScreen(0);
+        DoSaveFailedScreen(SAVE_NORMAL);
     return 0;
 }
 
@@ -738,7 +738,7 @@ u8 sub_80DA434(void)
 {
     sav12_xor_get(0xE, gRamSaveSectionLocations);
     if (gDamagedSaveSectors)
-        DoSaveFailedScreen(0);
+        DoSaveFailedScreen(SAVE_NORMAL);
     return 0;
 }
 
@@ -769,34 +769,34 @@ bool8 sub_80DA4A0(void)
         retVal = TRUE;
     }
     if (gDamagedSaveSectors)
-        DoSaveFailedScreen(1);
+        DoSaveFailedScreen(SAVE_LINK);
     return retVal;
 }
 
-u8 Save_LoadGameData(u8 a1)
+u8 Save_LoadGameData(u8 saveType)
 {
     u8 result;
 
     if (gFlashMemoryPresent != TRUE)
     {
-        gSaveFileStatus = 4;
-        return 0xFF;
+        gSaveFileStatus = SAVE_STATUS_NO_FLASH;
+        return SAVE_STATUS_ERROR;
     }
 
     UpdateSaveAddresses();
-    switch (a1)
+    switch (saveType)
     {
-    case 0:
+    case SAVE_NORMAL:
     default:
         result = sub_80D9E14(0xFFFF, gRamSaveSectionLocations);
         LoadSerializedGame();
         gSaveFileStatus = result;
         gGameContinueCallback = 0;
         break;
-    case 3:
-        result = sub_80DA120(0x1C, gDecompressionBuffer, 0xF80);
-        if(result == 1)
-            result = sub_80DA120(0x1D, gDecompressionBuffer + 0xF80, 0xF80);
+    case SAVE_HALL_OF_FAME:
+        result = sub_80DA120(SECTOR_HOF(0), gDecompressionBuffer, 0xF80);
+        if (result == SAVE_STATUS_OK)
+            result = sub_80DA120(SECTOR_HOF(1), gDecompressionBuffer + 0xF80, 0xF80);
         break;
     }
 
@@ -809,7 +809,7 @@ u32 TryCopySpecialSaveSection(u8 sector, u8* dst)
     s32 size;
     u8* savData;
 
-    if (sector != 30 && sector != 31)
+    if (sector != SECTOR_TTOWER(0) && sector != SECTOR_TTOWER(1))
         return 0xFF;
     ReadFlash(sector, 0, (u8 *)&gSaveDataBuffer, sizeof(struct SaveSection));
     if (*(u32*)(&gSaveDataBuffer.data[0]) != 0xB39D)
@@ -830,7 +830,7 @@ u32 TryWriteSpecialSaveSection(u8 sector, u8* src)
     u8* savData;
     void* savDataBuffer;
 
-    if (sector != 30 && sector != 31)
+    if (sector != SECTOR_TTOWER(0) && sector != SECTOR_TTOWER(1))
         return 0xFF;
 
     savDataBuffer = &gSaveDataBuffer;
diff --git a/src/script.c b/src/script.c
index 06418b8d0..f18a8568b 100644
--- a/src/script.c
+++ b/src/script.c
@@ -546,7 +546,7 @@ u8 *sub_8069E48(void)
     }
 }
 
-void sub_8069EA4(u8 *script, u16 scriptSize)
+void MEventSetRamScript(u8 *script, u16 scriptSize)
 {
     if (scriptSize > sizeof(gSaveBlock1Ptr->ramScript.data.script))
         scriptSize = sizeof(gSaveBlock1Ptr->ramScript.data.script);
diff --git a/src/title_screen.c b/src/title_screen.c
index 44bdc7c0f..2d6b6cf15 100644
--- a/src/title_screen.c
+++ b/src/title_screen.c
@@ -621,7 +621,7 @@ static void SetTitleScreenScene_Cry(s16 * data)
             SetSaveBlocksPointers();
             ResetMenuAndMonGlobals();
             Save_ResetSaveCounters();
-            Save_LoadGameData(0);
+            Save_LoadGameData(SAVE_NORMAL);
             if (gSaveFileStatus == SAVE_STATUS_EMPTY || gSaveFileStatus == SAVE_STATUS_INVALID)
                 Sav2_ClearSetDefault();
             SetPokemonCryStereo(gSaveBlock2Ptr->optionsSound);
diff --git a/src/tm_case.c b/src/tm_case.c
index ca149a6c6..260efaa53 100644
--- a/src/tm_case.c
+++ b/src/tm_case.c
@@ -105,7 +105,7 @@ static void Task_SelectTMAction_Type3(u8 taskId);
 static void Task_SelectTMAction_FromSellMenu(u8 taskId);
 static void Task_AskConfirmSaleWithAmount(u8 taskId);
 static void Task_PlaceYesNoBox(u8 taskId);
-static void Task_SaleOfTMsCancelled(u8 taskId);
+static void Task_SaleOfTMsCanceled(u8 taskId);
 static void Task_InitQuantitySelectUI(u8 taskId);
 static void SellTM_PrintQuantityAndSalePrice(s16 quantity, s32 value);
 static void Task_QuantitySelect_HandleInput(u8 taskId);
@@ -178,7 +178,7 @@ static const struct MenuAction sMenuActions_UseGiveExit[] = {
 
 static const u8 sMenuActionIndices_Field[] = {0, 1, 2};
 static const u8 sMenuActionIndices_UnionRoom[] = {1, 2};
-static const struct YesNoFuncTable sYesNoFuncTable = {Task_PrintSaleConfirmedText, Task_SaleOfTMsCancelled};
+static const struct YesNoFuncTable sYesNoFuncTable = {Task_PrintSaleConfirmedText, Task_SaleOfTMsCanceled};
 
 static const u8 sText_ClearTo18[] = _("{CLEAR_TO 18}");
 static const u8 sText_SingleSpace[] = _(" ");
@@ -1012,7 +1012,7 @@ static void Task_PlaceYesNoBox(u8 taskId)
     HandleCreateYesNoMenu(taskId, &sYesNoFuncTable);
 }
 
-static void Task_SaleOfTMsCancelled(u8 taskId)
+static void Task_SaleOfTMsCanceled(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;