Merge pull request #315 from PikalaxALT/overworld

Overworld

38 files changed, 3715 insertions, 174 deletions

diff --git a/src/bg_regs.c b/src/bg_regs.c
index d5879a862..ec884e4f7 100644
--- a/src/bg_regs.c
+++ b/src/bg_regs.c
@@ -25,7 +25,7 @@ vu16 *const gBGVOffsetRegs[] =
 };
 
 const u16 gDISPCNTBGFlags[] = { DISPCNT_BG0_ON, DISPCNT_BG1_ON, DISPCNT_BG2_ON, DISPCNT_BG3_ON };
-const u16 gBLDCNTTarget2BGFlags[] = { BLDCNT_TGT2_BG0, BLDCNT_TGT2_BG1, BLDCNT_TGT2_BG2, BLDCNT_TGT2_BG3 };
+const u16 gOverworldBackgroundLayerFlags[] = { BLDCNT_TGT2_BG0, BLDCNT_TGT2_BG1, BLDCNT_TGT2_BG2, BLDCNT_TGT2_BG3 };
 const u16 gBLDCNTTarget1BGFlags[] = { BLDCNT_TGT1_BG0, BLDCNT_TGT1_BG1, BLDCNT_TGT1_BG2, BLDCNT_TGT1_BG3 };
 
 const u8 gBGControlRegOffsets[] =
diff --git a/src/bike.c b/src/bike.c
index 5ec44ec7a..eaa4af2bd 100644
--- a/src/bike.c
+++ b/src/bike.c
@@ -260,7 +260,7 @@ bool8 sub_80BD460(u8 r0)
 
 bool32 IsRunningDisallowed(u8 metatileBehavior)
 {
-    if (!(gMapHeader.escapeRope & 2)) // wrong name? probably a bitfield. 
+    if (!(gMapHeader.flags & MAP_ALLOW_RUN))
         return TRUE;
     if (sub_80BD4B8(metatileBehavior) != TRUE)
         return FALSE;
diff --git a/src/cable_club.c b/src/cable_club.c
index bc41ca4f6..e75f1abf8 100644
--- a/src/cable_club.c
+++ b/src/cable_club.c
@@ -724,7 +724,7 @@ static void sub_8081624(void)
 void CB2_ReturnFromCableClubBattle(void)
 {
     gBattleTypeFlags &= (u16)~BATTLE_TYPE_20;
-    sub_8055DB8();
+    Overworld_ResetMapMusic();
     LoadPlayerParty();
     SavePlayerBag();
     Special_UpdateTrainerFansAfterLinkBattle();
@@ -750,7 +750,7 @@ void CB2_ReturnFromCableClubBattle(void)
     }
     else
     {
-        gMain.savedCallback = c2_8056854;
+        gMain.savedCallback = CB2_ReturnToFieldFromMultiplayer;
     }
     SetMainCallback2(CB2_SetUpSaveAfterLinkBattle);
 }
@@ -767,7 +767,7 @@ void CleanupLinkRoomState(void)
 
 void ExitLinkRoom(void)
 {
-    sub_8057F5C();
+    QueueExitLinkRoomKey();
 }
 
 static void Task_EnterCableClubSeat(u8 taskId)
diff --git a/src/credits.c b/src/credits.c
index 4d7bbd67b..12240c98f 100644
--- a/src/credits.c
+++ b/src/credits.c
@@ -1,6 +1,7 @@
 #include "global.h"
 #include "malloc.h"
 #include "bg.h"
+#include "credits.h"
 #include "palette.h"
 #include "gpu_regs.h"
 #include "task.h"
@@ -563,94 +564,81 @@ static const struct SpriteTemplate sGroundSpriteTemplate_Static = {
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_Route23[] = {
-    { 0x00fe, MAP_GROUP(ROUTE23), MAP_NUM(ROUTE23) },
-    { 0x000b, 0x006b, 0x0001 },
-    { 0x0000, 0x0001, 0x0500 }, // Scroll down
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(ROUTE23, 11, 107, 1),
+    CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_ViridianCity[] = {
-    { 0x00fe, MAP_GROUP(VIRIDIAN_CITY), MAP_NUM(VIRIDIAN_CITY) },
-    { 0x001e, 0x0022, 0x0001 },
-    { 0x0000, 0xffff, 0x0500 }, // Scroll up
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(VIRIDIAN_CITY, 30, 34, 1),
+    CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_PewterCity[] = {
-    { 0x00fe, MAP_GROUP(PEWTER_CITY), MAP_NUM(PEWTER_CITY) },
-    { 0x0014, 0x001a, 0x0001 },
-    { 0x0000, 0xffff, 0x0500 }, // Scroll up
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(PEWTER_CITY, 20, 26, 1),
+    CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_CeruleanCity[] = {
-    { 0x00fe, MAP_GROUP(CERULEAN_CITY), MAP_NUM(CERULEAN_CITY) },
-    { 0x0008, 0x0006, 0x0001 },
-    { 0x0001, 0x0001, 0x0500 }, // Scroll right and down
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(CERULEAN_CITY, 8, 6, 1),
+    CREDITSOVWLDSCROLL(1, 1, 0x0500), // Scroll right and down
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_Route25[] = {
-    { 0x00fe, MAP_GROUP(ROUTE25), MAP_NUM(ROUTE25) },
-    { 0x0019, 0x0006, 0x0001 },
-    { 0x0001, 0x0000, 0x0500 }, // Scroll right
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(ROUTE25, 25, 6, 1),
+    CREDITSOVWLDSCROLL(1, 0, 0x0500), // Scroll right
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_VermilionCity[] = {
-    { 0x00fe, MAP_GROUP(VERMILION_CITY), MAP_NUM(VERMILION_CITY) },
-    { 0x0009, 0x0007, 0x0001 },
-    { 0x0001, 0x0001, 0x0500 }, // Scroll right and down
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(VERMILION_CITY, 9, 7, 1),
+    CREDITSOVWLDSCROLL(1, 1, 0x0500), // Scroll right and down
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_Route10[] = {
-    { 0x00fe, MAP_GROUP(ROUTE10), MAP_NUM(ROUTE10) },
-    { 0x000b, 0x0044, 0x0001 },
-    { 0x0000, 0x0001, 0x0500 }, // Scroll down
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(ROUTE10, 11, 68, 1),
+    CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_CeladonCity[] = {
-    { 0x00fe, MAP_GROUP(CELADON_CITY), MAP_NUM(CELADON_CITY) },
-    { 0x0030, 0x0010, 0x0001 },
-    { 0xffff, 0x0000, 0x0500 }, // Scroll left
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(CELADON_CITY, 48, 16, 1),
+    CREDITSOVWLDSCROLL(-1, 0, 0x0500), // Scroll left
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_SaffronCity[] = {
-    { 0x00fe, MAP_GROUP(SAFFRON_CITY), MAP_NUM(SAFFRON_CITY) },
-    { 0x0027, 0x0005, 0x0001 },
-    { 0x0000, 0x0001, 0x0500 }, // Scroll down
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(SAFFRON_CITY, 39, 5, 1),
+    CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_Route17[] = {
-    { 0x00fe, MAP_GROUP(ROUTE17), MAP_NUM(ROUTE17) },
-    { 0x0007, 0x002b, 0x0001 },
-    { 0x0000, 0x0001, 0x0500 }, // Scroll down
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(ROUTE17, 7, 43, 1),
+    CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_FuchsiaCity[] = {
-    { 0x00fe, MAP_GROUP(FUCHSIA_CITY), MAP_NUM(FUCHSIA_CITY) },
-    { 0x001c, 0x0005, 0x0001 },
-    { 0x0000, 0x0001, 0x0500 }, // Scroll down
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(FUCHSIA_CITY, 28, 5, 1),
+    CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_CinnabarIsland[] = {
-    { 0x00fe, MAP_GROUP(CINNABAR_ISLAND), MAP_NUM(CINNABAR_ISLAND) },
-    { 0x000d, 0x0011, 0x0001 },
-    { 0x0000, 0xffff, 0x0500 }, // Scroll up
-    { 0x00fd, 0x00fd, 0x00fd }
+    CREDITSOVWLDLOADMAP(CINNABAR_ISLAND, 13, 17, 1),
+    CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up
+    CREDITSOVWLDEND
 };
 
 static const struct CreditsOverworldCmd sOverworldCmd_Route21[] = {
-    { 0x00fe, MAP_GROUP(ROUTE21_NORTH), MAP_NUM(ROUTE21_NORTH) },
-    { 0x0008, 0x0014, 0x0001 },
-    { 0x0000, 0xffff, 0x0500 }, // Scroll up
-    { 0x00fd, 0x00fd, 0x00fd },
+    CREDITSOVWLDLOADMAP(ROUTE21_NORTH, 8, 20, 1),
+    CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up
+    CREDITSOVWLDEND,
 };
 
 static const struct CreditsOverworldCmd *const sOverworldMapScenes[] = {
diff --git a/src/daycare.c b/src/daycare.c
index e07c2a234..1e50a7c09 100644
--- a/src/daycare.c
+++ b/src/daycare.c
@@ -1766,7 +1766,7 @@ static void Task_EggHatch(u8 taskID)
     {
         CleanupOverworldWindowsAndTilemaps();
         SetMainCallback2(CB2_EggHatch_0);
-        gFieldCallback = FieldCallback_ReturnToEventScript2;
+        gFieldCallback = FieldCB_ContinueScriptHandleMusic;
         DestroyTask(taskID);
     }
 }
diff --git a/src/diploma.c b/src/diploma.c
index f702eebd5..5c653d071 100644
--- a/src/diploma.c
+++ b/src/diploma.c
@@ -193,7 +193,7 @@ static void Task_DiplomaReturnToOverworld(u8 taskId)
     DestroyTask(taskId);
     FreeAllWindowBuffers();
     FREE_AND_SET_NULL(gDiploma);
-    SetMainCallback2(CB2_Overworld);
+    SetMainCallback2(sub_80568FC);
 }
 
 static void DiplomaBgInit(void)
diff --git a/src/easy_chat_2.c b/src/easy_chat_2.c
index 4b3c70b67..948b7c39f 100644
--- a/src/easy_chat_2.c
+++ b/src/easy_chat_2.c
@@ -279,7 +279,7 @@ void ShowEasyChatScreen(void)
     default:
         return;
     }
-    DoEasyChatScreen(gSpecialVar_0x8004, words, sub_80568C4);
+    DoEasyChatScreen(gSpecialVar_0x8004, words, CB2_ReturnToFieldContinueScript);
 }
 
 static const u16 sECPhrase_MysteryEventIsExciting[] = {
diff --git a/src/event_data.c b/src/event_data.c
index f16267c98..c012a4a59 100644
--- a/src/event_data.c
+++ b/src/event_data.c
@@ -38,7 +38,7 @@ void InitEventData(void)
     memset(sSpecialFlags, 0, SPECIAL_FLAGS_COUNT);
 }
 
-void sub_806E110(void)
+void ClearTempFieldEventData(void)
 {
     memset(gSaveBlock1Ptr->flags, 0, 4);
     memset(gSaveBlock1Ptr->vars, 0, 16 * 2);
diff --git a/src/field_effect.c b/src/field_effect.c
index b59ce5a6b..c0d7d3463 100644
--- a/src/field_effect.c
+++ b/src/field_effect.c
@@ -2064,7 +2064,7 @@ static void EscapeRopeFieldEffect_Step1(struct Task * task)
     if (data[4] == 1 && !gPaletteFade.active && BGMusicStopped() == TRUE)
     {
         SetObjectEventDirection(playerObj, task->data[15]);
-        sub_80555E0();
+        SetWarpDestinationToEscapeWarp();
         WarpIntoMap();
         gFieldCallback = FieldCallback_EscapeRopeExit;
         SetMainCallback2(CB2_LoadMap);
@@ -2331,7 +2331,7 @@ static void TeleportFieldEffectTask4(struct Task * task)
     {
         if (BGMusicStopped() == TRUE)
         {
-            copy_saved_warp3_bank_and_enter_x_to_warp1();
+            SetWarpDestinationToLastHealLocation();
             WarpIntoMap();
             SetMainCallback2(CB2_LoadMap);
             gFieldCallback = FieldCallback_TeleportIn;
diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c
index 03190c095..bf5ab0ab3 100644
--- a/src/field_fadetransition.c
+++ b/src/field_fadetransition.c
@@ -94,7 +94,7 @@ void FadeInFromBlack(void)
 
 void WarpFadeOutScreen(void)
 {
-    const struct MapHeader *header = warp1_get_mapheader();
+    const struct MapHeader *header = GetDestinationWarpMapHeader();
     if (header->regionMapSectionId != gMapHeader.regionMapSectionId && MapHasPreviewScreen(header->regionMapSectionId, MPS_TYPE_CAVE))
         FadeScreen(FADE_TO_BLACK, 0);
     else
@@ -113,7 +113,7 @@ void WarpFadeOutScreen(void)
 
 static void sub_807DC70(void)
 {
-    switch (MapTransitionIsEnter(GetCurrentMapType(), warp1_get_mapheader()->mapType))
+    switch (MapTransitionIsEnter(GetCurrentMapType(), GetDestinationWarpMapHeader()->mapType))
     {
     case FALSE:
         FadeScreen(FADE_TO_BLACK, 3);
@@ -152,7 +152,7 @@ static void task0A_asap_script_env_2_enable_and_set_ctx_running(u8 taskId)
     }
 }
 
-void FieldCallback_ReturnToEventScript2(void)
+void FieldCB_ContinueScriptHandleMusic(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
@@ -160,7 +160,7 @@ void FieldCallback_ReturnToEventScript2(void)
     CreateTask(task0A_asap_script_env_2_enable_and_set_ctx_running, 10);
 }
 
-void sub_807DD44(void)
+void FieldCB_ContinueScript(void)
 {
     ScriptContext2_Enable();
     FadeInFromBlack();
@@ -193,7 +193,7 @@ static void task_mpl_807DD60(u8 taskId)
     }
 }
 
-void FieldCB_ReturnToFieldWiredLink(void)
+void FieldCB_ReturnToFieldCableLink(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
@@ -284,7 +284,7 @@ static void sub_807DF4C(bool8 a0)
         FadeInFromBlack();
 }
 
-void FieldCB_UnionRoomWarp(void)
+void FieldCB_DefaultWarpExit(void)
 {
     Overworld_PlaySpecialMapMusic();
     sub_8111CF0();
@@ -292,7 +292,7 @@ void FieldCB_UnionRoomWarp(void)
     ScriptContext2_Enable();
 }
 
-void sub_807DF7C(void)
+void FieldCB_WarpExitFadeFromBlack(void)
 {
     Overworld_PlaySpecialMapMusic();
     sub_8111CF0();
@@ -491,7 +491,7 @@ void FadeTransition_FadeInOnReturnToStartMenu(void)
     ScriptContext2_Enable();
 }
 
-bool8 FieldCB2_ReturnToStartMenuInit(void)
+bool8 FieldCB_ReturnToFieldOpenStartMenu(void)
 {
     SetUpReturnToStartMenu();
     return FALSE;
@@ -535,7 +535,7 @@ void DoWarp(void)
     WarpFadeOutScreen();
     PlayRainStoppingSoundEffect();
     PlaySE(SE_KAIDAN);
-    gFieldCallback = FieldCB_UnionRoomWarp;
+    gFieldCallback = FieldCB_DefaultWarpExit;
     CreateTask(sub_807E718, 10);
 }
 
@@ -545,7 +545,7 @@ void DoDiveWarp(void)
     TryFadeOutOldMapMusic();
     WarpFadeOutScreen();
     PlayRainStoppingSoundEffect();
-    gFieldCallback = FieldCB_UnionRoomWarp;
+    gFieldCallback = FieldCB_DefaultWarpExit;
     CreateTask(sub_807E718, 10);
 }
 
@@ -560,7 +560,7 @@ void sub_807E4A0(u16 metatileBehavior, u16 delay)
 void DoDoorWarp(void)
 {
     ScriptContext2_Enable();
-    gFieldCallback = FieldCB_UnionRoomWarp;
+    gFieldCallback = FieldCB_DefaultWarpExit;
     CreateTask(sub_807E80C, 10);
 }
 
@@ -574,7 +574,7 @@ void sub_807E500(void)
 void DoUnionRoomWarp(void)
 {
     ScriptContext2_Enable();
-    gFieldCallback = FieldCB_UnionRoomWarp;
+    gFieldCallback = FieldCB_DefaultWarpExit;
     CreateTask(Task_TeleportWarp, 10);
 }
 
@@ -833,7 +833,7 @@ static void sub_807E980(u8 taskId)
             data[0]++;
         break;
     default:
-        gFieldCallback = FieldCB_UnionRoomWarp;
+        gFieldCallback = FieldCB_DefaultWarpExit;
         WarpIntoMap();
         SetMainCallback2(CB2_LoadMap);
         DestroyTask(taskId);
diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c
index 0bc4910eb..6b51e7bc2 100644
--- a/src/field_player_avatar.c
+++ b/src/field_player_avatar.c
@@ -1152,7 +1152,7 @@ u8 GetPlayerAvatarGraphicsIdByStateIdAndGender(u8 state, u8 gender)
     return sPlayerAvatarGfxIds[state][gender];
 }
 
-u8 GetHoennLinkPartnerGraphicsIdByGender(u8 gender)
+u8 GetRSAvatarGraphicsIdByGender(u8 gender)
 {
     return sHoennLinkPartnerGfxIds[gender];
 }
diff --git a/src/field_screen_effect.c b/src/field_screen_effect.c
index a12b57b24..22043ed2d 100644
--- a/src/field_screen_effect.c
+++ b/src/field_screen_effect.c
@@ -360,7 +360,7 @@ static void Task_BarnDoorWipeChild(u8 taskId)
 #undef DIR_WIPE_OUT
 #undef tChildOffset
 
-static bool8 sub_807F3A4(u8 taskId, const u8 *text, u8 x, u8 y)
+static bool8 PrintWhiteOutRecoveryMessage(u8 taskId, const u8 *text, u8 x, u8 y)
 {
     u8 windowId = gTasks[taskId].data[1];
 
@@ -385,7 +385,7 @@ static bool8 sub_807F3A4(u8 taskId, const u8 *text, u8 x, u8 y)
     return FALSE;
 }
 
-static void sub_807F45C(u8 taskId)
+static void Task_RushInjuredPokemonToCenter(u8 taskId)
 {
     u8 windowId;
     const struct HealLocation *loc;
@@ -399,7 +399,7 @@ static void sub_807F45C(u8 taskId)
         FillWindowPixelBuffer(windowId, PIXEL_FILL(0));
         PutWindowTilemap(windowId);
         CopyWindowToVram(windowId, 3);
-        loc = GetHealLocationPointer(1);
+        loc = GetHealLocation(1);
         if (gSaveBlock1Ptr->lastHealLocation.mapGroup == loc->group
          && gSaveBlock1Ptr->lastHealLocation.mapNum == loc->map
          && gSaveBlock1Ptr->lastHealLocation.warpId == -1
@@ -410,14 +410,14 @@ static void sub_807F45C(u8 taskId)
             gTasks[taskId].data[0] = 1;
         break;
     case 1:
-        if (sub_807F3A4(taskId, gUnknown_841B554, 2, 8))
+        if (PrintWhiteOutRecoveryMessage(taskId, gText_PlayerScurriedToCenter, 2, 8))
         {
             ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], 2);
             ++gTasks[taskId].data[0];
         }
         break;
     case 4:
-        if (sub_807F3A4(taskId, gUnknown_841B5B6, 2, 8))
+        if (PrintWhiteOutRecoveryMessage(taskId, gText_PlayerScurriedBackHome, 2, 8))
         {
             ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], 2);
             ++gTasks[taskId].data[0];
@@ -450,12 +450,12 @@ static void sub_807F45C(u8 taskId)
     }
 }
 
-void sub_807F5F0(void)
+void FieldCB_RushInjuredPokemonToCenter(void)
 {
     u8 taskId;
 
     ScriptContext2_Enable();
     palette_bg_faded_fill_black();
-    taskId = CreateTask(sub_807F45C, 10);
+    taskId = CreateTask(Task_RushInjuredPokemonToCenter, 10);
     gTasks[taskId].data[0] = 0;
 }
diff --git a/src/field_specials.c b/src/field_specials.c
index 59c026b78..657c80a40 100644
--- a/src/field_specials.c
+++ b/src/field_specials.c
@@ -108,7 +108,7 @@ void ForcePlayerOntoBike(void)
     Overworld_ChangeMusicTo(MUS_CYCLING);
 }
 
-void nullsub_74(void)
+void ResetCyclingRoadChallengeData(void)
 {
 
 }
@@ -840,9 +840,9 @@ static const u8 sElevatorWindowAnimDuration[] = {
 void GetElevatorFloor(void)
 {
     u16 floor = 4;
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F))
+    if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F))
     {
-        switch (gSaveBlock1Ptr->warp2.mapNum)
+        switch (gSaveBlock1Ptr->dynamicWarp.mapNum)
         {
         case MAP_NUM(SILPH_CO_1F):
             floor = 4;
@@ -888,9 +888,9 @@ void GetElevatorFloor(void)
             break;
         }
     }
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F))
+    if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F))
     {
-        switch (gSaveBlock1Ptr->warp2.mapNum)
+        switch (gSaveBlock1Ptr->dynamicWarp.mapNum)
         {
         case MAP_NUM(CELADON_CITY_DEPARTMENT_STORE_1F):
             floor = 4;
@@ -909,9 +909,9 @@ void GetElevatorFloor(void)
             break;
         }
     }
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F))
+    if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(TRAINER_TOWER_1F))
     {
-        switch (gSaveBlock1Ptr->warp2.mapNum)
+        switch (gSaveBlock1Ptr->dynamicWarp.mapNum)
         {
         case MAP_NUM(TRAINER_TOWER_1F):
         case MAP_NUM(TRAINER_TOWER_2F):
@@ -937,9 +937,9 @@ u16 InitElevatorFloorSelectMenuPos(void)
     sElevatorScroll = 0;
     sElevatorCursorPos = 0;
 
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F))
+    if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F))
     {
-        switch (gSaveBlock1Ptr->warp2.mapNum)
+        switch (gSaveBlock1Ptr->dynamicWarp.mapNum)
         {
         case MAP_NUM(SILPH_CO_11F):
             sElevatorScroll = 0;
@@ -999,9 +999,9 @@ u16 InitElevatorFloorSelectMenuPos(void)
             break;
         }
     }
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F))
+    if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F))
     {
-        switch (gSaveBlock1Ptr->warp2.mapNum)
+        switch (gSaveBlock1Ptr->dynamicWarp.mapNum)
         {
         case MAP_NUM(CELADON_CITY_DEPARTMENT_STORE_5F):
             sElevatorScroll = 0;
@@ -1025,9 +1025,9 @@ u16 InitElevatorFloorSelectMenuPos(void)
             break;
         }
     }
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F))
+    if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(TRAINER_TOWER_1F))
     {
-        switch (gSaveBlock1Ptr->warp2.mapNum)
+        switch (gSaveBlock1Ptr->dynamicWarp.mapNum)
         {
         case MAP_NUM(TRAINER_TOWER_1F):
         case MAP_NUM(TRAINER_TOWER_2F):
@@ -2037,10 +2037,10 @@ const u16 sPokeCenter1FMaps[] = {
     MAP_UNDEFINED
 };
 
-bool8 sub_80CC87C(void)
+bool8 UsedPokemonCenterWarp(void)
 {
     s32 i;
-    u16 mapno = (gUnknown_2031DB4.mapGroup << 8) + gUnknown_2031DB4.mapNum;
+    u16 mapno = (gLastUsedWarp.mapGroup << 8) + gLastUsedWarp.mapNum;
     for (i = 0; sPokeCenter1FMaps[i] != MAP_UNDEFINED; i++)
     {
         if (sPokeCenter1FMaps[i] == mapno)
diff --git a/src/field_tasks.c b/src/field_tasks.c
index 6bd4b6f46..4c7b93f20 100644
--- a/src/field_tasks.c
+++ b/src/field_tasks.c
@@ -63,7 +63,7 @@ static void Task_RunTimeBasedEvents(u8 taskId)
     {
         if (gQuestLogState != 2 && gQuestLogState != 3)
         {
-            sub_8056078(&data[1], &data[2]);
+            UpdateAmbientCry(&data[1], &data[2]);
         }
     }
 }
diff --git a/src/fieldmap.c b/src/fieldmap.c
index 53a97629f..60c6f3dae 100644
--- a/src/fieldmap.c
+++ b/src/fieldmap.c
@@ -370,7 +370,7 @@ union Block
     s32 xprime;                                                                                    \
     s32 yprime;                                                                                    \
                                                                                                    \
-    struct MapLayout *mapLayout = gMapHeader.mapLayout;                                            \
+    const struct MapLayout *mapLayout = gMapHeader.mapLayout;                                      \
                                                                                                    \
     xprime = x - 7;                                                                                \
     xprime += 8 * mapLayout->borderWidth;                                                          \
@@ -485,7 +485,7 @@ void MapGridSetMetatileImpassabilityAt(s32 x, s32 y, bool32 arg2)
     }
 }
 
-u32 GetBehaviorByMetatileIdAndMapLayout(struct MapLayout *mapLayout, u16 metatile, u8 attr)
+u32 GetBehaviorByMetatileIdAndMapLayout(const struct MapLayout *mapLayout, u16 metatile, u8 attr)
 {
     u32 * attributes;
 
@@ -732,7 +732,7 @@ bool8 CameraMove(s32 x, s32 y)
         old_y = gSaveBlock1Ptr->pos.y;
         connection = sub_8059600(direction, gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y);
         sub_80594AC(connection, direction, x, y);
-        sub_8055864(connection->mapGroup, connection->mapNum);
+        LoadMapFromCameraTransition(connection->mapGroup, connection->mapNum);
         gCamera.active = TRUE;
         gCamera.x = old_x - gSaveBlock1Ptr->pos.x;
         gCamera.y = old_y - gSaveBlock1Ptr->pos.y;
diff --git a/src/heal_location.c b/src/heal_location.c
index a8ac8cb46..ae02c7844 100644
--- a/src/heal_location.c
+++ b/src/heal_location.c
@@ -50,7 +50,7 @@ static const struct HealLocation * GetHealLocationPointerFromMapGroupAndNum(u16
     return &sSpawnPoints[i - 1];
 }
 
-const struct HealLocation * GetHealLocationPointer(u32 idx)
+const struct HealLocation * GetHealLocation(u32 idx)
 {
     if (idx == 0)
         return NULL;
diff --git a/src/item_use.c b/src/item_use.c
index df3dbaceb..af3243678 100644
--- a/src/item_use.c
+++ b/src/item_use.c
@@ -268,7 +268,7 @@ void FieldUseFunc_MachBike(u8 taskId)
      || MetatileBehavior_IsIsolatedVerticalRail(behavior) == TRUE
      || MetatileBehavior_IsIsolatedHorizontalRail(behavior) == TRUE)
         sub_80A10C4(taskId, gTasks[taskId].data[3], 2, gUnknown_8416451);
-    else if (sub_8055C9C() == TRUE && !sub_80BD540())
+    else if (Overworld_IsBikingAllowed() == TRUE && !sub_80BD540())
     {
         sItemUseOnFieldCB = ItemUseOnFieldCB_Bicycle;
         sub_80A103C(taskId);
@@ -618,7 +618,7 @@ static void sub_80A1B48(u8 taskId)
 
 bool8 CanUseEscapeRopeOnCurrMap(void)
 {
-    if (gMapHeader.escapeRope & 1)
+    if (gMapHeader.flags & MAP_ALLOW_ESCAPE_ROPE)
         return TRUE;
     else
         return FALSE;
diff --git a/src/itemfinder.c b/src/itemfinder.c
index 5d6950acc..51a670b0f 100644
--- a/src/itemfinder.c
+++ b/src/itemfinder.c
@@ -15,7 +15,7 @@
 static void Task_NoResponse_CleanUp(u8 taskId);
 static void Task_ItemfinderResponseSoundsAndAnims(u8 taskId);
 static void Task_ItemfinderUnderfootSoundsAndAnims(u8 taskId);
-static bool8 HiddenItemIsWithinRangeOfPlayer(struct MapEvents * events, u8 taskId);
+static bool8 HiddenItemIsWithinRangeOfPlayer(const struct MapEvents * events, u8 taskId);
 static void SetUnderfootHiddenItem(u8 taskId, u32 hiddenItem);
 static void SetNormalHiddenItem(u8 taskId);
 static void FindHiddenItemsInConnectedMaps(u8 taskId);
@@ -199,7 +199,7 @@ static void Task_ItemfinderUnderfootSoundsAndAnims(u8 taskId)
     tDingTimer++;
 }
 
-static bool8 HiddenItemIsWithinRangeOfPlayer(struct MapEvents * events, u8 taskId)
+static bool8 HiddenItemIsWithinRangeOfPlayer(const struct MapEvents * events, u8 taskId)
 {
     s16 x, y, i, dx, dy;
     PlayerGetDestCoords(&x, &y);
@@ -284,7 +284,7 @@ static void SetNormalHiddenItem(u8 taskId)
     }
 }
 
-static bool8 HiddenItemAtPos(struct MapEvents * events, s16 x, s16 y)
+static bool8 HiddenItemAtPos(const struct MapEvents * events, s16 x, s16 y)
 {
     u8 bgEventCount = events->bgEventCount;
     struct BgEvent * bgEvents = events->bgEvents;
diff --git a/src/learn_move.c b/src/learn_move.c
index 8a2f5781b..8cf10cffa 100644
--- a/src/learn_move.c
+++ b/src/learn_move.c
@@ -286,7 +286,7 @@ static void Task_InitMoveRelearnerMenu(u8 taskId)
     if (!gPaletteFade.active)
     {
         SetMainCallback2(CB2_MoveRelearner_Init);
-        gFieldCallback = FieldCallback_ReturnToEventScript2;
+        gFieldCallback = FieldCB_ContinueScriptHandleMusic;
         DestroyTask(taskId);
     }
 }
diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c
index 2259e9214..15ffb4813 100644
--- a/src/link_rfu_2.c
+++ b/src/link_rfu_2.c
@@ -201,7 +201,7 @@ void ResetLinkRfuGFLayer(void)
     }
     ResetSendDataManager(&Rfu.cmd_8800_sendbuf);
     RFU_queue_20_70_reset(&Rfu.unk_124);
-    RFU_queue_40_14_reset(&Rfu.unk_9e8);
+    RFU_queue_40_14_reset(&Rfu.sendQueue);
     CpuFill16(0, gSendCmd, sizeof gSendCmd);
     CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
     CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers);
@@ -659,7 +659,7 @@ static void sub_80F906C(void)
     }
     if (Rfu.unk_c3c == 0)
     {
-        RFU_queue_40_14_send(&Rfu.unk_9e8, Rfu.unk_4c);
+        RFU_queue_40_14_send(&Rfu.sendQueue, Rfu.unk_4c);
         RFU_queue_2_14_recv(&Rfu.unk_c1c, Rfu.unk_4c);
     }
 }
@@ -881,7 +881,7 @@ static bool32 RfuProcessEnqueuedRecvBlock(void)
         Rfu.unk_cd0--;
         CallRfuFunc();
         sub_80F94BC(gSendCmd, sp48);
-        RFU_queue_40_14_recv(&Rfu.unk_9e8, sp48);
+        RFU_queue_40_14_recv(&Rfu.sendQueue, sp48);
         for (i = 0; i < CMD_LENGTH - 1; i++)
             gSendCmd[i] = 0;
     }
@@ -909,7 +909,7 @@ static void HandleSendFailure(u8 unused, u32 flags)
 
                 j++;j--; // Needed to match;
             }
-            RFU_queue_40_14_recv(&Rfu.unk_9e8, sResendBlock8);
+            RFU_queue_40_14_recv(&Rfu.sendQueue, sResendBlock8);
             Rfu.cmd_8800_sendbuf.failedFlags |= (1 << i);
         }
         flags >>= 1;
@@ -1853,11 +1853,11 @@ static void RfuCheckErrorStatus(void)
             gWirelessCommType = 2;
         SetMainCallback2(CB2_LinkError);
         gMain.savedCallback = CB2_LinkError;
-        SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.unk_9e8.count, RfuGetErrorStatus() == 2);
+        SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.sendQueue.count, RfuGetErrorStatus() == 2);
         Rfu.errorState = 2;
         CloseLink();
     }
-    else if (Rfu.unk_9e8.full == 1 || Rfu.unk_124.full == 1)
+    else if (Rfu.sendQueue.full == 1 || Rfu.unk_124.full == 1)
     {
         if (lman.childClockSlave_flag)
             rfu_LMAN_requestChangeAgbClockMaster();
@@ -2851,7 +2851,7 @@ static const char gUnknown_843EEA8[][8] = {
 
 static u32 sub_80FC44C(void)
 {
-    return Rfu.unk_9e8.count;
+    return Rfu.sendQueue.count;
 }
 
 u32 GetRfuRecvQueueLength(void)
diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c
index d3f6e93db..8382f1dab 100644
--- a/src/link_rfu_3.c
+++ b/src/link_rfu_3.c
@@ -184,7 +184,7 @@ void RFU_queue_20_70_reset(struct UnkRfuStruct_2_Sub_124 *queue)
     queue->full = 0;
 }
 
-void RFU_queue_40_14_reset(struct UnkRfuStruct_2_Sub_9e8 *ptr)
+void RFU_queue_40_14_reset(struct RfuSendQueue *ptr)
 {
     s32 i;
     s32 j;
@@ -260,7 +260,7 @@ void RFU_queue_20_70_recv(struct UnkRfuStruct_2_Sub_124 *queue, u8 *data)
     }
 }
 
-void RFU_queue_40_14_recv(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *data)
+void RFU_queue_40_14_recv(struct RfuSendQueue *queue, u8 *data)
 {
     s32 i;
     u16 imeBak;
@@ -325,7 +325,7 @@ bool8 RFU_queue_20_70_send(struct UnkRfuStruct_2_Sub_124 *queue, u8 *dest)
     return TRUE;
 }
 
-bool8 RFU_queue_40_14_send(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *dest)
+bool8 RFU_queue_40_14_send(struct RfuSendQueue *queue, u8 *dest)
 {
     s32 i;
     u16 imeBak;
diff --git a/src/load_save.c b/src/load_save.c
index 7ab28ffc3..9dff59928 100644
--- a/src/load_save.c
+++ b/src/load_save.c
@@ -127,24 +127,24 @@ void MoveSaveBlocks_ResetHeap(void)
     gSaveBlock2Ptr->encryptionKey = encryptionKey;
 }
 
-u32 sav2_x1_query_bit1(void)
+u32 UseContinueGameWarp(void)
 {
     return gSaveBlock2Ptr->specialSaveWarpFlags & CONTINUE_GAME_WARP;
 }
 
-void sav2_x9_clear_bit1(void)
+void ClearContinueGameWarpStatus(void)
 {
     gSaveBlock2Ptr->specialSaveWarpFlags &= ~CONTINUE_GAME_WARP;
 }
 
-void sub_804C1AC(void)
+void SetContinueGameWarpStatus(void)
 {
     gSaveBlock2Ptr->specialSaveWarpFlags |= CONTINUE_GAME_WARP;
 }
 
 void SetContinueGameWarpStatusToDynamicWarp(void)
 {
-    sub_8055778(0);
+    SetContinueGameWarpToDynamicWarp(0);
     gSaveBlock2Ptr->specialSaveWarpFlags |= CONTINUE_GAME_WARP;
 }
 
@@ -286,7 +286,7 @@ void ApplyNewEncryptionKeyToAllEncryptedData(u32 encryptionKey)
     for(i = 0; i < NUM_TOWER_CHALLENGE_TYPES; i++)
         ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->trainerTower[i].bestTime, encryptionKey);
 
-    sub_8054F38(encryptionKey);
+    ApplyNewEncryptionKeyToGameStats(encryptionKey);
     ApplyNewEncryptionKeyToBagItems_(encryptionKey);
     ApplyNewEncryptionKeyToBerryPowder(encryptionKey);
     ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->money, encryptionKey);
diff --git a/src/map_name_popup.c b/src/map_name_popup.c
index 10e549cbd..87df371ce 100644
--- a/src/map_name_popup.c
+++ b/src/map_name_popup.c
@@ -18,7 +18,7 @@ static u16 MapNamePopupCreateWindow(bool32 palIntoFadedBuffer);
 static void MapNamePopupPrintMapNameOnWindow(u16 windowId);
 static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 flags);
 
-void CreateMapNamePopupIfNotAlreadyRunning(bool32 palIntoFadedBuffer)
+void ShowMapNamePopup(bool32 palIntoFadedBuffer)
 {
     u8 taskId;
     if (FlagGet(FLAG_SPECIAL_FLAG_0x4000) != TRUE && !(gQuestLogState == 2 || gQuestLogState == 3))
@@ -151,9 +151,9 @@ static u16 MapNamePopupCreateWindow(bool32 palintoFadedBuffer)
     };
     u16 windowId;
     u16 r6 = 0x01D;
-    if (gMapHeader.flags != 0)
+    if (gMapHeader.floorNum != 0)
     {
-        if (gMapHeader.flags != 0x7F)
+        if (gMapHeader.floorNum != 0x7F)
         {
             windowTemplate.width += 5;
             r6 = 0x027;
@@ -187,29 +187,29 @@ static void MapNamePopupPrintMapNameOnWindow(u16 windowId)
     u32 maxWidth = 112;
     u32 xpos;
     u8 *ptr = GetMapName(mapName, gMapHeader.regionMapSectionId, 0);
-    if (gMapHeader.flags != 0)
+    if (gMapHeader.floorNum != 0)
     {
-        ptr = MapNamePopupAppendFloorNum(ptr, gMapHeader.flags);
-        maxWidth = gMapHeader.flags != 0x7F ? 152 : 176;
+        ptr = MapNamePopupAppendFloorNum(ptr, gMapHeader.floorNum);
+        maxWidth = gMapHeader.floorNum != 0x7F ? 152 : 176;
     }
     xpos = (maxWidth - GetStringWidth(2, mapName, -1)) / 2;
     FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
     AddTextPrinterParameterized(windowId, 2, mapName, xpos, 2, 0xFF, NULL);
 }
 
-static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 flags)
+static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 floorNum)
 {
-    if (flags == 0)
+    if (floorNum == 0)
         return dest;
     *dest++ = CHAR_SPACE;
-    if (flags == 0x7F)
+    if (floorNum == 0x7F)
         return StringCopy(dest, gUnknown_841D18D);
-    if (flags < 0)
+    if (floorNum < 0)
     {
         *dest++ = CHAR_B;
-        flags *= -1;
+        floorNum *= -1;
     }
-    dest = ConvertIntToDecimalStringN(dest, flags, STR_CONV_MODE_LEFT_ALIGN, 2);
+    dest = ConvertIntToDecimalStringN(dest, floorNum, STR_CONV_MODE_LEFT_ALIGN, 2);
     *dest++ = CHAR_F;
     *dest = EOS;
     return dest;
diff --git a/src/metatile_behavior.c b/src/metatile_behavior.c
index f75630802..77c839b89 100644
--- a/src/metatile_behavior.c
+++ b/src/metatile_behavior.c
@@ -199,7 +199,7 @@ bool8 MetatileBehavior_IsNonAnimDoor(u8 metatileBehavior)
         return FALSE;
 }
 
-bool8 MetatileBehavior_ReturnFalse_2(u8 metatileBehavior) { return FALSE; }
+bool8 MetatileBehavior_IsDeepSouthWarp(u8 metatileBehavior) { return FALSE; }
 
 bool8 MetatileBehavior_IsSurfable(u8 metatileBehavior)
 {
diff --git a/src/option_menu.c b/src/option_menu.c
index 62e90c33b..87306c98f 100644
--- a/src/option_menu.c
+++ b/src/option_menu.c
@@ -509,7 +509,7 @@ static void BufferOptionMenuString(u8 selection)
 
 static void CloseAndSaveOptionMenu(u8 taskId)
 {
-    gFieldCallback = FieldCB_UnionRoomWarp;
+    gFieldCallback = FieldCB_DefaultWarpExit;
     SetMainCallback2(gMain.savedCallback);
     FreeAllWindowBuffers();
     gSaveBlock2Ptr->optionsTextSpeed = sOptionMenuPtr->option[MENUITEM_TEXTSPEED];
diff --git a/src/overworld.c b/src/overworld.c
new file mode 100644
index 000000000..e86939f10
--- /dev/null
+++ b/src/overworld.c
@@ -0,0 +1,3553 @@
+#include "global.h"
+#include "gflib.h"
+#include "bg_regs.h"
+#include "cable_club.h"
+#include "credits.h"
+#include "event_data.h"
+#include "event_object_movement.h"
+#include "event_scripts.h"
+#include "field_camera.h"
+#include "field_control_avatar.h"
+#include "field_effect.h"
+#include "field_fadetransition.h"
+#include "field_message_box.h"
+#include "field_player_avatar.h"
+#include "field_screen_effect.h"
+#include "field_specials.h"
+#include "field_tasks.h"
+#include "field_weather.h"
+#include "fieldmap.h"
+#include "fldeff.h"
+#include "heal_location.h"
+#include "help_system.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "load_save.h"
+#include "m4a.h"
+#include "map_name_popup.h"
+#include "map_preview_screen.h"
+#include "metatile_behavior.h"
+#include "money.h"
+#include "new_game.h"
+#include "new_menu_helpers.h"
+#include "overworld.h"
+#include "play_time.h"
+#include "quest_log.h"
+#include "quest_log_objects.h"
+#include "random.h"
+#include "renewable_hidden_items.h"
+#include "roamer.h"
+#include "safari_zone.h"
+#include "save_location.h"
+#include "scanline_effect.h"
+#include "script.h"
+#include "script_pokemon_util.h"
+#include "start_menu.h"
+#include "tileset_anims.h"
+#include "trainer_pokemon_sprites.h"
+#include "vs_seeker.h"
+#include "wild_encounter.h"
+#include "constants/maps.h"
+#include "constants/flags.h"
+#include "constants/species.h"
+#include "constants/region_map_sections.h"
+#include "constants/songs.h"
+
+#define PLAYER_TRADING_STATE_IDLE 0x80
+#define PLAYER_TRADING_STATE_BUSY 0x81
+#define PLAYER_TRADING_STATE_UNK_2 0x82
+#define PLAYER_TRADING_STATE_EXITING_ROOM 0x83
+
+#define FACING_NONE 0
+#define FACING_UP 1
+#define FACING_DOWN 2
+#define FACING_LEFT 3
+#define FACING_RIGHT 4
+#define FACING_FORCED_UP 7
+#define FACING_FORCED_DOWN 8
+#define FACING_FORCED_LEFT 9
+#define FACING_FORCED_RIGHT 10
+
+typedef u16 (*KeyInterCB)(u32 key);
+
+struct InitialPlayerAvatarState
+{
+    u8 transitionFlags;
+    u8 direction;
+    bool8 unk2;
+};
+
+struct TradeRoomPlayer
+{
+    u8 playerId;
+    bool8 isLocalPlayer;
+    u8 c;
+    u8 facing;
+    struct MapPosition pos;
+    u16 field_C;
+};
+
+EWRAM_DATA struct WarpData gLastUsedWarp = {};
+static EWRAM_DATA struct WarpData sWarpDestination = {};
+static EWRAM_DATA struct WarpData sFixedDiveWarp = {};
+static EWRAM_DATA struct WarpData sFixedHoleWarp = {};
+
+// File boundary perhaps?
+static EWRAM_DATA struct InitialPlayerAvatarState sInitialPlayerAvatarState = {};
+
+// File boundary perhaps?
+EWRAM_DATA bool8 gDisableMapMusicChangeOnMapLoad = FALSE;
+static EWRAM_DATA u16 sAmbientCrySpecies = SPECIES_NONE;
+static EWRAM_DATA bool8 sIsAmbientCryWaterMon = FALSE;
+
+// File boundary perhaps?
+ALIGNED(4) EWRAM_DATA bool8 gUnknown_2031DE0 = FALSE;
+static EWRAM_DATA const struct CreditsOverworldCmd *sCreditsOverworld_Script = NULL;
+static EWRAM_DATA s16 sCreditsOverworld_CmdLength = 0;
+static EWRAM_DATA s16 sCreditsOverworld_CmdIndex = 0;
+
+// File boundary perhaps?
+EWRAM_DATA struct LinkPlayerObjectEvent gLinkPlayerObjectEvents[4] = {};
+
+u16 *gBGTilemapBuffers1;
+u16 *gBGTilemapBuffers2;
+u16 *gBGTilemapBuffers3;
+void (*gFieldCallback)(void);
+bool8 (*gFieldCallback2)(void);
+u16 gHeldKeyCodeToSend;
+u8 gLocalLinkPlayerId;
+u8 gFieldLinkPlayerCount;
+
+static u8 sPlayerTradingStates[4];
+static KeyInterCB sPlayerKeyInterceptCallback;
+static bool8 gUnknown_3000E88;
+static u8 sRfuKeepAliveTimer;
+
+static u8 CountBadgesForOverworldWhiteOutLossCalculation(void);
+static void Overworld_ResetStateAfterWhitingOut(void);
+static void Overworld_SetWhiteoutRespawnPoint(void);
+static u8 GetAdjustedInitialTransitionFlags(struct InitialPlayerAvatarState *playerStruct, u16 metatileBehavior, u8 mapType);
+static u8 GetAdjustedInitialDirection(struct InitialPlayerAvatarState *playerStruct, u8 transitionFlags, u16 metatileBehavior, u8 mapType);
+static u16 GetCenterScreenMetatileBehavior(void);
+static void SetDefaultFlashLevel(void);
+static void Overworld_TryMapConnectionMusicTransition(void);
+static void ChooseAmbientCrySpecies(void);
+
+static void CB2_Overworld(void);
+static void CB2_LoadMap2(void);
+static void c2_80567AC(void);
+static void CB2_ReturnToFieldLocal(void);
+static void CB2_ReturnToFieldLink(void);
+static void FieldClearVBlankHBlankCallbacks(void);
+static void SetFieldVBlankCallback(void);
+static void VBlankCB_Field(void);
+
+static bool32 map_loading_iteration_3(u8 *state);
+static bool32 sub_8056CD8(u8 *state);
+static bool32 map_loading_iteration_2_link(u8 *state);
+static void do_load_map_stuff_loop(u8 *state);
+static void MoveSaveBlocks_ResetHeap_(void);
+static void sub_8056E80(void);
+static void sub_8056F08(void);
+static void InitOverworldGraphicsRegisters(void);
+static void sub_8057024(bool32 a0);
+static void sub_8057074(void);
+static void mli4_mapscripts_and_other(void);
+static void sub_8057100(void);
+static void sub_8057114(void);
+static void SetCameraToTrackGuestPlayer(void);
+static void SetCameraToTrackGuestPlayer_2(void);
+static void sub_8057178(void);
+static void sub_80571A8(void);
+static void CreateLinkPlayerSprites(void);
+static void sub_80572D8(void);
+static void sub_8057300(u8 *state);
+static bool32 sub_8057314(u8 *state);
+static bool32 SetUpScrollSceneForCredits(u8 *state, u8 unused);
+static bool8 MapLdr_Credits(void);
+static void CameraCB_CreditsPan(struct CameraObject * camera);
+static void Task_OvwldCredits_FadeOut(u8 taskId);
+static void Task_OvwldCredits_WaitFade(u8 taskId);
+
+static void CB1_UpdateLinkState(void);
+static void ResetAllMultiplayerState(void);
+static void ClearAllPlayerKeys(void);
+static void SetKeyInterceptCallback(KeyInterCB callback);
+static void ResetAllTradingStates(void);
+static void UpdateAllLinkPlayers(u16 *linkKeys, s32 selfId);
+static void UpdateHeldKeyCode(u16 interceptedKeys);
+static u32 GetLinkSendQueueLength(void);
+static u16 GetDirectionForDpadKey(u16 key);
+static void SetPlayerFacingDirection(u8 linkPlayerId, u8 setFacing);
+static void ResetPlayerHeldKeys(u16 *linkKeys);
+static u16 KeyInterCB_SelfIdle(u32 linkPlayerId);
+static u16 KeyInterCB_DeferToEventScript(u32 linkPlayerId);
+static u16 KeyInterCB_DeferToRecvQueue(u32 linkPlayerId);
+static u16 KeyInterCB_DeferToSendQueue(u32 linkPlayerId);
+static void LoadTradeRoomPlayer(s32 i, s32 selfId, struct TradeRoomPlayer * trainer);
+static bool32 PlayerIsAtSouthExit(struct TradeRoomPlayer * player);
+static const u8 *TryGetTileEventScript(struct TradeRoomPlayer * player);
+static const u8 *TryInteractWithPlayer(struct TradeRoomPlayer * player);
+static bool32 sub_8057FEC(struct TradeRoomPlayer * player);
+static bool32 sub_8058004(struct TradeRoomPlayer * player);
+static u16 GetDirectionForEventScript(const u8 *script);
+static void sub_80581BC(void);
+static void CreateConfirmLeaveTradeRoomPrompt(void);
+static void InitLinkRoomStartMenuScript(void);
+static void InitMenuBasedScript(const u8 *script);
+static void sub_80581DC(const u8 *script);
+static void sub_8058230(void);
+static void SpawnLinkPlayerObjectEvent(u8 i, s16 x, s16 y, u8 gender);
+static void InitLinkPlayerObjectEventPos(struct ObjectEvent *objEvent, s16 x, s16 y);
+static u8 GetSpriteForLinkedPlayer(u8 linkPlayerId);
+static void GetLinkPlayerCoords(u8 linkPlayerId, u16 *x, u16 *y);
+static u8 GetLinkPlayerFacingDirection(u8 linkPlayerId);
+static u8 GetLinkPlayerElevation(u8 linkPlayerId);
+static u8 GetLinkPlayerIdAt(s16 x, s16 y);
+static void CreateLinkPlayerSprite(u8 i, u8 version);
+static u8 MovementEventModeCB_Normal(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8);
+static u8 MovementEventModeCB_Ignored(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8);
+static u8 MovementEventModeCB_Normal_2(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8);
+static u8 FacingHandler_DoNothing(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8);
+static u8 FacingHandler_DpadMovement(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8);
+static u8 FacingHandler_ForcedFacingChange(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8);
+static void MovementStatusHandler_EnterFreeMode(struct LinkPlayerObjectEvent *, struct ObjectEvent *);
+static void MovementStatusHandler_TryAdvanceScript(struct LinkPlayerObjectEvent *, struct ObjectEvent *);
+static u8 FlipVerticalAndClearForced(u8 newFacing, u8 oldFacing);
+static u8 LinkPlayerDetectCollision(u8 selfObjEventId, u8 a2, s16 x, s16 y);
+static void SpriteCB_LinkPlayer(struct Sprite * sprite);
+
+extern const struct MapLayout * gMapLayouts[];
+extern const struct MapHeader *const *gMapGroups[];
+
+// Routines related to game state on warping in
+
+static const u8 sWhiteOutMoneyLossMultipliers[] = {
+     2,
+     4,
+     6,
+     9,
+    12,
+    16,
+    20,
+    25,
+    30
+};
+
+static const u16 sWhiteOutMoneyLossBadgeFlagIDs[] = {
+    FLAG_BADGE01_GET,
+    FLAG_BADGE02_GET,
+    FLAG_BADGE03_GET,
+    FLAG_BADGE04_GET,
+    FLAG_BADGE05_GET,
+    FLAG_BADGE06_GET,
+    FLAG_BADGE07_GET,
+    FLAG_BADGE08_GET
+};
+
+static void DoWhiteOut(void)
+{
+    ScriptContext2_RunNewScript(EventScript_ResetEliteFourEnd);
+    RemoveMoney(&gSaveBlock1Ptr->money, ComputeWhiteOutMoneyLoss());
+    HealPlayerParty();
+    Overworld_ResetStateAfterWhitingOut();
+    Overworld_SetWhiteoutRespawnPoint();
+    WarpIntoMap();
+}
+
+u32 ComputeWhiteOutMoneyLoss(void)
+{
+    u8 nbadges = CountBadgesForOverworldWhiteOutLossCalculation();
+    u8 toplevel = GetPlayerPartyHighestLevel();
+    u32 losings = toplevel * 4 * sWhiteOutMoneyLossMultipliers[nbadges];
+    u32 money = GetMoney(&gSaveBlock1Ptr->money);
+    if (losings > money)
+        losings = money;
+    return losings;
+}
+
+void OverworldWhiteOutGetMoneyLoss(void)
+{
+    u32 losings = ComputeWhiteOutMoneyLoss();
+    ConvertIntToDecimalStringN(gStringVar1, losings, STR_CONV_MODE_LEFT_ALIGN, CountDigits(losings));
+}
+
+static u8 CountBadgesForOverworldWhiteOutLossCalculation(void)
+{
+    int i;
+    u8 nbadges = 0;
+    for (i = 0; i < NELEMS(sWhiteOutMoneyLossBadgeFlagIDs); i++)
+    {
+        if (FlagGet(sWhiteOutMoneyLossBadgeFlagIDs[i]))
+            nbadges++;
+    }
+    return nbadges;
+}
+
+void Overworld_ResetStateAfterFly(void)
+{
+    ResetInitialPlayerAvatarState();
+    FlagClear(FLAG_SYS_ON_CYCLING_ROAD);
+    VarSet(VAR_MAP_SCENE_ROUTE16, 0);
+    FlagClear(FLAG_SYS_CRUISE_MODE);
+    FlagClear(FLAG_SYS_SAFARI_MODE);
+    VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0);
+    FlagClear(FLAG_SYS_USE_STRENGTH);
+    FlagClear(FLAG_SYS_FLASH_ACTIVE);
+    FlagClear(FLAG_0x808);
+    VarSet(VAR_0x404D, 0);
+}
+
+void Overworld_ResetStateAfterTeleport(void)
+{
+    ResetInitialPlayerAvatarState();
+    FlagClear(FLAG_SYS_ON_CYCLING_ROAD);
+    VarSet(VAR_MAP_SCENE_ROUTE16, 0);
+    FlagClear(FLAG_SYS_CRUISE_MODE);
+    FlagClear(FLAG_SYS_SAFARI_MODE);
+    VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0);
+    FlagClear(FLAG_SYS_USE_STRENGTH);
+    FlagClear(FLAG_SYS_FLASH_ACTIVE);
+    FlagClear(FLAG_0x808);
+    VarSet(VAR_0x404D, 0);
+}
+
+void Overworld_ResetStateAfterDigEscRope(void)
+{
+    ResetInitialPlayerAvatarState();
+    FlagClear(FLAG_SYS_ON_CYCLING_ROAD);
+    VarSet(VAR_MAP_SCENE_ROUTE16, 0);
+    FlagClear(FLAG_SYS_CRUISE_MODE);
+    FlagClear(FLAG_SYS_SAFARI_MODE);
+    VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0);
+    FlagClear(FLAG_SYS_USE_STRENGTH);
+    FlagClear(FLAG_SYS_FLASH_ACTIVE);
+    FlagClear(FLAG_0x808);
+    VarSet(VAR_0x404D, 0);
+}
+
+static void Overworld_ResetStateAfterWhitingOut(void)
+{
+    ResetInitialPlayerAvatarState();
+    FlagClear(FLAG_SYS_ON_CYCLING_ROAD);
+    VarSet(VAR_MAP_SCENE_ROUTE16, 0);
+    FlagClear(FLAG_SYS_CRUISE_MODE);
+    FlagClear(FLAG_SYS_SAFARI_MODE);
+    VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0);
+    FlagClear(FLAG_SYS_USE_STRENGTH);
+    FlagClear(FLAG_SYS_FLASH_ACTIVE);
+    FlagClear(FLAG_0x808);
+    VarSet(VAR_0x404D, 0);
+}
+
+static void sub_8054E40(void)
+{
+    FlagClear(FLAG_SYS_SAFARI_MODE);
+    VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0);
+    ChooseAmbientCrySpecies();
+    UpdateLocationHistoryForRoamer();
+    RoamerMoveToOtherLocationSet();
+}
+
+// Routines related to game stats
+
+void ResetGameStats(void)
+{
+    int i;
+
+    for (i = 0; i < NUM_GAME_STATS; i++)
+    {
+        gSaveBlock1Ptr->gameStats[i] = 0;
+    }
+}
+
+void IncrementGameStat(u8 statId)
+{
+    u32 statVal;
+    if (statId >= NUM_USED_GAME_STATS)
+        return;
+    statVal = GetGameStat(statId);
+    if (statVal < 0xFFFFFF)
+        statVal++;
+    else
+        statVal = 0xFFFFFF;
+    SetGameStat(statId, statVal);
+}
+
+u32 GetGameStat(u8 statId)
+{
+    if (statId >= NUM_USED_GAME_STATS)
+        return 0;
+    else
+        return gSaveBlock1Ptr->gameStats[statId] ^ gSaveBlock2Ptr->encryptionKey;
+}
+
+void SetGameStat(u8 statId, u32 statVal)
+{
+    if (statId >= NUM_USED_GAME_STATS)
+        return;
+    gSaveBlock1Ptr->gameStats[statId] = statVal ^ gSaveBlock2Ptr->encryptionKey;
+}
+
+void ApplyNewEncryptionKeyToGameStats(u32 newKey)
+{
+    u8 i;
+    for (i = 0; i < NUM_GAME_STATS; i++)
+    {
+        ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->gameStats[i], newKey);
+    }
+}
+
+// Routines related to object events
+
+static void sub_8054F68(void)
+{
+    u8 i, j;
+    u8 mapGroup;
+    u8 mapNum;
+    u8 localId;
+    const struct MapHeader * linkedMap;
+
+    for (i = 0, j = 0; i < gMapHeader.events->objectEventCount; i++)
+    {
+        if (gMapHeader.events->objectEvents[i].unk2 == 0xFF)
+        {
+            localId = gMapHeader.events->objectEvents[i].elevation;
+            mapNum = gMapHeader.events->objectEvents[i].trainerType;
+            mapGroup = gMapHeader.events->objectEvents[i].trainerRange_berryTreeId;
+            linkedMap = Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum);
+            gSaveBlock1Ptr->objectEventTemplates[j] = linkedMap->events->objectEvents[localId - 1];
+            gSaveBlock1Ptr->objectEventTemplates[j].localId = gMapHeader.events->objectEvents[i].localId;
+            gSaveBlock1Ptr->objectEventTemplates[j].x = gMapHeader.events->objectEvents[i].x;
+            gSaveBlock1Ptr->objectEventTemplates[j].y = gMapHeader.events->objectEvents[i].y;
+            gSaveBlock1Ptr->objectEventTemplates[j].elevation = localId;
+            gSaveBlock1Ptr->objectEventTemplates[j].trainerType = mapNum;
+            gSaveBlock1Ptr->objectEventTemplates[j].trainerRange_berryTreeId = mapGroup;
+            gSaveBlock1Ptr->objectEventTemplates[j].unk2 = 0xFF;
+            j++;
+        }
+        else
+        {
+            gSaveBlock1Ptr->objectEventTemplates[j] = gMapHeader.events->objectEvents[i];
+            j++;
+        }
+    }
+}
+
+static void LoadSaveblockObjEventScripts(void)
+{
+    int i;
+    const struct ObjectEventTemplate * src = gMapHeader.events->objectEvents;
+    struct ObjectEventTemplate * savObjTemplates = gSaveBlock1Ptr->objectEventTemplates;
+
+    for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++)
+    {
+        savObjTemplates[i].script = src[i].script;
+    }
+}
+
+void Overworld_SetMapObjTemplateCoords(u8 localId, s16 x, s16 y)
+{
+    int i;
+    struct ObjectEventTemplate * savObjTemplates = gSaveBlock1Ptr->objectEventTemplates;
+    for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++)
+    {
+        if (savObjTemplates[i].localId == localId)
+        {
+            savObjTemplates[i].x = x;
+            savObjTemplates[i].y = y;
+            break;
+        }
+    }
+}
+
+void Overworld_SetObjEventTemplateMovementType(u8 localId, u8 movementType)
+{
+    s32 i;
+
+    struct ObjectEventTemplate *savObjTemplates = gSaveBlock1Ptr->objectEventTemplates;
+    for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++)
+    {
+        struct ObjectEventTemplate *objectEventTemplate = &savObjTemplates[i];
+        if (objectEventTemplate->localId == localId)
+        {
+            objectEventTemplate->movementType = movementType;
+            return;
+        }
+    }
+}
+
+// Routines related to the map layout
+
+static void mapdata_load_assets_to_gpu_and_full_redraw(void)
+{
+    move_tilemap_camera_to_upper_left_corner();
+    copy_map_tileset1_tileset2_to_vram(gMapHeader.mapLayout);
+    apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout);
+    DrawWholeMapView();
+    InitTilesetAnimations();
+}
+
+static const struct MapLayout *GetMapLayout(void)
+{
+    u16 mapLayoutId = gSaveBlock1Ptr->mapLayoutId;
+    if (mapLayoutId)
+        return gMapLayouts[mapLayoutId - 1];
+    return NULL;
+}
+
+// Routines related to warps
+
+static const struct WarpData sDummyWarpData = {
+    .mapGroup = MAP_GROUP(UNDEFINED),
+    .mapNum = MAP_NUM(UNDEFINED),
+    .warpId = 0xFF,
+    .x = -1,
+    .y = -1
+};
+
+static void ApplyCurrentWarp(void)
+{
+    gLastUsedWarp = gSaveBlock1Ptr->location;
+    gSaveBlock1Ptr->location = sWarpDestination;
+    sFixedDiveWarp = sDummyWarpData;
+    sFixedHoleWarp = sDummyWarpData;
+}
+
+static void SetWarpData(struct WarpData *warp, s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y)
+{
+    warp->mapGroup = mapGroup;
+    warp->mapNum = mapNum;
+    warp->warpId = warpId;
+    warp->x = x;
+    warp->y = y;
+}
+
+static bool32 IsDummyWarp(struct WarpData *warp)
+{
+    if (warp->mapGroup != -1)
+        return FALSE;
+    else if (warp->mapNum != -1)
+        return FALSE;
+    else if (warp->warpId != -1)
+        return FALSE;
+    else if (warp->x != -1)
+        return FALSE;
+    else if (warp->y != -1)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+struct MapHeader const *const Overworld_GetMapHeaderByGroupAndId(u16 mapGroup, u16 mapNum)
+{
+    return gMapGroups[mapGroup][mapNum];
+}
+
+struct MapHeader const *const GetDestinationWarpMapHeader(void)
+{
+    return Overworld_GetMapHeaderByGroupAndId(sWarpDestination.mapGroup, sWarpDestination.mapNum);
+}
+
+static void LoadCurrentMapData(void)
+{
+    gMapHeader = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum);
+    gSaveBlock1Ptr->mapLayoutId = gMapHeader.mapLayoutId;
+    gMapHeader.mapLayout = GetMapLayout();
+}
+
+static void LoadSaveblockMapHeader(void)
+{
+    gMapHeader = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum);
+    gMapHeader.mapLayout = GetMapLayout();
+}
+
+static void SetPlayerCoordsFromWarp(void)
+{
+    if (gSaveBlock1Ptr->location.warpId >= 0 && gSaveBlock1Ptr->location.warpId < gMapHeader.events->warpCount)
+    {
+        gSaveBlock1Ptr->pos.x = gMapHeader.events->warps[gSaveBlock1Ptr->location.warpId].x;
+        gSaveBlock1Ptr->pos.y = gMapHeader.events->warps[gSaveBlock1Ptr->location.warpId].y;
+    }
+    else if (gSaveBlock1Ptr->location.x >= 0 && gSaveBlock1Ptr->location.y >= 0)
+    {
+        gSaveBlock1Ptr->pos.x = gSaveBlock1Ptr->location.x;
+        gSaveBlock1Ptr->pos.y = gSaveBlock1Ptr->location.y;
+    }
+    else
+    {
+        gSaveBlock1Ptr->pos.x = gMapHeader.mapLayout->width / 2;
+        gSaveBlock1Ptr->pos.y = gMapHeader.mapLayout->height / 2;
+    }
+}
+
+void WarpIntoMap(void)
+{
+    ApplyCurrentWarp();
+    LoadCurrentMapData();
+    SetPlayerCoordsFromWarp();
+}
+
+void SetWarpDestination(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y)
+{
+    SetWarpData(&sWarpDestination, mapGroup, mapNum, warpId, x, y);
+}
+
+void SetWarpDestinationToMapWarp(s8 mapGroup, s8 mapNum, s8 warpId)
+{
+    SetWarpDestination(mapGroup, mapNum, warpId, -1, -1);
+}
+
+void SetDynamicWarp(s32 unused, s8 mapGroup, s8 mapNum, s8 warpId)
+{
+    SetWarpData(&gSaveBlock1Ptr->dynamicWarp, mapGroup, mapNum, warpId, gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y);
+}
+
+void SetDynamicWarpWithCoords(s32 unused, s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y)
+{
+    SetWarpData(&gSaveBlock1Ptr->dynamicWarp, mapGroup, mapNum, warpId, x, y);
+}
+
+void SetWarpDestinationToDynamicWarp(u8 unusedWarpId)
+{
+    sWarpDestination = gSaveBlock1Ptr->dynamicWarp;
+}
+
+void SetWarpDestinationToHealLocation(u8 healLocationId)
+{
+    const struct HealLocation *warp = GetHealLocation(healLocationId);
+    if (warp)
+        SetWarpDestination(warp->group, warp->map, -1, warp->x, warp->y);
+}
+
+void SetWarpDestinationToLastHealLocation(void)
+{
+    sWarpDestination = gSaveBlock1Ptr->lastHealLocation;
+}
+
+static void Overworld_SetWhiteoutRespawnPoint(void)
+{
+    SetWhiteoutRespawnWarpAndHealerNpc(&sWarpDestination);
+}
+
+void SetLastHealLocationWarp(u8 healLocationId)
+{
+    const struct HealLocation *healLocation = GetHealLocation(healLocationId);
+    if (healLocation)
+        SetWarpData(&gSaveBlock1Ptr->lastHealLocation, healLocation->group, healLocation->map, -1, healLocation->x, healLocation->y);
+}
+
+void UpdateEscapeWarp(s16 x, s16 y)
+{
+    u8 currMapType = GetCurrentMapType();
+    u8 destMapType = GetMapTypeByGroupAndId(sWarpDestination.mapGroup, sWarpDestination.mapNum);
+    u8 delta;
+    if (IsMapTypeOutdoors(currMapType) && IsMapTypeOutdoors(destMapType) != TRUE && !(gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(VIRIDIAN_FOREST) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(VIRIDIAN_FOREST)))
+    {
+        delta = GetPlayerFacingDirection() != DIR_SOUTH;
+        SetEscapeWarp(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, x - 7, y - 7 + delta);
+    }
+}
+
+void SetEscapeWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y)
+{
+    SetWarpData(&gSaveBlock1Ptr->escapeWarp, mapGroup, mapNum, warpId, x, y);
+}
+
+void SetWarpDestinationToEscapeWarp(void)
+{
+    sWarpDestination = gSaveBlock1Ptr->escapeWarp;
+}
+
+void SetFixedDiveWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y)
+{
+    SetWarpData(&sFixedDiveWarp, mapGroup, mapNum, warpId, x, y);
+}
+
+static void SetWarpDestinationToDiveWarp(void)
+{
+    sWarpDestination = sFixedDiveWarp;
+}
+
+void SetFixedHoleWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y)
+{
+    SetWarpData(&sFixedHoleWarp, mapGroup, mapNum, warpId, x, y);
+}
+
+void SetWarpDestinationToFixedHoleWarp(s16 x, s16 y)
+{
+    if (IsDummyWarp(&sFixedHoleWarp) == TRUE)
+        sWarpDestination = gLastUsedWarp;
+    else
+        SetWarpDestination(sFixedHoleWarp.mapGroup, sFixedHoleWarp.mapNum, -1, x, y);
+}
+
+static void SetWarpDestinationToContinueGameWarp(void)
+{
+    sWarpDestination = gSaveBlock1Ptr->continueGameWarp;
+}
+
+static void SetContinueGameWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y)
+{
+    SetWarpData(&gSaveBlock1Ptr->continueGameWarp, mapGroup, mapNum, warpId, x, y);
+}
+
+void SetContinueGameWarpToHealLocation(u8 healLocationId)
+{
+    const struct HealLocation *warp = GetHealLocation(healLocationId);
+    if (warp)
+        SetWarpData(&gSaveBlock1Ptr->continueGameWarp, warp->group, warp->map, -1, warp->x, warp->y);
+}
+
+void SetContinueGameWarpToDynamicWarp(int unused)
+{
+    gSaveBlock1Ptr->continueGameWarp = gSaveBlock1Ptr->dynamicWarp;
+}
+
+static const struct MapConnection * GetMapConnection(u8 dir)
+{
+    s32 i;
+    s32 count = gMapHeader.connections->count;
+    const struct MapConnection *connection = gMapHeader.connections->connections;
+
+    if (connection == NULL)
+        return NULL;
+
+    for(i = 0; i < count; i++, connection++)
+        if (connection->direction == dir)
+            return connection;
+
+    return NULL;
+}
+
+static bool8 SetDiveWarp(u8 dir, u16 x, u16 y)
+{
+    const struct MapConnection *connection = GetMapConnection(dir);
+
+    if (connection != NULL)
+    {
+        SetWarpDestination(connection->mapGroup, connection->mapNum, -1, x, y);
+    }
+    else
+    {
+        RunOnDiveWarpMapScript();
+        if (IsDummyWarp(&sFixedDiveWarp))
+            return FALSE;
+        SetWarpDestinationToDiveWarp();
+    }
+    return TRUE;
+}
+
+bool8 SetDiveWarpEmerge(u16 x, u16 y)
+{
+    return SetDiveWarp(CONNECTION_EMERGE, x, y);
+}
+
+bool8 SetDiveWarpDive(u16 x, u16 y)
+{
+    return SetDiveWarp(CONNECTION_DIVE, x, y);
+}
+
+// Map loaders
+
+void LoadMapFromCameraTransition(u8 mapGroup, u8 mapNum)
+{
+    int paletteIndex;
+
+    SetWarpDestination(mapGroup, mapNum, -1, -1, -1);
+    Overworld_TryMapConnectionMusicTransition();
+    ApplyCurrentWarp();
+    LoadCurrentMapData();
+    sub_8054F68();
+    TrySetMapSaveWarpStatus();
+    ClearTempFieldEventData();
+    ResetCyclingRoadChallengeData();
+    RestartWildEncounterImmunitySteps();
+    TryUpdateRandomTrainerRematches(mapGroup, mapNum);
+    SetSav1WeatherFromCurrMapHeader();
+    ChooseAmbientCrySpecies();
+    SetDefaultFlashLevel();
+    Overworld_ClearSavedMusic();
+    RunOnTransitionMapScript();
+    TryRegenerateRenewableHiddenItems();
+    InitMap();
+    copy_map_tileset2_to_vram_2(gMapHeader.mapLayout);
+    apply_map_tileset2_palette(gMapHeader.mapLayout);
+    for (paletteIndex = 7; paletteIndex < 13; paletteIndex++)
+        ApplyWeatherGammaShiftToPal(paletteIndex);
+    InitSecondaryTilesetAnimation();
+    UpdateLocationHistoryForRoamer();
+    RoamerMove();
+    sub_8110920();
+    DoCurrentWeather();
+    ResetFieldTasksArgs();
+    RunOnResumeMapScript();
+    if (GetLastUsedWarpMapSectionId() != gMapHeader.regionMapSectionId)
+        ShowMapNamePopup(TRUE);
+}
+
+static void mli0_load_map(bool32 a1)
+{
+    bool8 isOutdoors;
+
+    LoadCurrentMapData();
+    sub_8054F68();
+    isOutdoors = IsMapTypeOutdoors(gMapHeader.mapType);
+
+    TrySetMapSaveWarpStatus();
+    ClearTempFieldEventData();
+    ResetCyclingRoadChallengeData();
+    RestartWildEncounterImmunitySteps();
+    TryUpdateRandomTrainerRematches(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum);
+    SetSav1WeatherFromCurrMapHeader();
+    ChooseAmbientCrySpecies();
+    if (isOutdoors)
+        FlagClear(FLAG_SYS_FLASH_ACTIVE);
+    SetDefaultFlashLevel();
+    Overworld_ClearSavedMusic();
+    RunOnTransitionMapScript();
+    TryRegenerateRenewableHiddenItems();
+    UpdateLocationHistoryForRoamer();
+    RoamerMoveToOtherLocationSet();
+    sub_8110920();
+    InitMap();
+}
+
+static void sub_80559A8(void)
+{
+    bool8 isOutdoors;
+
+    LoadCurrentMapData();
+    sub_8054F68();
+    isOutdoors = IsMapTypeOutdoors(gMapHeader.mapType);
+    TrySetMapSaveWarpStatus();
+    SetSav1WeatherFromCurrMapHeader();
+    ChooseAmbientCrySpecies();
+    SetDefaultFlashLevel();
+    sub_8110920();
+    sub_8111708();
+    LoadSaveblockMapHeader();
+    InitMap();
+}
+
+// Routines related to the initial player avatar state
+
+void ResetInitialPlayerAvatarState(void)
+{
+    sInitialPlayerAvatarState.direction = DIR_SOUTH;
+    sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT;
+    sInitialPlayerAvatarState.unk2 = FALSE;
+}
+
+static void SetInitialPlayerAvatarStateWithDirection(u8 dirn)
+{
+    sInitialPlayerAvatarState.direction = dirn;
+    sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT;
+    sInitialPlayerAvatarState.unk2 = TRUE;
+}
+
+void StoreInitialPlayerAvatarState(void)
+{
+    sInitialPlayerAvatarState.direction = GetPlayerFacingDirection();
+
+    if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE))
+        sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_MACH_BIKE;
+    else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_ACRO_BIKE))
+        sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ACRO_BIKE;
+    else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING))
+        sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_SURFING;
+    else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_UNDERWATER))
+        sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_UNDERWATER;
+    else
+        sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT;
+    sInitialPlayerAvatarState.unk2 = FALSE;
+}
+
+struct InitialPlayerAvatarState *GetInitialPlayerAvatarState(void)
+{
+    struct InitialPlayerAvatarState playerStruct;
+    u8 mapType = GetCurrentMapType();
+    u16 metatileBehavior = GetCenterScreenMetatileBehavior();
+    u8 transitionFlags = GetAdjustedInitialTransitionFlags(&sInitialPlayerAvatarState, metatileBehavior, mapType);
+    playerStruct.transitionFlags = transitionFlags;
+    playerStruct.direction = GetAdjustedInitialDirection(&sInitialPlayerAvatarState, transitionFlags, metatileBehavior, mapType);
+    playerStruct.unk2 = FALSE;
+    sInitialPlayerAvatarState = playerStruct;
+    return &sInitialPlayerAvatarState;
+}
+
+static u8 GetAdjustedInitialTransitionFlags(struct InitialPlayerAvatarState *playerStruct, u16 metatileBehavior, u8 mapType)
+{
+    if (mapType != MAP_TYPE_INDOOR && FlagGet(FLAG_SYS_CRUISE_MODE))
+        return PLAYER_AVATAR_FLAG_ON_FOOT;
+    else if (mapType == MAP_TYPE_UNDERWATER)
+        return PLAYER_AVATAR_FLAG_UNDERWATER;
+    else if (sub_8055B38(metatileBehavior) == TRUE)
+        return PLAYER_AVATAR_FLAG_ON_FOOT;
+    else if (MetatileBehavior_IsSurfable(metatileBehavior) == TRUE)
+        return PLAYER_AVATAR_FLAG_SURFING;
+    else if (Overworld_IsBikingAllowed() != TRUE)
+        return PLAYER_AVATAR_FLAG_ON_FOOT;
+    else if (playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_MACH_BIKE)
+        return PLAYER_AVATAR_FLAG_MACH_BIKE;
+    else if (playerStruct->transitionFlags != PLAYER_AVATAR_FLAG_ACRO_BIKE)
+        return PLAYER_AVATAR_FLAG_ON_FOOT;
+    else
+        return PLAYER_AVATAR_FLAG_ACRO_BIKE;
+}
+
+bool8 sub_8055B38(u16 metatileBehavior)
+{
+    if (MetatileBehavior_IsSurfable(metatileBehavior) != TRUE)
+        return FALSE;
+    if ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEAFOAM_ISLANDS_B3F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEAFOAM_ISLANDS_B3F)) || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEAFOAM_ISLANDS_B4F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEAFOAM_ISLANDS_B4F)))
+        return TRUE;
+    return FALSE;
+}
+
+static u8 GetAdjustedInitialDirection(struct InitialPlayerAvatarState *playerStruct, u8 transitionFlags, u16 metatileBehavior, u8 mapType)
+{
+    if (FlagGet(FLAG_SYS_CRUISE_MODE) && mapType == MAP_TYPE_OCEAN_ROUTE)
+        return DIR_EAST;
+    else if (MetatileBehavior_IsDeepSouthWarp(metatileBehavior) == TRUE)
+        return DIR_NORTH;
+    else if (MetatileBehavior_IsNonAnimDoor(metatileBehavior) == TRUE || MetatileBehavior_IsWarpDoor_2(metatileBehavior) == TRUE)
+        return DIR_SOUTH;
+    else if (MetatileBehavior_IsSouthArrowWarp(metatileBehavior) == TRUE)
+        return DIR_NORTH;
+    else if (MetatileBehavior_IsNorthArrowWarp(metatileBehavior) == TRUE)
+        return DIR_SOUTH;
+    else if (MetatileBehavior_IsWestArrowWarp(metatileBehavior) == TRUE)
+        return DIR_EAST;
+    else if (MetatileBehavior_IsEastArrowWarp(metatileBehavior) == TRUE)
+        return DIR_WEST;
+    else if (MetatileBehavior_IsUnknownWarp6C(metatileBehavior) == TRUE || MetatileBehavior_IsUnknownWarp6E(metatileBehavior) == TRUE)
+        return DIR_WEST;
+    else if (MetatileBehavior_IsUnknownWarp6D(metatileBehavior) == TRUE || MetatileBehavior_IsUnknownWarp6F(metatileBehavior) == TRUE)
+        return DIR_EAST;
+    else if ((playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_UNDERWATER  && transitionFlags == PLAYER_AVATAR_FLAG_SURFING)
+             || (playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_SURFING && transitionFlags == PLAYER_AVATAR_FLAG_UNDERWATER ))
+        return playerStruct->direction;
+    else if (MetatileBehavior_IsLadder(metatileBehavior) == TRUE)
+        return playerStruct->direction;
+    else if (playerStruct->unk2)
+        return playerStruct->direction;
+    else
+        return DIR_SOUTH;
+}
+
+static u16 GetCenterScreenMetatileBehavior(void)
+{
+    return MapGridGetMetatileBehaviorAt(gSaveBlock1Ptr->pos.x + 7, gSaveBlock1Ptr->pos.y + 7);
+}
+
+// Routines related to flash level and map perms
+
+bool32 Overworld_IsBikingAllowed(void)
+{
+    if (!gMapHeader.bikingAllowed)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+static void SetDefaultFlashLevel(void)
+{
+    if (!gMapHeader.cave)
+        gSaveBlock1Ptr->flashLevel = 0;
+    else if (FlagGet(FLAG_SYS_FLASH_ACTIVE))
+        gSaveBlock1Ptr->flashLevel = 0;
+    else
+        gSaveBlock1Ptr->flashLevel = gMaxFlashLevel;
+}
+
+void Overworld_SetFlashLevel(s32 flashLevel)
+{
+    if (flashLevel < 0 || flashLevel > gMaxFlashLevel)
+        flashLevel = 0;
+    gSaveBlock1Ptr->flashLevel = flashLevel;
+}
+
+u8 Overworld_GetFlashLevel(void)
+{
+    return gSaveBlock1Ptr->flashLevel;
+}
+
+void SetCurrentMapLayout(u16 mapLayoutId)
+{
+    gSaveBlock1Ptr->mapLayoutId = mapLayoutId;
+    gMapHeader.mapLayout = GetMapLayout();
+}
+
+void sub_8055D5C(struct WarpData * warp)
+{
+    sWarpDestination = *warp;
+}
+
+// Routines related to map music
+
+static u16 GetLocationMusic(struct WarpData * warp)
+{
+    return Overworld_GetMapHeaderByGroupAndId(warp->mapGroup, warp->mapNum)->music;
+}
+
+static u16 GetCurrLocationDefaultMusic(void)
+{
+    u16 music;
+    music = GetLocationMusic(&gSaveBlock1Ptr->location);
+    return music;
+}
+
+static u16 GetWarpDestinationMusic(void)
+{
+    u16 music = GetLocationMusic(&sWarpDestination);
+    return music;
+}
+
+void Overworld_ResetMapMusic(void)
+{
+    ResetMapMusic();
+}
+
+void Overworld_PlaySpecialMapMusic(void)
+{
+    u16 music;
+    s16 x, y;
+
+    if (gDisableMapMusicChangeOnMapLoad == 1)
+    {
+        StopMapMusic();
+        return;
+    }
+    if (gDisableMapMusicChangeOnMapLoad == 2)
+    {
+        return;
+    }
+    if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(POKEMON_LEAGUE_CHAMPIONS_ROOM) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(POKEMON_LEAGUE_CHAMPIONS_ROOM))
+    {
+        PlayerGetDestCoords(&x, &y);
+        if (y - 7 < 11 && gMPlayInfo_BGM.songHeader == &mus_win_gym)
+        {
+            FadeInBGM(4);
+            return;
+        }
+    }
+
+    music = GetCurrLocationDefaultMusic();
+
+    if (gSaveBlock1Ptr->savedMusic)
+        music = gSaveBlock1Ptr->savedMusic;
+    else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) &&sub_8056124(MUS_NAMINORI))
+        music = MUS_NAMINORI;
+
+    if (music != GetCurrentMapMusic())
+        PlayNewMapMusic(music);
+}
+
+void Overworld_SetSavedMusic(u16 songNum)
+{
+    gSaveBlock1Ptr->savedMusic = songNum;
+}
+
+void Overworld_ClearSavedMusic(void)
+{
+    gSaveBlock1Ptr->savedMusic = 0;
+}
+
+static void Overworld_TryMapConnectionMusicTransition(void)
+{
+    u16 newMusic;
+    u16 currentMusic;
+
+    if (gDisableMapMusicChangeOnMapLoad == 1)
+    {
+        StopMapMusic();
+        return;
+    }
+    if (gDisableMapMusicChangeOnMapLoad == 2)
+    {
+        return;
+    }
+
+    if (FlagGet(FLAG_DONT_TRANSITION_MUSIC) != TRUE)
+    {
+        newMusic = GetWarpDestinationMusic();
+        currentMusic = GetCurrentMapMusic();
+        if (currentMusic == MUS_NAMINORI)
+            return;
+        if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && sub_8056124(MUS_NAMINORI))
+            newMusic = MUS_NAMINORI;
+        if (newMusic != currentMusic)
+        {
+            if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE))
+                FadeOutAndFadeInNewMapMusic(newMusic, 4, 4);
+            else
+                FadeOutAndPlayNewMapMusic(newMusic, 8);
+        }
+    }
+}
+
+void Overworld_ChangeMusicToDefault(void)
+{
+    u16 currentMusic = GetCurrentMapMusic();
+    if (currentMusic != GetCurrLocationDefaultMusic())
+        FadeOutAndPlayNewMapMusic(GetCurrLocationDefaultMusic(), 8);
+}
+
+void Overworld_ChangeMusicTo(u16 newMusic)
+{
+    u16 currentMusic = GetCurrentMapMusic();
+    if (currentMusic != newMusic)
+        FadeOutAndPlayNewMapMusic(newMusic, 8);
+}
+
+static u8 GetMapMusicFadeoutSpeed(void)
+{
+    const struct MapHeader *mapHeader = GetDestinationWarpMapHeader();
+    if (IsMapTypeIndoors(mapHeader->mapType) == TRUE)
+        return 2;
+    else
+        return 4;
+}
+
+void TryFadeOutOldMapMusic(void)
+{
+    u16 warpMusic = GetWarpDestinationMusic();
+    if (FlagGet(FLAG_DONT_TRANSITION_MUSIC) != TRUE && warpMusic != GetCurrentMapMusic())
+    {
+        FadeOutMapMusic(GetMapMusicFadeoutSpeed());
+    }
+}
+
+bool8 BGMusicStopped(void)
+{
+    return IsNotWaitingForBGMStop();
+}
+
+void Overworld_FadeOutMapMusic(void)
+{
+    FadeOutMapMusic(4);
+}
+
+static void PlayAmbientCry(void)
+{
+    s16 x, y;
+    s8 pan;
+    s8 volume;
+
+    PlayerGetDestCoords(&x, &y);
+    if (sIsAmbientCryWaterMon == TRUE
+        && !MetatileBehavior_IsSurfable(MapGridGetMetatileBehaviorAt(x, y)))
+        return;
+    pan = (Random() % 88) + 212;
+    volume = (Random() % 30) + 50;
+
+    if (gDisableMapMusicChangeOnMapLoad == 1)
+    {
+        StopMapMusic();
+        return;
+    }
+    if (gDisableMapMusicChangeOnMapLoad == 2)
+    {
+        return;
+    }
+
+    PlayCry2(sAmbientCrySpecies, pan, volume, 1);
+}
+
+void UpdateAmbientCry(s16 *state, u16 *delayCounter)
+{
+    u8 i, monsCount, divBy;
+
+    switch (*state)
+    {
+    case 0:
+        if (sAmbientCrySpecies == SPECIES_NONE)
+            *state = 4;
+        else
+            *state = 1;
+        break;
+    case 1:
+        *delayCounter = (Random() % 2400) + 1200;
+        *state = 3;
+        break;
+    case 2:
+        *delayCounter = (Random() % 1200) + 1200;
+        *state = 3;
+        break;
+    case 3:
+        (*delayCounter)--;
+        if (*delayCounter == 0)
+        {
+            PlayAmbientCry();
+            *state = 2;
+        }
+        break;
+    case 4:
+        break;
+    }
+}
+
+static void ChooseAmbientCrySpecies(void)
+{
+    sAmbientCrySpecies = GetLocalWildMon(&sIsAmbientCryWaterMon);
+}
+
+bool32 sub_8056124(u16 music)
+{
+    if (music == MUS_CYCLING || music == MUS_NAMINORI)
+    {
+        if (gMapHeader.regionMapSectionId == MAPSEC_KANTO_VICTORY_ROAD || gMapHeader.regionMapSectionId == MAPSEC_ROUTE_23 || gMapHeader.regionMapSectionId == MAPSEC_INDIGO_PLATEAU)
+            return FALSE;
+    }
+    return TRUE;
+}
+
+u8 GetMapTypeByGroupAndId(s8 mapGroup, s8 mapNum)
+{
+    return Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum)->mapType;
+}
+
+static u8 GetMapTypeByWarpData(struct WarpData *warp)
+{
+    return GetMapTypeByGroupAndId(warp->mapGroup, warp->mapNum);
+}
+
+u8 GetCurrentMapType(void)
+{
+    return GetMapTypeByWarpData(&gSaveBlock1Ptr->location);
+}
+
+u8 GetLastUsedWarpMapType(void)
+{
+    return GetMapTypeByWarpData(&gLastUsedWarp);
+}
+
+u8 GetLastUsedWarpMapSectionId(void)
+{
+    return Overworld_GetMapHeaderByGroupAndId(gLastUsedWarp.mapGroup, gLastUsedWarp.mapNum)->regionMapSectionId;
+}
+
+bool8 IsMapTypeOutdoors(u8 mapType)
+{
+    if (mapType == MAP_TYPE_ROUTE
+        || mapType == MAP_TYPE_TOWN
+        || mapType == MAP_TYPE_UNDERWATER
+        || mapType == MAP_TYPE_CITY
+        || mapType == MAP_TYPE_OCEAN_ROUTE)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool8 Overworld_MapTypeAllowsTeleportAndFly(u8 mapType)
+{
+    if (mapType == MAP_TYPE_ROUTE
+        || mapType == MAP_TYPE_TOWN
+        || mapType == MAP_TYPE_OCEAN_ROUTE
+        || mapType == MAP_TYPE_CITY)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool8 IsMapTypeIndoors(u8 mapType)
+{
+    if (mapType == MAP_TYPE_INDOOR
+        || mapType == MAP_TYPE_SECRET_BASE)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static u8 GetSavedWarpRegionMapSectionId(void)
+{
+    return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->dynamicWarp.mapGroup, gSaveBlock1Ptr->dynamicWarp.mapNum)->regionMapSectionId;
+}
+
+u8 GetCurrentRegionMapSectionId(void)
+{
+    return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)->regionMapSectionId;
+}
+
+u8 GetCurrentMapBattleScene(void)
+{
+    return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)->battleType;
+}
+
+static const int sUnusedData[] = {
+    1200,
+    3600,
+    1200,
+    2400,
+      50,
+      80,
+     -44,
+      44
+};
+
+const struct UCoords32 gDirectionToVectors[] = {
+    { 0u,  0u},
+    { 0u,  1u},
+    { 0u, -1u},
+    {-1u,  0u},
+    { 1u,  0u},
+    {-1u,  1u},
+    { 1u,  1u},
+    {-1u, -1u},
+    { 1u, -1u},
+};
+
+static const struct BgTemplate sOverworldBgTemplates[] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0x000
+    }, {
+        .bg = 1,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 29,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0x000
+    }, {
+        .bg = 2,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 28,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0x000
+    }, {
+        .bg = 3,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0x000
+    }
+};
+
+static void InitOverworldBgs(void)
+{
+    MoveSaveBlocks_ResetHeap_();
+    sub_8056E80();
+    ResetBgsAndClearDma3BusyFlags(FALSE);
+    InitBgsFromTemplates(0, sOverworldBgTemplates, NELEMS(sOverworldBgTemplates));
+    SetBgAttribute(1, BG_ATTR_MOSAIC, TRUE);
+    SetBgAttribute(2, BG_ATTR_MOSAIC, TRUE);
+    SetBgAttribute(3, BG_ATTR_MOSAIC, TRUE);
+    gBGTilemapBuffers2 = AllocZeroed(BG_SCREEN_SIZE);
+    gBGTilemapBuffers1 = AllocZeroed(BG_SCREEN_SIZE);
+    gBGTilemapBuffers3 = AllocZeroed(BG_SCREEN_SIZE);
+    SetBgTilemapBuffer(1, gBGTilemapBuffers2);
+    SetBgTilemapBuffer(2, gBGTilemapBuffers1);
+    SetBgTilemapBuffer(3, gBGTilemapBuffers3);
+    InitStandardTextBoxWindows();
+    ResetBg0();
+    sub_8069348();
+}
+
+static void InitOverworldBgs_NoResetHeap(void)
+{
+    ResetBgsAndClearDma3BusyFlags(FALSE);
+    InitBgsFromTemplates(0, sOverworldBgTemplates, NELEMS(sOverworldBgTemplates));
+    SetBgAttribute(1, BG_ATTR_MOSAIC, TRUE);
+    SetBgAttribute(2, BG_ATTR_MOSAIC, TRUE);
+    SetBgAttribute(3, BG_ATTR_MOSAIC, TRUE);
+    gBGTilemapBuffers2 = AllocZeroed(BG_SCREEN_SIZE);
+    gBGTilemapBuffers1 = AllocZeroed(BG_SCREEN_SIZE);
+    gBGTilemapBuffers3 = AllocZeroed(BG_SCREEN_SIZE);
+    SetBgTilemapBuffer(1, gBGTilemapBuffers2);
+    SetBgTilemapBuffer(2, gBGTilemapBuffers1);
+    SetBgTilemapBuffer(3, gBGTilemapBuffers3);
+    InitStandardTextBoxWindows();
+    ResetBg0();
+    sub_8069348();
+}
+
+void CleanupOverworldWindowsAndTilemaps(void)
+{
+    FreeAllOverworldWindowBuffers();
+    Free(gBGTilemapBuffers3);
+    Free(gBGTilemapBuffers1);
+    Free(gBGTilemapBuffers2);
+}
+
+static void ResetSafariZoneFlag_(void)
+{
+    ResetSafariZoneFlag();
+}
+
+bool32 IsUpdateLinkStateCBActive(void)
+{
+    if (gMain.callback1 == CB1_UpdateLinkState)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static void DoCB1_Overworld(u16 newKeys, u16 heldKeys)
+{
+    struct FieldInput fieldInput;
+
+    sub_8112B3C();
+    sub_805BEB8();
+    FieldClearPlayerInput(&fieldInput);
+    FieldGetPlayerInput(&fieldInput, newKeys, heldKeys);
+    FieldInput_HandleCancelSignpost(&fieldInput);
+    if (!ScriptContext2_IsEnabled())
+    {
+        if (ProcessPlayerFieldInput(&fieldInput) == TRUE)
+        {
+            if (gUnknown_3005E88 == 2)
+                sub_81127F8(&gInputToStoreInQuestLogMaybe);
+            ScriptContext2_Enable();
+            DismissMapNamePopup();
+        }
+        else
+        {
+            player_step(fieldInput.dpadDirection, newKeys, heldKeys);
+        }
+    }
+    RunQuestLogCB();
+}
+
+static void DoCB1_Overworld_QuestLogPlayback(void)
+{
+    struct FieldInput fieldInput;
+
+    sub_8112B3C();
+    sub_805BEB8();
+    sub_8111C68();
+    FieldClearPlayerInput(&fieldInput);
+    fieldInput = gUnknown_3005E90;
+    FieldInput_HandleCancelSignpost(&fieldInput);
+    if (!ScriptContext2_IsEnabled())
+    {
+        if (ProcessPlayerFieldInput(&fieldInput) == TRUE)
+        {
+            ScriptContext2_Enable();
+            DismissMapNamePopup();
+        }
+        else
+        {
+            RunQuestLogCB();
+        }
+    }
+    else if (sub_8111CD0() == TRUE)
+    {
+        RunQuestLogCB();
+    }
+    FieldClearPlayerInput(&gUnknown_3005E90);
+}
+
+void CB1_Overworld(void)
+{
+    if (gMain.callback2 == CB2_Overworld)
+    {
+        if (sub_8112CAC() == TRUE || gQuestLogState == QL_STATE_2)
+            DoCB1_Overworld_QuestLogPlayback();
+        else
+            DoCB1_Overworld(gMain.newKeys, gMain.heldKeys);
+    }
+}
+
+static void OverworldBasic(void)
+{
+    ScriptContext2_RunScript();
+    RunTasks();
+    AnimateSprites();
+    CameraUpdate();
+    sub_8115798();
+    UpdateCameraPanning();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+    UpdateTilesetAnimations();
+    DoScheduledBgTilemapCopiesToVram();
+}
+
+// This CB2 is used when starting
+void CB2_OverworldBasic(void)
+{
+    OverworldBasic();
+}
+
+static void CB2_Overworld(void)
+{
+    bool32 fading = !!gPaletteFade.active;
+    if (fading)
+        SetVBlankCallback(NULL);
+    OverworldBasic();
+    if (fading)
+        SetFieldVBlankCallback();
+}
+
+void SetMainCallback1(MainCallback cb)
+{
+    gMain.callback1 = cb;
+}
+
+static bool8 map_post_load_hook_exec(void)
+{
+    if (gFieldCallback2)
+    {
+        if (!gFieldCallback2())
+        {
+            return FALSE;
+        }
+        else
+        {
+            gFieldCallback2 = NULL;
+            gFieldCallback = NULL;
+        }
+    }
+    else
+    {
+        if (gFieldCallback)
+            gFieldCallback();
+        else
+            FieldCB_DefaultWarpExit();
+
+        gFieldCallback = NULL;
+    }
+
+    return TRUE;
+}
+
+void CB2_NewGame(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    StopMapMusic();
+    ResetSafariZoneFlag_();
+    NewGameInitData();
+    ResetInitialPlayerAvatarState();
+    PlayTimeCounter_Start();
+    ScriptContext1_Init();
+    ScriptContext2_Disable();
+    gFieldCallback = FieldCB_WarpExitFadeFromBlack;
+    gFieldCallback2 = NULL;
+    do_load_map_stuff_loop(&gMain.state);
+    SetFieldVBlankCallback();
+    SetMainCallback1(CB1_Overworld);
+    SetMainCallback2(CB2_Overworld);
+}
+
+void CB2_WhiteOut(void)
+{
+    u8 val;
+
+    if (++gMain.state >= 120)
+    {
+        FieldClearVBlankHBlankCallbacks();
+        StopMapMusic();
+        ResetSafariZoneFlag_();
+        DoWhiteOut();
+        SetInitialPlayerAvatarStateWithDirection(DIR_NORTH);
+        ScriptContext1_Init();
+        ScriptContext2_Disable();
+        gFieldCallback = FieldCB_RushInjuredPokemonToCenter;
+        val = 0;
+        do_load_map_stuff_loop(&val);
+        sub_8112364();
+        SetFieldVBlankCallback();
+        SetMainCallback1(CB1_Overworld);
+        SetMainCallback2(CB2_Overworld);
+    }
+}
+
+void CB2_LoadMap(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    ScriptContext1_Init();
+    ScriptContext2_Disable();
+    SetMainCallback1(NULL);
+    SetMainCallback2(CB2_DoChangeMap);
+    gMain.savedCallback = CB2_LoadMap2;
+}
+
+static void CB2_LoadMap2(void)
+{
+    do_load_map_stuff_loop(&gMain.state);
+    if (sub_8113748() == TRUE)
+    {
+        sub_81119C8();
+    }
+    else
+    {
+        SetFieldVBlankCallback();
+        SetMainCallback1(CB1_Overworld);
+        SetMainCallback2(CB2_Overworld);
+    }
+}
+
+void CB2_ReturnToFieldCableClub(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    gFieldCallback = FieldCB_ReturnToFieldWirelessLink;
+    SetMainCallback2(c2_80567AC);
+}
+
+static void c2_80567AC(void)
+{
+    if (map_loading_iteration_3(&gMain.state))
+    {
+        SetFieldVBlankCallback();
+        SetMainCallback1(CB1_UpdateLinkState);
+        ResetAllMultiplayerState();
+        SetMainCallback2(CB2_Overworld);
+    }
+}
+
+void CB2_ReturnToField(void)
+{
+    if (IsUpdateLinkStateCBActive() == TRUE)
+    {
+        SetMainCallback2(CB2_ReturnToFieldLink);
+    }
+    else
+    {
+        FieldClearVBlankHBlankCallbacks();
+        SetMainCallback2(CB2_ReturnToFieldLocal);
+    }
+}
+
+static void CB2_ReturnToFieldLocal(void)
+{
+    if (sub_8056CD8(&gMain.state))
+    {
+        SetFieldVBlankCallback();
+        SetMainCallback2(CB2_Overworld);
+    }
+}
+
+static void CB2_ReturnToFieldLink(void)
+{
+    if (!sub_8058244() && map_loading_iteration_2_link(&gMain.state))
+        SetMainCallback2(CB2_Overworld);
+}
+
+void CB2_ReturnToFieldFromMultiplayer(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    StopMapMusic();
+    SetMainCallback1(CB1_UpdateLinkState);
+    ResetAllMultiplayerState();
+
+    if (gWirelessCommType != 0)
+        gFieldCallback = FieldCB_ReturnToFieldWirelessLink;
+    else
+        gFieldCallback = FieldCB_ReturnToFieldCableLink;
+
+    ScriptContext1_Init();
+    ScriptContext2_Disable();
+    CB2_ReturnToField();
+}
+
+void CB2_ReturnToFieldWithOpenMenu(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    gFieldCallback2 = FieldCB_ReturnToFieldOpenStartMenu;
+    CB2_ReturnToField();
+}
+
+void CB2_ReturnToFieldContinueScript(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    gFieldCallback = FieldCB_ContinueScript;
+    CB2_ReturnToField();
+}
+
+void CB2_ReturnToFieldContinueScriptPlayMapMusic(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    gFieldCallback = FieldCB_ContinueScriptHandleMusic;
+    CB2_ReturnToField();
+}
+
+void sub_80568FC(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    gFieldCallback = FieldCB_WarpExitFadeFromBlack;
+    CB2_ReturnToField();
+}
+
+static void sub_8056918(void)
+{
+    if (SHOW_MAP_NAME_ENABLED)
+        ShowMapNamePopup(FALSE);
+    FieldCB_WarpExitFadeFromBlack();
+}
+
+void CB2_ContinueSavedGame(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    StopMapMusic();
+    ResetSafariZoneFlag_();
+    LoadSaveblockMapHeader();
+    LoadSaveblockObjEventScripts();
+    UnfreezeObjectEvents();
+    sub_8054E40();
+    InitMapFromSavedGame();
+    PlayTimeCounter_Start();
+    ScriptContext1_Init();
+    ScriptContext2_Disable();
+    gFieldCallback2 = NULL;
+    gUnknown_2031DE0 = TRUE;
+    if (UseContinueGameWarp() == TRUE)
+    {
+        ClearContinueGameWarpStatus();
+        SetWarpDestinationToContinueGameWarp();
+        WarpIntoMap();
+        SetMainCallback2(CB2_LoadMap);
+    }
+    else
+    {
+        gFieldCallback = sub_8056918;
+        SetMainCallback1(CB1_Overworld);
+        CB2_ReturnToField();
+    }
+}
+
+static void FieldClearVBlankHBlankCallbacks(void)
+{
+    if (UsedPokemonCenterWarp() == TRUE)
+        CloseLink();
+
+    if (gWirelessCommType != 0)
+    {
+        EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_VCOUNT | INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL);
+        DisableInterrupts(INTR_FLAG_HBLANK);
+    }
+    else
+    {
+        DisableInterrupts(INTR_FLAG_HBLANK);
+        EnableInterrupts(INTR_FLAG_VBLANK);
+    }
+
+    SetVBlankCallback(NULL);
+    SetHBlankCallback(NULL);
+}
+
+static void SetFieldVBlankCallback(void)
+{
+    SetVBlankCallback(VBlankCB_Field);
+}
+
+static void VBlankCB_Field(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    ScanlineEffect_InitHBlankDmaTransfer();
+    FieldUpdateBgTilemapScroll();
+    TransferPlttBuffer();
+    TransferTilesetAnimsBuffer();
+}
+
+static void InitCurrentFlashLevelScanlineEffect(void)
+{
+    u8 flashLevel = Overworld_GetFlashLevel();
+    if (flashLevel != 0)
+    {
+        WriteFlashScanlineEffectBuffer(flashLevel);
+        ScanlineEffect_SetParams((struct ScanlineEffectParams){
+            .dmaDest = &REG_WIN0H,
+            .dmaControl = (2 >> 1) | ((DMA_16BIT | DMA_DEST_RELOAD | DMA_SRC_INC | DMA_REPEAT | DMA_START_HBLANK | DMA_ENABLE) << 16),
+            .initState = 1,
+            .unused9 = 0
+        });
+    }
+}
+
+static bool32 map_loading_iteration_3(u8 *state)
+{
+    switch (*state)
+    {
+    case 0:
+        InitOverworldBgs();
+        ScriptContext1_Init();
+        ScriptContext2_Disable();
+        (*state)++;
+        break;
+    case 1:
+        mli0_load_map(TRUE);
+        (*state)++;
+        break;
+    case 2:
+        sub_8057024(TRUE);
+        (*state)++;
+        break;
+    case 3:
+        sub_8057178();
+        sub_8057074();
+        sub_80571A8();
+        SetCameraToTrackGuestPlayer();
+        SetHelpContextForMap();
+        (*state)++;
+        break;
+    case 4:
+        InitCurrentFlashLevelScanlineEffect();
+        InitOverworldGraphicsRegisters();
+        (*state)++;
+        break;
+    case 5:
+        move_tilemap_camera_to_upper_left_corner();
+        (*state)++;
+        break;
+    case 6:
+        copy_map_tileset1_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 7:
+        copy_map_tileset2_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 8:
+        if (FreeTempTileDataBuffersIfPossible() != TRUE)
+        {
+            apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout);
+            (*state)++;
+        }
+        break;
+    case 9:
+        DrawWholeMapView();
+        (*state)++;
+        break;
+    case 10:
+        InitTilesetAnimations();
+        (*state)++;
+        break;
+    case 11:
+        if (gWirelessCommType != 0)
+        {
+            LoadWirelessStatusIndicatorSpriteGfx();
+            CreateWirelessStatusIndicatorSprite(0, 0);
+        }
+        (*state)++;
+        break;
+    case 12:
+        if (map_post_load_hook_exec())
+            (*state)++;
+        break;
+    case 13:
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static bool32 load_map_stuff(u8 *state, bool32 a1)
+{
+    switch (*state)
+    {
+    case 0:
+        InitOverworldBgs();
+        FieldClearVBlankHBlankCallbacks();
+        mli0_load_map(a1);
+        (*state)++;
+        break;
+    case 1:
+        sub_8111F14();
+        (*state)++;
+        break;
+    case 2:
+        sub_8057024(a1);
+        (*state)++;
+        break;
+    case 3:
+        if (sub_8113748() == TRUE)
+            return TRUE;
+        (*state)++;
+        break;
+    case 4:
+        mli4_mapscripts_and_other();
+        sub_8057114();
+        if (gQuestLogState != QL_STATE_2)
+        {
+            sub_80CC534();
+            sub_80CC59C();
+        }
+        SetHelpContextForMap();
+        (*state)++;
+        break;
+    case 5:
+        InitCurrentFlashLevelScanlineEffect();
+        InitOverworldGraphicsRegisters();
+        (*state)++;
+        break;
+    case 6:
+        move_tilemap_camera_to_upper_left_corner();
+        (*state)++;
+        break;
+    case 7:
+        copy_map_tileset1_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 8:
+        copy_map_tileset2_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 9:
+        if (FreeTempTileDataBuffersIfPossible() != TRUE)
+        {
+            apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout);
+            (*state)++;
+        }
+        break;
+    case 10:
+        DrawWholeMapView();
+        (*state)++;
+        break;
+    case 11:
+        InitTilesetAnimations();
+        (*state)++;
+        break;
+    case 12:
+        if (GetLastUsedWarpMapSectionId() != gMapHeader.regionMapSectionId && MapHasPreviewScreen_HandleQLState2(gMapHeader.regionMapSectionId, MPS_TYPE_FOREST) == TRUE)
+        {
+            MapPreview_LoadGfx(gMapHeader.regionMapSectionId);
+            MapPreview_StartForestTransition(gMapHeader.regionMapSectionId);
+        }
+        else if (SHOW_MAP_NAME_ENABLED)
+        {
+            ShowMapNamePopup(FALSE);
+        }
+        (*state)++;
+        break;
+    case 13:
+        if (map_post_load_hook_exec())
+            (*state)++;
+        break;
+    case 14:
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool32 sub_8056CD8(u8 *state)
+{
+    switch (*state)
+    {
+    case 0:
+        InitOverworldBgs();
+        sub_8111F14();
+        sub_8057024(FALSE);
+        sub_8057100();
+        sub_8057114();
+        (*state)++;
+        break;
+    case 1:
+        (*state)++;
+        break;
+    case 2:
+        sub_8056F08();
+        SetHelpContextForMap();
+        (*state)++;
+        break;
+    case 3:
+        if (map_post_load_hook_exec())
+            (*state)++;
+        break;
+    case 4:
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool32 map_loading_iteration_2_link(u8 *state)
+{
+    switch (*state)
+    {
+    case 0:
+        InitOverworldBgs();
+        FieldClearVBlankHBlankCallbacks();
+        (*state)++;
+        break;
+    case 1:
+        sub_8111F14();
+        sub_8057024(1);
+        (*state)++;
+        break;
+    case 2:
+        CreateLinkPlayerSprites();
+        sub_8057100();
+        SetCameraToTrackGuestPlayer_2();
+        SetHelpContextForMap();
+        (*state)++;
+        break;
+    case 3:
+        InitCurrentFlashLevelScanlineEffect();
+        InitOverworldGraphicsRegisters();
+        (*state)++;
+        break;
+    case 4:
+        move_tilemap_camera_to_upper_left_corner();
+        (*state)++;
+        break;
+    case 5:
+        copy_map_tileset1_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 6:
+        copy_map_tileset2_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 7:
+        if (FreeTempTileDataBuffersIfPossible() != TRUE)
+        {
+            apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout);
+            (*state)++;
+        }
+        break;
+    case 8:
+        DrawWholeMapView();
+        (*state)++;
+        break;
+    case 9:
+        InitTilesetAnimations();
+        (*state)++;
+        break;
+    case 10:
+        (*state)++;
+        break;
+    case 11:
+        if (gWirelessCommType != 0)
+        {
+            LoadWirelessStatusIndicatorSpriteGfx();
+            CreateWirelessStatusIndicatorSprite(0, 0);
+        }
+        (*state)++;
+        break;
+    case 12:
+        if (map_post_load_hook_exec())
+            (*state)++;
+        break;
+    case 13:
+        SetFieldVBlankCallback();
+        (*state)++;
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static void do_load_map_stuff_loop(u8 *state)
+{
+    while (!load_map_stuff(state, FALSE))
+        ;
+}
+
+static void MoveSaveBlocks_ResetHeap_(void)
+{
+    MoveSaveBlocks_ResetHeap();
+}
+
+static void sub_8056E80(void)
+{
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    ScanlineEffect_Stop();
+
+    DmaClear16(3, PLTT + 2, PLTT_SIZE - 2);
+    DmaFillLarge16(3, 0, (void *)(VRAM + 0x0), 0x18000, 0x1000);
+    ResetOamRange(0, 128);
+    LoadOam();
+}
+
+static void sub_8056F08(void)
+{
+    InitCurrentFlashLevelScanlineEffect();
+    InitOverworldGraphicsRegisters();
+    mapdata_load_assets_to_gpu_and_full_redraw();
+}
+
+static void InitOverworldGraphicsRegisters(void)
+{
+    ClearScheduledBgCopiesToVram();
+    ResetTempTileDataBuffers();
+    SetGpuReg(REG_OFFSET_MOSAIC, 0);
+    SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ);
+    SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WINOBJ_BG0);
+    SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0, 255));
+    SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(0, 255));
+    SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(255, 255));
+    SetGpuReg(REG_OFFSET_WIN1V, WIN_RANGE(255, 255));
+    SetGpuReg(REG_OFFSET_BLDCNT, gOverworldBackgroundLayerFlags[1] | gOverworldBackgroundLayerFlags[2] | gOverworldBackgroundLayerFlags[3]
+                                 | BLDCNT_TGT2_OBJ | BLDCNT_EFFECT_BLEND);
+    SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(13, 7));
+    ScheduleBgCopyTilemapToVram(1);
+    ScheduleBgCopyTilemapToVram(2);
+    ScheduleBgCopyTilemapToVram(3);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | 0x20 | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON | DISPCNT_WIN1_ON);
+    ShowBg(0);
+    ShowBg(1);
+    ShowBg(2);
+    ShowBg(3);
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(2, 0, 0);
+    ChangeBgY(2, 0, 0);
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+}
+
+static void sub_8057024(u32 a1)
+{
+    ResetTasks();
+    ResetSpriteData();
+    ResetPaletteFade();
+    ScanlineEffect_Clear();
+    ResetAllPicSprites();
+    ResetCameraUpdateInfo();
+    InstallCameraPanAheadCallback();
+    if (!a1)
+        InitObjectEventPalettes(0);
+    else
+        InitObjectEventPalettes(1);
+
+    FieldEffectActiveListClear();
+    StartWeather();
+    ResumePausedWeather();
+    if (!a1)
+        SetUpFieldTasks();
+    RunOnResumeMapScript();
+}
+
+static void sub_8057074(void)
+{
+    gTotalCameraPixelOffsetX = 0;
+    gTotalCameraPixelOffsetY = 0;
+    ResetObjectEvents();
+    TrySpawnObjectEvents(0, 0);
+    TryRunOnWarpIntoMapScript();
+}
+
+static void mli4_mapscripts_and_other(void)
+{
+    s16 x, y;
+    struct InitialPlayerAvatarState *player;
+
+    gTotalCameraPixelOffsetX = 0;
+    gTotalCameraPixelOffsetY = 0;
+    ResetObjectEvents();
+    GetCameraFocusCoords(&x, &y);
+    player = GetInitialPlayerAvatarState();
+    InitPlayerAvatar(x, y, player->direction, gSaveBlock2Ptr->playerGender);
+    SetPlayerAvatarTransitionFlags(player->transitionFlags);
+    ResetInitialPlayerAvatarState();
+    TrySpawnObjectEvents(0, 0);
+    TryRunOnWarpIntoMapScript();
+}
+
+static void sub_8057100(void)
+{
+    sub_805EDF0(0, 0);
+    RunOnReturnToFieldMapScript();
+}
+
+static void sub_8057114(void)
+{
+    gObjectEvents[gPlayerAvatar.objectEventId].trackedByCamera = TRUE;
+    InitCameraUpdateCallback(gPlayerAvatar.spriteId);
+}
+
+static void SetCameraToTrackGuestPlayer(void)
+{
+    InitCameraUpdateCallback(GetSpriteForLinkedPlayer(gLocalLinkPlayerId));
+}
+
+// Duplicate function.
+static void SetCameraToTrackGuestPlayer_2(void)
+{
+    InitCameraUpdateCallback(GetSpriteForLinkedPlayer(gLocalLinkPlayerId));
+}
+
+static void sub_8057178(void)
+{
+    u16 x, y;
+    GetCameraFocusCoords(&x, &y);
+
+    // This is a hack of some kind; it's undone in sub_8086B14, which is called
+    // soon after this function.
+    SetCameraFocusCoords(x + gLocalLinkPlayerId, y);
+}
+
+static void sub_80571A8(void)
+{
+    u16 i;
+    u16 x, y;
+
+    GetCameraFocusCoords(&x, &y);
+    x -= gLocalLinkPlayerId;
+
+    for (i = 0; i < gFieldLinkPlayerCount; i++)
+    {
+        SpawnLinkPlayerObjectEvent(i, i + x, y, gLinkPlayers[i].gender);
+        CreateLinkPlayerSprite(i, gLinkPlayers[i].version);
+    }
+
+    ClearAllPlayerKeys();
+}
+
+static void CreateLinkPlayerSprites(void)
+{
+    u16 i;
+    for (i = 0; i < gFieldLinkPlayerCount; i++)
+        CreateLinkPlayerSprite(i, gLinkPlayers[i].version);
+}
+
+// Quest Log
+
+void sub_805726C(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    gUnknown_2036E28 = 1;
+    ScriptContext1_Init();
+    ScriptContext2_Disable();
+    SetMainCallback1(NULL);
+    SetMainCallback2(CB2_DoChangeMap);
+    gMain.savedCallback = sub_80572D8;
+}
+
+void sub_80572A8(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    gUnknown_2036E28 = 1;
+    LoadSaveblockMapHeader();
+    ScriptContext1_Init();
+    ScriptContext2_Disable();
+    SetMainCallback1(NULL);
+    SetMainCallback2(sub_80572D8);
+}
+
+static void sub_80572D8(void)
+{
+    sub_8057300(&gMain.state);
+    SetFieldVBlankCallback();
+    SetMainCallback1(CB1_Overworld);
+    SetMainCallback2(CB2_Overworld);
+}
+
+static void sub_8057300(u8 *state)
+{
+    while (!sub_8057314(state))
+        ;
+}
+
+static bool32 sub_8057314(u8 *state)
+{
+    switch (*state)
+    {
+    case 0:
+        InitOverworldBgs();
+        FieldClearVBlankHBlankCallbacks();
+        sub_8111F14();
+        sub_81113E4();
+        sub_8111438();
+        if (sub_8110AC8() == 2)
+        {
+            gUnknown_2031DE0 = FALSE;
+            mli0_load_map(FALSE);
+        }
+        else
+        {
+            gUnknown_2031DE0 = TRUE;
+            sub_80559A8();
+        }
+        (*state)++;
+        break;
+    case 1:
+        sub_8110FCC();
+        (*state)++;
+        break;
+    case 2:
+        sub_8057024(0);
+        (*state)++;
+        break;
+    case 3:
+        sub_8057100();
+        sub_8057114();
+        (*state)++;
+        break;
+    case 4:
+        InitCurrentFlashLevelScanlineEffect();
+        InitOverworldGraphicsRegisters();
+        (*state)++;
+        break;
+    case 5:
+        move_tilemap_camera_to_upper_left_corner();
+        (*state)++;
+        break;
+    case 6:
+        copy_map_tileset1_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 7:
+        copy_map_tileset2_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 8:
+        if (FreeTempTileDataBuffersIfPossible() != TRUE)
+        {
+            apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout);
+            (*state)++;
+        }
+        break;
+    case 9:
+        DrawWholeMapView();
+        (*state)++;
+        break;
+    case 10:
+        InitTilesetAnimations();
+        sub_815A540();
+        (*state)++;
+        break;
+    default:
+        if (map_post_load_hook_exec())
+            return TRUE;
+        break;
+    }
+    return FALSE;
+}
+
+void sub_8057430(void)
+{
+    FieldClearVBlankHBlankCallbacks();
+    StopMapMusic();
+    gUnknown_2036E28 = 3;
+    ResetSafariZoneFlag_();
+    LoadSaveblockMapHeader();
+    LoadSaveblockObjEventScripts();
+    UnfreezeObjectEvents();
+    sub_8054E40();
+    InitMapFromSavedGame();
+    PlayTimeCounter_Start();
+    ScriptContext1_Init();
+    gUnknown_2031DE0 = TRUE;
+    if (UseContinueGameWarp() == TRUE)
+    {
+        ClearContinueGameWarpStatus();
+        SetWarpDestinationToContinueGameWarp();
+        WarpIntoMap();
+        SetMainCallback2(CB2_LoadMap);
+    }
+    else
+    {
+        SetMainCallback1(CB1_Overworld);
+        CB2_ReturnToField();
+    }
+}
+
+// Credits
+
+void Overworld_CreditsMainCB(void)
+{
+    bool8 fading = !!gPaletteFade.active;
+    if (fading)
+        SetVBlankCallback(NULL);
+    RunTasks();
+    AnimateSprites();
+    sub_805ACF0();
+    UpdateCameraPanning();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+    UpdateTilesetAnimations();
+    DoScheduledBgTilemapCopiesToVram();
+    if (fading)
+        SetFieldVBlankCallback();
+}
+
+static bool8 FieldCB2_Credits_WaitFade(void)
+{
+    if (gPaletteFade.active)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool32 Overworld_DoScrollSceneForCredits(u8 *state_p, const struct CreditsOverworldCmd * script, u8 a2)
+{
+    sCreditsOverworld_Script = script;
+    gUnknown_2036E28 = a2;
+    return SetUpScrollSceneForCredits(state_p, 0);
+}
+
+static bool32 SetUpScrollSceneForCredits(u8 *state, u8 unused)
+{
+    struct WarpData warp;
+    switch (*state)
+    {
+    case 0:
+        sCreditsOverworld_CmdIndex = 0;
+        sCreditsOverworld_CmdLength = 0;
+        (*state)++;
+        return FALSE;
+    case 1:
+        warp.mapGroup = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2;
+        warp.mapNum = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4;
+        warp.warpId = -1;
+        sCreditsOverworld_CmdIndex++;
+        warp.x = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0;
+        warp.y = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2;
+        sWarpDestination = warp;
+        sCreditsOverworld_CmdLength = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4;
+        WarpIntoMap();
+        gPaletteFade.bufferTransferDisabled = TRUE;
+        ScriptContext1_Init();
+        ScriptContext2_Disable();
+        SetMainCallback1(NULL);
+        gFieldCallback2 = FieldCB2_Credits_WaitFade;
+        gMain.state = 0;
+        (*state)++;
+        return FALSE;
+    case 2:
+        if (MapLdr_Credits())
+        {
+            (*state)++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        gFieldCamera.callback = CameraCB_CreditsPan;
+        SetFieldVBlankCallback();
+        *state = 0;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool8 MapLdr_Credits(void)
+{
+    u8 *state = &gMain.state;
+    switch (*state)
+    {
+    case 0:
+        InitOverworldBgs_NoResetHeap();
+        mli0_load_map(FALSE);
+        (*state)++;
+        break;
+    case 1:
+        ScanlineEffect_Clear();
+        ResetAllPicSprites();
+        ResetCameraUpdateInfo();
+        InstallCameraPanAheadCallback();
+        FieldEffectActiveListClear();
+        StartWeather();
+        ResumePausedWeather();
+        SetUpFieldTasks();
+        RunOnResumeMapScript();
+        (*state)++;
+        break;
+    case 2:
+        InitCurrentFlashLevelScanlineEffect();
+        InitOverworldGraphicsRegisters();
+        (*state)++;
+        break;
+    case 3:
+        move_tilemap_camera_to_upper_left_corner();
+        (*state)++;
+        break;
+    case 4:
+        copy_map_tileset1_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 5:
+        copy_map_tileset2_to_vram(gMapHeader.mapLayout);
+        (*state)++;
+        break;
+    case 6:
+        if (FreeTempTileDataBuffersIfPossible() != TRUE)
+        {
+            apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout);
+            (*state)++;
+        }
+        break;
+    case 7:
+        DrawWholeMapView();
+        (*state)++;
+        break;
+    case 8:
+        InitTilesetAnimations();
+        gPaletteFade.bufferTransferDisabled = FALSE;
+        FadeSelectedPals(FADE_FROM_BLACK, 0, 0x3FFFFFFF);
+        (*state)++;
+        break;
+    default:
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static void CameraCB_CreditsPan(struct CameraObject * camera)
+{
+    if (sCreditsOverworld_CmdLength == 0)
+    {
+        sCreditsOverworld_CmdIndex++;
+        switch (sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0)
+        {
+        case CREDITSOVWLDCMD_FC:
+        case CREDITSOVWLDCMD_LOADMAP:
+            return;
+        case CREDITSOVWLDCMD_FF:
+            camera->movementSpeedX = 0;
+            camera->movementSpeedY = 0;
+            camera->callback = NULL;
+            CreateTask(Task_OvwldCredits_FadeOut, 0);
+            return;
+        case CREDITSOVWLDCMD_FB:
+            camera->movementSpeedX = 0;
+            camera->movementSpeedY = 0;
+            camera->callback = NULL;
+            break;
+        case CREDITSOVWLDCMD_END:
+            camera->movementSpeedX = 0;
+            camera->movementSpeedY = 0;
+            camera->callback = NULL;
+            return;
+        default:
+            sCreditsOverworld_CmdLength = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4;
+            camera->movementSpeedX = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0;
+            camera->movementSpeedY = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2;
+            break;
+        }
+    }
+    if (sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0 == 0xFF)
+    {
+        camera->movementSpeedX = 0;
+        camera->movementSpeedY = 0;
+    }
+    else
+        sCreditsOverworld_CmdLength--;
+}
+
+static void Task_OvwldCredits_FadeOut(u8 taskId)
+{
+    BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+    gTasks[taskId].func = Task_OvwldCredits_WaitFade;
+}
+
+static void Task_OvwldCredits_WaitFade(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        CleanupOverworldWindowsAndTilemaps();
+        SetMainCallback2(CB2_LoadMap);
+        DestroyTask(taskId);
+    }
+}
+
+// Link related
+
+static u8 (*const sLinkPlayerMovementModes[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8) = {
+    MovementEventModeCB_Normal, // MOVEMENT_MODE_FREE
+    MovementEventModeCB_Ignored, // MOVEMENT_MODE_FROZEN
+    MovementEventModeCB_Normal_2, // MOVEMENT_MODE_SCRIPTED
+};
+
+// These handlers return TRUE if the movement was scripted and successful, and FALSE otherwise.
+static bool8 (*const sLinkPlayerFacingHandlers[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8) = {
+    FacingHandler_DoNothing,
+    FacingHandler_DpadMovement,
+    FacingHandler_DpadMovement,
+    FacingHandler_DpadMovement,
+    FacingHandler_DpadMovement,
+    FacingHandler_DoNothing,
+    FacingHandler_DoNothing,
+    FacingHandler_ForcedFacingChange,
+    FacingHandler_ForcedFacingChange,
+    FacingHandler_ForcedFacingChange,
+    FacingHandler_ForcedFacingChange,
+};
+
+// These handlers are run after an attempted movement.
+static void (*const sMovementStatusHandler[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *) = {
+    // FALSE:
+    MovementStatusHandler_EnterFreeMode,
+    // TRUE:
+    MovementStatusHandler_TryAdvanceScript,
+};
+
+static void CB1_UpdateLinkState(void)
+{
+    if (gWirelessCommType == 0 || !IsRfuRecvQueueEmpty() || !IsSendingKeysToLink())
+    {
+        u8 selfId = gLocalLinkPlayerId;
+        UpdateAllLinkPlayers(gLinkPartnersHeldKeys, selfId);
+
+        // Note: Because guestId is between 0 and 4, while the smallest key code is
+        // LINK_KEY_CODE_EMPTY, this is functionally equivalent to `sPlayerKeyInterceptCallback(0)`.
+        // It is expecting the callback to be KeyInterCB_SelfIdle, and that will
+        // completely ignore any input parameters.
+        //
+        // UpdateHeldKeyCode performs a sanity check on its input; if
+        // sPlayerKeyInterceptCallback echoes back the argument, which is selfId, then
+        // it'll use LINK_KEY_CODE_EMPTY instead.
+        //
+        // Note 2: There are some key intercept callbacks that treat the key as a player
+        // ID. It's so hacky.
+        UpdateHeldKeyCode(sPlayerKeyInterceptCallback(selfId));
+        ClearAllPlayerKeys();
+    }
+}
+
+static void ResetAllMultiplayerState(void)
+{
+    ResetAllTradingStates();
+    SetKeyInterceptCallback(KeyInterCB_SelfIdle);
+}
+
+static void ClearAllPlayerKeys(void)
+{
+    ResetPlayerHeldKeys(gLinkPartnersHeldKeys);
+}
+
+static void SetKeyInterceptCallback(KeyInterCB func)
+{
+    sRfuKeepAliveTimer = 0;
+    sPlayerKeyInterceptCallback = func;
+}
+
+// Once every ~60 frames, if the link state hasn't changed (timer reset by calls
+// to SetKeyInterceptCallback), it does a bunch of sanity checks on the connection.
+// I'm not sure if sRfuKeepAliveTimer is reset in the process, though; rfu stuff is
+// still undocumented.
+static void CheckRfuKeepAliveTimer(void)
+{
+    if (gWirelessCommType != 0 && ++sRfuKeepAliveTimer > 60)
+        LinkRfu_FatalError();
+}
+
+static void ResetAllTradingStates(void)
+{
+    s32 i;
+    for (i = 0; i < 4; i++)
+        sPlayerTradingStates[i] = PLAYER_TRADING_STATE_IDLE;
+}
+
+// Returns true if all connected players are in tradingState.
+static bool32 AreAllPlayersInTradingState(u16 tradingState)
+{
+    s32 i;
+    s32 count = gFieldLinkPlayerCount;
+
+    for (i = 0; i < count; i++)
+        if (sPlayerTradingStates[i] != tradingState)
+            return FALSE;
+    return TRUE;
+}
+
+static bool32 IsAnyPlayerInTradingState(u16 tradingState)
+{
+    s32 i;
+    s32 count = gFieldLinkPlayerCount;
+
+    for (i = 0; i < count; i++)
+        if (sPlayerTradingStates[i] == tradingState)
+            return TRUE;
+    return FALSE;
+}
+
+static void HandleLinkPlayerKeyInput(u32 playerId, u16 key, struct TradeRoomPlayer *trainer, u16 *forceFacing)
+{
+    const u8 *script;
+
+    if (sPlayerTradingStates[playerId] == PLAYER_TRADING_STATE_IDLE)
+    {
+        script = TryGetTileEventScript(trainer);
+        if (script)
+        {
+            *forceFacing = GetDirectionForEventScript(script);
+            sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+            if (trainer->isLocalPlayer)
+            {
+                SetKeyInterceptCallback(KeyInterCB_DeferToEventScript);
+                sub_80581DC(script);
+            }
+            return;
+        }
+        if (IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE)
+        {
+            sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+            if (trainer->isLocalPlayer)
+            {
+                SetKeyInterceptCallback(KeyInterCB_DeferToEventScript);
+                sub_8058230();
+            }
+            return;
+        }
+
+        switch (key)
+        {
+        case LINK_KEY_CODE_START_BUTTON:
+            if (sub_8058004(trainer))
+            {
+                sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+                if (trainer->isLocalPlayer)
+                {
+                    SetKeyInterceptCallback(KeyInterCB_DeferToEventScript);
+                    InitLinkRoomStartMenuScript();
+                }
+            }
+            break;
+        case LINK_KEY_CODE_DPAD_DOWN:
+            if (PlayerIsAtSouthExit(trainer) == TRUE)
+            {
+                sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+                if (trainer->isLocalPlayer)
+                {
+                    SetKeyInterceptCallback(KeyInterCB_DeferToEventScript);
+                    CreateConfirmLeaveTradeRoomPrompt();
+                }
+            }
+            break;
+        case LINK_KEY_CODE_A_BUTTON:
+            script = TryInteractWithPlayer(trainer);
+            if (script)
+            {
+                sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+                if (trainer->isLocalPlayer)
+                {
+                    SetKeyInterceptCallback(KeyInterCB_DeferToEventScript);
+                    InitMenuBasedScript(script);
+                }
+            }
+            break;
+        case LINK_KEY_CODE_HANDLE_RECV_QUEUE:
+            if (sub_8057FEC(trainer))
+            {
+                sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+                if (trainer->isLocalPlayer)
+                {
+                    SetKeyInterceptCallback(KeyInterCB_DeferToRecvQueue);
+                    sub_80581BC();
+                }
+            }
+            break;
+        case LINK_KEY_CODE_HANDLE_SEND_QUEUE:
+            if (sub_8057FEC(trainer))
+            {
+                sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+                if (trainer->isLocalPlayer)
+                {
+                    SetKeyInterceptCallback(KeyInterCB_DeferToSendQueue);
+                    sub_80581BC();
+                }
+            }
+            break;
+        }
+    }
+
+    switch (key)
+    {
+    case LINK_KEY_CODE_EXIT_ROOM:
+        sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_EXITING_ROOM;
+        break;
+    case LINK_KEY_CODE_UNK_2:
+        sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_UNK_2;
+        break;
+    case LINK_KEY_CODE_UNK_4:
+        sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_IDLE;
+        if (trainer->isLocalPlayer)
+            SetKeyInterceptCallback(KeyInterCB_SelfIdle);
+        break;
+    case LINK_KEY_CODE_UNK_7:
+        if (sPlayerTradingStates[playerId] == PLAYER_TRADING_STATE_UNK_2)
+            sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY;
+        break;
+    }
+}
+
+static void UpdateAllLinkPlayers(u16 *keys, s32 selfId)
+{
+    struct TradeRoomPlayer trainer;
+    s32 i;
+
+    for (i = 0; i < MAX_LINK_PLAYERS; i++)
+    {
+        u8 key = keys[i];
+        u16 setFacing = FACING_NONE;
+        LoadTradeRoomPlayer(i, selfId, &trainer);
+        HandleLinkPlayerKeyInput(i, key, &trainer, &setFacing);
+        if (sPlayerTradingStates[i] == PLAYER_TRADING_STATE_IDLE)
+            setFacing = GetDirectionForDpadKey(key);
+        SetPlayerFacingDirection(i, setFacing);
+    }
+}
+
+static void UpdateHeldKeyCode(u16 key)
+{
+    if (key >= LINK_KEY_CODE_EMPTY && key < LINK_KEY_CODE_UNK_8)
+        gHeldKeyCodeToSend = key;
+    else
+        gHeldKeyCodeToSend = LINK_KEY_CODE_EMPTY;
+
+    if (gWirelessCommType != 0
+        && GetLinkSendQueueLength() > 1
+        && IsUpdateLinkStateCBActive() == TRUE
+        && IsSendingKeysToLink() == TRUE)
+    {
+        switch (key)
+        {
+        case LINK_KEY_CODE_EMPTY:
+        case LINK_KEY_CODE_DPAD_DOWN:
+        case LINK_KEY_CODE_DPAD_UP:
+        case LINK_KEY_CODE_DPAD_LEFT:
+        case LINK_KEY_CODE_DPAD_RIGHT:
+        case LINK_KEY_CODE_START_BUTTON:
+        case LINK_KEY_CODE_A_BUTTON:
+            gHeldKeyCodeToSend = LINK_KEY_CODE_NULL;
+            break;
+        }
+    }
+}
+
+static u16 KeyInterCB_ReadButtons(u32 key)
+{
+    if (JOY_HELD(DPAD_UP))
+        return LINK_KEY_CODE_DPAD_UP;
+    else if (JOY_HELD(DPAD_DOWN))
+        return LINK_KEY_CODE_DPAD_DOWN;
+    else if (JOY_HELD(DPAD_LEFT))
+        return LINK_KEY_CODE_DPAD_LEFT;
+    else if (JOY_HELD(DPAD_RIGHT))
+        return LINK_KEY_CODE_DPAD_RIGHT;
+    else if (JOY_NEW(START_BUTTON))
+        return LINK_KEY_CODE_START_BUTTON;
+    else if (JOY_NEW(A_BUTTON))
+        return LINK_KEY_CODE_A_BUTTON;
+    else
+        return LINK_KEY_CODE_EMPTY;
+}
+
+static u16 GetDirectionForDpadKey(u16 a1)
+{
+    switch (a1)
+    {
+    case LINK_KEY_CODE_DPAD_RIGHT:
+        return FACING_RIGHT;
+    case LINK_KEY_CODE_DPAD_LEFT:
+        return FACING_LEFT;
+    case LINK_KEY_CODE_DPAD_UP:
+        return FACING_UP;
+    case LINK_KEY_CODE_DPAD_DOWN:
+        return FACING_DOWN;
+    default:
+        return FACING_NONE;
+    }
+}
+
+// Overwrites the keys with 0x11
+static void ResetPlayerHeldKeys(u16 *keys)
+{
+    s32 i;
+    for (i = 0; i < 4; i++)
+        keys[i] = LINK_KEY_CODE_EMPTY;
+}
+
+static u16 KeyInterCB_SelfIdle(u32 key)
+{
+    if (ScriptContext2_IsEnabled() == TRUE)
+        return LINK_KEY_CODE_EMPTY;
+    if (GetLinkRecvQueueLength() > 4)
+        return LINK_KEY_CODE_HANDLE_RECV_QUEUE;
+    if (GetLinkSendQueueLength() <= 4)
+        return KeyInterCB_ReadButtons(key);
+    return LINK_KEY_CODE_HANDLE_SEND_QUEUE;
+}
+
+static u16 sub_8057D98(u32 key)
+{
+    CheckRfuKeepAliveTimer();
+    return LINK_KEY_CODE_EMPTY;
+}
+
+// Ignore the player's inputs as long as there is an event script
+// in ScriptContext2.
+static u16 KeyInterCB_DeferToEventScript(u32 key)
+{
+    u16 retVal;
+    if (ScriptContext2_IsEnabled() == TRUE)
+    {
+        retVal = LINK_KEY_CODE_EMPTY;
+    }
+    else
+    {
+        retVal = LINK_KEY_CODE_UNK_4;
+        SetKeyInterceptCallback(sub_8057D98);
+    }
+    return retVal;
+}
+
+// Ignore the player's inputs as long as there are events being recived.
+static u16 KeyInterCB_DeferToRecvQueue(u32 key)
+{
+    u16 retVal;
+    if (GetLinkRecvQueueLength() > 2)
+    {
+        retVal = LINK_KEY_CODE_EMPTY;
+    }
+    else
+    {
+        retVal = LINK_KEY_CODE_UNK_4;
+        ScriptContext2_Disable();
+        SetKeyInterceptCallback(sub_8057D98);
+    }
+    return retVal;
+}
+
+// Ignore the player's inputs as long as there are events being sent.
+static u16 KeyInterCB_DeferToSendQueue(u32 key)
+{
+    u16 retVal;
+    if (GetLinkSendQueueLength() > 2)
+    {
+        retVal = LINK_KEY_CODE_EMPTY;
+    }
+    else
+    {
+        retVal = LINK_KEY_CODE_UNK_4;
+        ScriptContext2_Disable();
+        SetKeyInterceptCallback(sub_8057D98);
+    }
+    return retVal;
+}
+
+static u16 KeyInterCB_DoNothingAndKeepAlive(u32 key)
+{
+    CheckRfuKeepAliveTimer();
+    return LINK_KEY_CODE_EMPTY;
+}
+
+static u16 sub_8057E1C(u32 keyOrPlayerId)
+{
+    if (sPlayerTradingStates[keyOrPlayerId] == PLAYER_TRADING_STATE_UNK_2)
+    {
+        if (JOY_NEW(B_BUTTON))
+        {
+            SetKeyInterceptCallback(KeyInterCB_DoNothingAndKeepAlive);
+            return LINK_KEY_CODE_UNK_7;
+        }
+        else
+        {
+            return LINK_KEY_CODE_EMPTY;
+        }
+    }
+    else
+    {
+        CheckRfuKeepAliveTimer();
+        return LINK_KEY_CODE_EMPTY;
+    }
+}
+
+static u16 sub_8057E58(u32 a1)
+{
+    SetKeyInterceptCallback(sub_8057E1C);
+    return LINK_KEY_CODE_UNK_2;
+}
+
+static u16 KeyInterCB_SendNothing(u32 key)
+{
+    return LINK_KEY_CODE_EMPTY;
+}
+
+static u16 KeyInterCB_WaitForPlayersToExit(u32 keyOrPlayerId)
+{
+    // keyOrPlayerId could be any keycode. This callback does no sanity checking
+    // on the size of the key. It's assuming that it is being called from
+    // CB1_UpdateLinkState.
+    if (sPlayerTradingStates[keyOrPlayerId] != PLAYER_TRADING_STATE_EXITING_ROOM)
+        CheckRfuKeepAliveTimer();
+    if (AreAllPlayersInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE)
+    {
+        ScriptContext1_SetupScript(CableClub_EventScript_DoLinkRoomExit);
+        SetKeyInterceptCallback(KeyInterCB_SendNothing);
+    }
+    return LINK_KEY_CODE_EMPTY;
+}
+
+static u16 KeyInterCB_SendExitRoomKey(u32 key)
+{
+    SetKeyInterceptCallback(KeyInterCB_WaitForPlayersToExit);
+    return LINK_KEY_CODE_EXIT_ROOM;
+}
+
+// Duplicate function.
+static u16 KeyInterCB_SendNothing_2(u32 key)
+{
+    return LINK_KEY_CODE_EMPTY;
+}
+
+u32 sub_8057EC0(void)
+{
+    if (IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE)
+        return 2;
+    if (sPlayerKeyInterceptCallback == sub_8057E1C && sPlayerTradingStates[gLocalLinkPlayerId] != PLAYER_TRADING_STATE_UNK_2)
+        return 0;
+    if (sPlayerKeyInterceptCallback == KeyInterCB_DoNothingAndKeepAlive && sPlayerTradingStates[gLocalLinkPlayerId] == PLAYER_TRADING_STATE_BUSY)
+        return 2;
+    if (AreAllPlayersInTradingState(PLAYER_TRADING_STATE_UNK_2) != FALSE)
+        return 1;
+    return 0;
+}
+
+static bool32 sub_8057F28(void)
+{
+    return IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM);
+}
+
+u16 sub_8057F34(void)
+{
+    SetKeyInterceptCallback(sub_8057E58);
+    return 0;
+}
+
+u16 sub_8057F48(void)
+{
+    SetKeyInterceptCallback(KeyInterCB_DeferToEventScript);
+    return 0;
+}
+
+// The exit room key will be sent at the next opportunity.
+// The return value is meaningless.
+u16 QueueExitLinkRoomKey(void)
+{
+    SetKeyInterceptCallback(KeyInterCB_SendExitRoomKey);
+    return 0;
+}
+
+u16 sub_8057F70(void)
+{
+    SetKeyInterceptCallback(KeyInterCB_SendNothing_2);
+    return 0;
+}
+
+static void LoadTradeRoomPlayer(s32 linkPlayerId, s32 myPlayerId, struct TradeRoomPlayer *trainer)
+{
+    s16 x, y;
+
+    trainer->playerId = linkPlayerId;
+    trainer->isLocalPlayer = (linkPlayerId == myPlayerId) ? TRUE : FALSE;
+    trainer->c = gLinkPlayerObjectEvents[linkPlayerId].movementMode;
+    trainer->facing = GetLinkPlayerFacingDirection(linkPlayerId);
+    GetLinkPlayerCoords(linkPlayerId, &x, &y);
+    trainer->pos.x = x;
+    trainer->pos.y = y;
+    trainer->pos.height = GetLinkPlayerElevation(linkPlayerId);
+    trainer->field_C = MapGridGetMetatileBehaviorAt(x, y);
+}
+
+static bool32 sub_8057FEC(struct TradeRoomPlayer *player)
+{
+    u8 v1 = player->c;
+    if (v1 == MOVEMENT_MODE_SCRIPTED || v1 == MOVEMENT_MODE_FREE)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+// Duplicate function.
+static bool32 sub_8058004(struct TradeRoomPlayer *player)
+{
+    u8 v1 = player->c;
+    if (v1 == MOVEMENT_MODE_SCRIPTED || v1 == MOVEMENT_MODE_FREE)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static const u8 *TryGetTileEventScript(struct TradeRoomPlayer *player)
+{
+    if (player->c != MOVEMENT_MODE_SCRIPTED)
+        return FACING_NONE;
+    return GetCoordEventScriptAtMapPosition(&player->pos);
+}
+
+static bool32 PlayerIsAtSouthExit(struct TradeRoomPlayer *player)
+{
+    if (player->c != MOVEMENT_MODE_SCRIPTED && player->c != MOVEMENT_MODE_FREE)
+        return FALSE;
+    else if (!MetatileBehavior_IsSouthArrowWarp(player->field_C))
+        return FALSE;
+    else if (player->facing != DIR_SOUTH)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+static const u8 *TryInteractWithPlayer(struct TradeRoomPlayer *player)
+{
+    struct MapPosition otherPlayerPos;
+    u8 linkPlayerId;
+
+    if (player->c != MOVEMENT_MODE_FREE && player->c != MOVEMENT_MODE_SCRIPTED)
+        return FACING_NONE;
+
+    otherPlayerPos = player->pos;
+    otherPlayerPos.x += gDirectionToVectors[player->facing].x;
+    otherPlayerPos.y += gDirectionToVectors[player->facing].y;
+    otherPlayerPos.height = 0;
+    linkPlayerId = GetLinkPlayerIdAt(otherPlayerPos.x, otherPlayerPos.y);
+
+    if (linkPlayerId != 4)
+    {
+        if (!player->isLocalPlayer)
+            return CableClub_EventScript_TooBusyToNotice;
+        else if (sPlayerTradingStates[linkPlayerId] != PLAYER_TRADING_STATE_IDLE)
+            return CableClub_EventScript_TooBusyToNotice;
+        else if (!GetSeeingLinkPlayerCardMsg(linkPlayerId))
+            return CableClub_EventScript_ReadTrainerCard;
+        else
+            return CableClub_EventScript_ReadTrainerCardColored;
+    }
+
+    return GetInteractedLinkPlayerScript(&otherPlayerPos, player->field_C, player->facing);
+}
+
+// This returns which direction to force the player to look when one of
+// these event scripts runs.
+static u16 GetDirectionForEventScript(const u8 *script)
+{
+    if (script == BattleColosseum_4P_EventScript_PlayerSpot0)
+        return FACING_FORCED_RIGHT;
+    else if (script == BattleColosseum_4P_EventScript_PlayerSpot1)
+        return FACING_FORCED_LEFT;
+    else if (script == BattleColosseum_4P_EventScript_PlayerSpot2)
+        return FACING_FORCED_RIGHT;
+    else if (script == BattleColosseum_4P_EventScript_PlayerSpot3)
+        return FACING_FORCED_LEFT;
+    else if (script == RecordCenter_EventScript_Spot0)
+        return FACING_FORCED_RIGHT;
+    else if (script == RecordCenter_EventScript_Spot1)
+        return FACING_FORCED_LEFT;
+    else if (script == RecordCenter_EventScript_Spot2)
+        return FACING_FORCED_RIGHT;
+    else if (script == RecordCenter_EventScript_Spot3)
+        return FACING_FORCED_LEFT;
+    else if (script == BattleColosseum_2P_EventScript_PlayerSpot0)
+        return FACING_FORCED_RIGHT;
+    else if (script == BattleColosseum_2P_EventScript_PlayerSpot1)
+        return FACING_FORCED_LEFT;
+    else if (script == TradeCenter_EventScript_Chair0)
+        return FACING_FORCED_RIGHT;
+    else if (script == TradeCenter_EventScript_Chair1)
+        return FACING_FORCED_LEFT;
+    else
+        return FACING_NONE;
+}
+
+static void sub_80581BC(void)
+{
+    ScriptContext2_Enable();
+}
+
+static void InitLinkRoomStartMenuScript(void)
+{
+    PlaySE(SE_WIN_OPEN);
+    ShowStartMenu();
+    ScriptContext2_Enable();
+}
+
+static void sub_80581DC(const u8 *script)
+{
+    PlaySE(SE_SELECT);
+    ScriptContext1_SetupScript(script);
+    ScriptContext2_Enable();
+}
+
+static void CreateConfirmLeaveTradeRoomPrompt(void)
+{
+    PlaySE(SE_WIN_OPEN);
+    ScriptContext1_SetupScript(TradeCenter_ConfirmLeaveRoom);
+    ScriptContext2_Enable();
+}
+
+static void InitMenuBasedScript(const u8 *script)
+{
+    PlaySE(SE_SELECT);
+    ScriptContext1_SetupScript(script);
+    ScriptContext2_Enable();
+}
+
+static void sub_8058230(void)
+{
+    ScriptContext1_SetupScript(TradeCenter_TerminateLink);
+    ScriptContext2_Enable();
+}
+
+bool32 sub_8058244(void)
+{
+    if (!IsUpdateLinkStateCBActive())
+        return FALSE;
+    if (GetLinkRecvQueueLength() >= 3)
+        gUnknown_3000E88 = TRUE;
+    else
+        gUnknown_3000E88 = FALSE;
+    return gUnknown_3000E88;
+}
+
+bool32 sub_8058274(void)
+{
+    u8 temp;
+
+    if (GetLinkRecvQueueLength() < 2)
+        return FALSE;
+    else if (IsUpdateLinkStateCBActive() != TRUE)
+        return FALSE;
+    else if (IsSendingKeysToLink() != TRUE)
+        return FALSE;
+    else if (sPlayerKeyInterceptCallback == KeyInterCB_DeferToRecvQueue)
+        return TRUE;
+    else if (sPlayerKeyInterceptCallback != KeyInterCB_DeferToEventScript)
+        return FALSE;
+
+    temp = gUnknown_3000E88;
+    gUnknown_3000E88 = FALSE;
+
+    if (temp == TRUE)
+        return TRUE;
+    else if (gPaletteFade.active && gPaletteFade.softwareFadeFinishing)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool32 sub_80582E0(void)
+{
+    if (GetLinkSendQueueLength() < 2)
+        return FALSE;
+    else if (IsUpdateLinkStateCBActive() != TRUE)
+        return FALSE;
+    else if (IsSendingKeysToLink() != TRUE)
+        return FALSE;
+    else if (sPlayerKeyInterceptCallback == KeyInterCB_DeferToSendQueue)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool32 sub_8058318(void)
+{
+    if (gWirelessCommType != 0)
+        return FALSE;
+    else if (!IsSendingKeysToLink())
+        return FALSE;
+    else
+        return TRUE;
+}
+
+static u32 GetLinkSendQueueLength(void)
+{
+    if (gWirelessCommType != 0)
+        return Rfu.sendQueue.count;
+    else
+        return gLink.sendQueue.count;
+}
+
+static void ZeroLinkPlayerObjectEvent(struct LinkPlayerObjectEvent *linkPlayerObjEvent)
+{
+    memset(linkPlayerObjEvent, 0, sizeof(struct LinkPlayerObjectEvent));
+}
+
+void ClearLinkPlayerObjectEvents(void)
+{
+    memset(gLinkPlayerObjectEvents, 0, sizeof(gLinkPlayerObjectEvents));
+}
+
+static void ZeroObjectEvent(struct ObjectEvent *objEvent)
+{
+    memset(objEvent, 0, sizeof(struct ObjectEvent));
+}
+
+static void SpawnLinkPlayerObjectEvent(u8 linkPlayerId, s16 x, s16 y, u8 a4)
+{
+    u8 objEventId = GetFirstInactiveObjectEventId();
+    struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId];
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+
+    ZeroLinkPlayerObjectEvent(linkPlayerObjEvent);
+    ZeroObjectEvent(objEvent);
+
+    linkPlayerObjEvent->active = TRUE;
+    linkPlayerObjEvent->linkPlayerId = linkPlayerId;
+    linkPlayerObjEvent->objEventId = objEventId;
+    linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FREE;
+
+    objEvent->active = TRUE;
+    objEvent->singleMovementActive = a4;
+    objEvent->range.as_byte = 2;
+    objEvent->spriteId = MAX_SPRITES;
+
+    InitLinkPlayerObjectEventPos(objEvent, x, y);
+}
+
+static void InitLinkPlayerObjectEventPos(struct ObjectEvent *objEvent, s16 x, s16 y)
+{
+    objEvent->currentCoords.x = x;
+    objEvent->currentCoords.y = y;
+    objEvent->previousCoords.x = x;
+    objEvent->previousCoords.y = y;
+    SetSpritePosToMapCoords(x, y, &objEvent->initialCoords.x, &objEvent->initialCoords.y);
+    objEvent->initialCoords.x += 8;
+    ObjectEventUpdateZCoord(objEvent);
+}
+
+static void sub_8058488(u8 linkPlayerId, u8 a2)
+{
+    if (gLinkPlayerObjectEvents[linkPlayerId].active)
+    {
+        u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId;
+        struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+        objEvent->range.as_byte = a2;
+    }
+}
+
+static void sub_80584B8(u8 linkPlayerId)
+{
+    struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId];
+    u8 objEventId = linkPlayerObjEvent->objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+    if (objEvent->spriteId != MAX_SPRITES)
+        DestroySprite(&gSprites[objEvent->spriteId]);
+    linkPlayerObjEvent->active = FALSE;
+    objEvent->active = FALSE;
+}
+
+// Returns the spriteId corresponding to this player.
+static u8 GetSpriteForLinkedPlayer(u8 linkPlayerId)
+{
+    u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+    return objEvent->spriteId;
+}
+
+static void GetLinkPlayerCoords(u8 linkPlayerId, u16 *x, u16 *y)
+{
+    u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+    *x = objEvent->currentCoords.x;
+    *y = objEvent->currentCoords.y;
+}
+
+static u8 GetLinkPlayerFacingDirection(u8 linkPlayerId)
+{
+    u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+    return objEvent->range.as_byte;
+}
+
+static u8 GetLinkPlayerElevation(u8 linkPlayerId)
+{
+    u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+    return objEvent->currentElevation;
+}
+
+static s32 sub_8058590(u8 linkPlayerId)
+{
+    u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+    return 16 - (s8)objEvent->directionSequenceIndex;
+}
+
+static u8 GetLinkPlayerIdAt(s16 x, s16 y)
+{
+    u8 i;
+    for (i = 0; i < MAX_LINK_PLAYERS; i++)
+    {
+        if (gLinkPlayerObjectEvents[i].active
+            && (gLinkPlayerObjectEvents[i].movementMode == 0 || gLinkPlayerObjectEvents[i].movementMode == 2))
+        {
+            struct ObjectEvent *objEvent = &gObjectEvents[gLinkPlayerObjectEvents[i].objEventId];
+            if (objEvent->currentCoords.x == x && objEvent->currentCoords.y == y)
+                return i;
+        }
+    }
+    return 4;
+}
+
+static void SetPlayerFacingDirection(u8 linkPlayerId, u8 facing)
+{
+    struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId];
+    u8 objEventId = linkPlayerObjEvent->objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+
+    if (linkPlayerObjEvent->active)
+    {
+        if (facing > FACING_FORCED_RIGHT)
+        {
+            objEvent->triggerGroundEffectsOnMove = TRUE;
+        }
+        else
+        {
+            // This is a hack to split this code onto two separate lines, without declaring a local variable.
+            // C++ style inline variables would be nice here.
+#define TEMP sLinkPlayerMovementModes[linkPlayerObjEvent->movementMode](linkPlayerObjEvent, objEvent, facing)
+
+            sMovementStatusHandler[TEMP](linkPlayerObjEvent, objEvent);
+
+            // Clean up the hack.
+#undef TEMP
+        }
+    }
+}
+
+static u8 MovementEventModeCB_Normal(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3)
+{
+    return sLinkPlayerFacingHandlers[a3](linkPlayerObjEvent, objEvent, a3);
+}
+
+static u8 MovementEventModeCB_Ignored(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3)
+{
+    return FACING_UP;
+}
+
+// Duplicate Function
+static u8 MovementEventModeCB_Normal_2(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3)
+{
+    return sLinkPlayerFacingHandlers[a3](linkPlayerObjEvent, objEvent, a3);
+}
+
+static bool8 FacingHandler_DoNothing(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3)
+{
+    return FALSE;
+}
+
+static bool8 FacingHandler_DpadMovement(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3)
+{
+    s16 x, y;
+
+    objEvent->range.as_byte = FlipVerticalAndClearForced(a3, objEvent->range.as_byte);
+    ObjectEventMoveDestCoords(objEvent, objEvent->range.as_byte, &x, &y);
+
+    if (LinkPlayerDetectCollision(linkPlayerObjEvent->objEventId, objEvent->range.as_byte, x, y))
+    {
+        return FALSE;
+    }
+    else
+    {
+        objEvent->directionSequenceIndex = 16;
+        ShiftObjectEventCoords(objEvent, x, y);
+        ObjectEventUpdateZCoord(objEvent);
+        return TRUE;
+    }
+}
+
+static bool8 FacingHandler_ForcedFacingChange(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3)
+{
+    objEvent->range.as_byte = FlipVerticalAndClearForced(a3, objEvent->range.as_byte);
+    return FALSE;
+}
+
+// This is called every time a free movement happens. Most of the time it's a No-Op.
+static void MovementStatusHandler_EnterFreeMode(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent)
+{
+    linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FREE;
+}
+
+static void MovementStatusHandler_TryAdvanceScript(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent)
+{
+    objEvent->directionSequenceIndex--;
+    linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FROZEN;
+    MoveCoords(objEvent->range.as_byte, &objEvent->initialCoords.x, &objEvent->initialCoords.y);
+    if (!objEvent->directionSequenceIndex)
+    {
+        ShiftStillObjectEventCoords(objEvent);
+        linkPlayerObjEvent->movementMode = MOVEMENT_MODE_SCRIPTED;
+    }
+}
+
+// Flip Up/Down facing codes. If newFacing doesn't specify a direction, default
+// to oldFacing. Note that this clears also the "FORCED" part of the facing code,
+// even for Left/Right codes.
+static u8 FlipVerticalAndClearForced(u8 newFacing, u8 oldFacing)
+{
+    switch (newFacing)
+    {
+    case FACING_UP:
+    case FACING_FORCED_UP:
+        return DIR_NORTH;
+    case FACING_DOWN:
+    case FACING_FORCED_DOWN:
+        return DIR_SOUTH;
+    case FACING_LEFT:
+    case FACING_FORCED_LEFT:
+        return DIR_WEST;
+    case FACING_RIGHT:
+    case FACING_FORCED_RIGHT:
+        return DIR_EAST;
+    }
+    return oldFacing;
+}
+
+static bool8 LinkPlayerDetectCollision(u8 selfObjEventId, u8 a2, s16 x, s16 y)
+{
+    u8 i;
+    for (i = 0; i < 16; i++)
+    {
+        if (i != selfObjEventId)
+        {
+            if ((gObjectEvents[i].currentCoords.x == x && gObjectEvents[i].currentCoords.y == y)
+                || (gObjectEvents[i].previousCoords.x == x && gObjectEvents[i].previousCoords.y == y))
+            {
+                return TRUE;
+            }
+        }
+    }
+    return MapGridIsImpassableAt(x, y);
+}
+
+static void CreateLinkPlayerSprite(u8 linkPlayerId, u8 gameVersion)
+{
+    struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId];
+    u8 objEventId = linkPlayerObjEvent->objEventId;
+    struct ObjectEvent *objEvent = &gObjectEvents[objEventId];
+    struct Sprite *sprite;
+
+    if (linkPlayerObjEvent->active)
+    {
+        if (gameVersion == VERSION_FIRE_RED || gameVersion == VERSION_LEAF_GREEN)
+        {
+            objEvent->spriteId = AddPseudoObjectEvent(
+                GetRivalAvatarGraphicsIdByStateIdAndGender(PLAYER_AVATAR_STATE_NORMAL, objEvent->singleMovementActive),
+                SpriteCB_LinkPlayer, 0, 0, 0);
+        }
+        else
+        {
+            objEvent->spriteId = AddPseudoObjectEvent(GetRSAvatarGraphicsIdByGender(objEvent->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0);
+        }
+
+        sprite = &gSprites[objEvent->spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->data[0] = linkPlayerId;
+        objEvent->triggerGroundEffectsOnMove = FALSE;
+    }
+}
+
+static void SpriteCB_LinkPlayer(struct Sprite *sprite)
+{
+    struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[sprite->data[0]];
+    struct ObjectEvent *objEvent = &gObjectEvents[linkPlayerObjEvent->objEventId];
+    sprite->pos1.x = objEvent->initialCoords.x;
+    sprite->pos1.y = objEvent->initialCoords.y;
+    SetObjectSubpriorityByZCoord(objEvent->previousElevation, sprite, 1);
+    sprite->oam.priority = ZCoordToPriority(objEvent->previousElevation);
+
+    if (!linkPlayerObjEvent->movementMode != MOVEMENT_MODE_FREE)
+        StartSpriteAnim(sprite, GetFaceDirectionAnimNum(objEvent->range.as_byte));
+    else
+        StartSpriteAnimIfDifferent(sprite, GetMoveDirectionAnimNum(objEvent->range.as_byte));
+
+    UpdateObjectEventSpriteVisibility(sprite, 0);
+    if (objEvent->triggerGroundEffectsOnMove)
+    {
+        sprite->invisible = ((sprite->data[7] & 4) >> 2);
+        sprite->data[7]++;
+    }
+}
diff --git a/src/party_menu_specials.c b/src/party_menu_specials.c
index aba11a534..48406da9a 100644
--- a/src/party_menu_specials.c
+++ b/src/party_menu_specials.c
@@ -47,7 +47,7 @@ void SelectMoveDeleterMove(void)
 {
     ShowSelectMovePokemonSummaryScreen(gPlayerParty, gSpecialVar_0x8004, gPlayerPartyCount - 1, CB2_ReturnToField, 0);
     sub_8138B38(3);
-    gFieldCallback = FieldCallback_ReturnToEventScript2;
+    gFieldCallback = FieldCB_ContinueScriptHandleMusic;
 }
 
 void GetNumMovesSelectedMonHas(void)
diff --git a/src/pokemon_jump_2.c b/src/pokemon_jump_2.c
index aa1238e3f..9f2f9e404 100644
--- a/src/pokemon_jump_2.c
+++ b/src/pokemon_jump_2.c
@@ -1883,7 +1883,7 @@ static int sub_81497A8(void)
 
 static bool32 sub_8149804(void)
 {
-    return !Rfu.unk_124.count && !Rfu.unk_9e8.count;
+    return !Rfu.unk_124.count && !Rfu.sendQueue.count;
 }
 
 static int sub_8149834(u8 *arg0)
diff --git a/src/post_battle_event_funcs.c b/src/post_battle_event_funcs.c
index 86406fa2a..7d154f815 100644
--- a/src/post_battle_event_funcs.c
+++ b/src/post_battle_event_funcs.c
@@ -28,8 +28,8 @@ bool8 EnterHallOfFame(void)
     {
         SetGameStat(GAME_STAT_FIRST_HOF_PLAY_TIME, (gSaveBlock2Ptr->playTimeHours << 16) | (gSaveBlock2Ptr->playTimeMinutes << 8) | gSaveBlock2Ptr->playTimeSeconds);
     }
-    sub_804C1AC();
-    sub_8055738(SPAWN_PALLET_TOWN);
+    SetContinueGameWarpStatus();
+    SetContinueGameWarpToHealLocation(SPAWN_PALLET_TOWN);
     gaveAtLeastOneRibbon = FALSE;
     for (i = 0, r7 = &ribbonState; i < PARTY_SIZE; i++)
     {
diff --git a/src/quest_log.c b/src/quest_log.c
index 21a05f407..3c6b88d3d 100644
--- a/src/quest_log.c
+++ b/src/quest_log.c
@@ -96,7 +96,7 @@ struct UnkStruct_203B044
 
 u8 gUnknown_3005E88;
 u16 sNumEventsInLogEntry;
-struct UnkStruct_3005E90 gUnknown_3005E90;
+struct FieldInput gUnknown_3005E90;
 struct QuestLogEntry * sCurQuestLogEntry;
 
 static struct UnkStruct_300201C * sFlagOrVarRecords;
@@ -600,7 +600,7 @@ bool8 sub_8111000(void)
 {
     LoadPalette(stdpal_get(4), 0xF0, 0x20);
     SetQuestLogState(QL_STATE_2);
-    FieldCB_UnionRoomWarp();
+    FieldCB_DefaultWarpExit();
     gUnknown_203AE94 = (struct UnkStruct_203AE94){};
     gUnknown_203AE94.unk_0_0 = 2;
     return 1;
@@ -610,7 +610,7 @@ bool8 sub_8111038(void)
 {
     LoadPalette(stdpal_get(4), 0xF0, 0x20);
     SetQuestLogState(QL_STATE_2);
-    sub_807DF7C();
+    FieldCB_WarpExitFadeFromBlack();
     gUnknown_203AE94 = (struct UnkStruct_203AE94){};
     gUnknown_203AE94.unk_0_0 = 2;
     return 1;
@@ -1217,7 +1217,7 @@ static bool8 sub_8111F60(void)
 {
     LoadPalette(stdpal_get(4), 0xF0, 0x20);
     DrawPreviouslyOnQuestHeader(0);
-    sub_807DF7C();
+    FieldCB_WarpExitFadeFromBlack();
     CreateTask(sub_8111F8C, 0xFF);
     return TRUE;
 }
@@ -1313,7 +1313,7 @@ static void Task_EndQuestLog(u8 taskId)
         break;
     default:
         if (gUnknown_203AE94.unk_0_6 == 1)
-            CreateMapNamePopupIfNotAlreadyRunning(1);
+            ShowMapNamePopup(1);
         CpuCopy16(gUnknown_203AE90, gPlttBufferUnfaded, 0x400);
         Free(gUnknown_203AE90);
         gUnknown_203AE94 = (struct UnkStruct_203AE94){};
@@ -1536,7 +1536,7 @@ void sub_811278C(u8 movementActionId, u8 duration)
     }
 }
 
-void sub_81127F8(struct UnkStruct_3005E90 * a0)
+void sub_81127F8(struct FieldInput * a0)
 {
     if (sQuestLogCursor < sNumEventsInLogEntry)
     {
@@ -1616,7 +1616,7 @@ static void SetUpQuestLogEntry(u8 kind, struct QuestLogEntry *entry, u16 size)
         }
         sQuestLogCursor = 0;
         gUnknown_203B01C = 0;
-        gUnknown_3005E90 = (struct UnkStruct_3005E90){};
+        gUnknown_3005E90 = (struct FieldInput){};
         sNextStepDelay = sCurQuestLogEntry[sQuestLogCursor].unk_4;
         sMovementScripts[0][0] = sCurQuestLogEntry[sQuestLogCursor].unk_3;
         sMovementScripts[0][1] = 0xFF;
diff --git a/src/region_map.c b/src/region_map.c
index 3a902ec0e..f97d67ffc 100644
--- a/src/region_map.c
+++ b/src/region_map.c
@@ -3471,7 +3471,7 @@ static void GetPlayerPositionOnRegionMap(void)
     const struct MapHeader * mapHeader;
     struct WarpData * warp;
 
-    switch (get_map_light_level_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum))
+    switch (GetMapTypeByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum))
     {
     default:
     case 1:
@@ -3495,12 +3495,12 @@ static void GetPlayerPositionOnRegionMap(void)
         y = gSaveBlock1Ptr->escapeWarp.y;
         break;
     case 9:
-        mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->warp2.mapGroup, gSaveBlock1Ptr->warp2.mapNum);
+        mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->dynamicWarp.mapGroup, gSaveBlock1Ptr->dynamicWarp.mapNum);
         gUnknown_20399E4->field_014 = mapHeader->regionMapSectionId;
         width = mapHeader->mapLayout->width;
         height = mapHeader->mapLayout->height;
-        x = gSaveBlock1Ptr->warp2.x;
-        y = gSaveBlock1Ptr->warp2.y;
+        x = gSaveBlock1Ptr->dynamicWarp.x;
+        y = gSaveBlock1Ptr->dynamicWarp.y;
         break;
     case 8:
         if ((gUnknown_20399E4->field_014 = gMapHeader.regionMapSectionId) != MAPSEC_SPECIAL_AREA)
@@ -3510,7 +3510,7 @@ static void GetPlayerPositionOnRegionMap(void)
         }
         else
         {
-            warp = &gSaveBlock1Ptr->warp2;
+            warp = &gSaveBlock1Ptr->dynamicWarp;
             mapHeader = Overworld_GetMapHeaderByGroupAndId(warp->mapGroup, warp->mapNum);
             gUnknown_20399E4->field_014 = mapHeader->regionMapSectionId;
         }
@@ -4318,7 +4318,7 @@ static void sub_80C4F08(u8 taskId)
         case 4:
             if ((sub_80C3AC8(0) == 2 || sub_80C3AC8(0) == 4) && GetRegionMapPermission(MAPPERM_3) == TRUE)
             {
-                switch (get_map_light_level_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum))
+                switch (GetMapTypeByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum))
                 {
                 case 4:
                 case 8:
@@ -4388,7 +4388,7 @@ static void sub_80C527C(u16 mapsec)
     u16 idx = mapsec - MAPSECS_KANTO;
     if (sMapsecToSpawn[idx][2])
     {
-        sub_805546C(sMapsecToSpawn[idx][2]);
+        SetWarpDestinationToHealLocation(sMapsecToSpawn[idx][2]);
         SetUsedFlyQuestLogEvent(sMapsecToSpawn[idx]);
     }
     else
diff --git a/src/scrcmd.c b/src/scrcmd.c
index af977fbc7..bec0f4942 100644
--- a/src/scrcmd.c
+++ b/src/scrcmd.c
@@ -1168,7 +1168,7 @@ bool8 ScrCmd_setobjectmovementtype(struct ScriptContext * ctx)
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 movementType = ScriptReadByte(ctx);
 
-    Overworld_SetMapObjTemplateMovementType(localId, movementType);
+    Overworld_SetObjEventTemplateMovementType(localId, movementType);
     return FALSE;
 }
 
diff --git a/src/script.c b/src/script.c
index ff74b40bc..13c571bac 100644
--- a/src/script.c
+++ b/src/script.c
@@ -358,7 +358,7 @@ void ScriptContext2_RunNewScript(const u8 *ptr)
 
 u8 *mapheader_get_tagged_pointer(u8 tag)
 {
-    u8 *mapScripts = gMapHeader.mapScripts;
+    const u8 *mapScripts = gMapHeader.mapScripts;
 
     if (mapScripts == NULL)
         return NULL;
@@ -370,7 +370,7 @@ u8 *mapheader_get_tagged_pointer(u8 tag)
         if (*mapScripts == tag)
         {
             mapScripts++;
-            return (u8 *)(mapScripts[0] + (mapScripts[1] << 8) + (mapScripts[2] << 16) + (mapScripts[3] << 24));
+            return T2_READ_PTR(mapScripts);
         }
         mapScripts += 5;
     }
@@ -379,7 +379,7 @@ u8 *mapheader_get_tagged_pointer(u8 tag)
 void mapheader_run_script_by_tag(u8 tag)
 {
     u8 *ptr = mapheader_get_tagged_pointer(tag);
-    if (ptr)
+    if (ptr != NULL)
         ScriptContext2_RunNewScript(ptr);
 }
 
@@ -387,7 +387,7 @@ u8 *mapheader_get_first_match_from_tagged_ptr_list(u8 tag)
 {
     u8 *ptr = mapheader_get_tagged_pointer(tag);
 
-    if (!ptr)
+    if (ptr == NULL)
         return NULL;
 
     while (1)
@@ -411,22 +411,22 @@ void RunOnLoadMapScript(void)
     mapheader_run_script_by_tag(1);
 }
 
-void mapheader_run_script_with_tag_x3(void)
+void RunOnTransitionMapScript(void)
 {
     mapheader_run_script_by_tag(3);
 }
 
-void mapheader_run_script_with_tag_x5(void)
+void RunOnResumeMapScript(void)
 {
     mapheader_run_script_by_tag(5);
 }
 
-void mapheader_run_script_with_tag_x7(void)
+void RunOnReturnToFieldMapScript(void)
 {
     mapheader_run_script_by_tag(7);
 }
 
-void mapheader_run_script_with_tag_x6(void)
+void RunOnDiveWarpMapScript(void)
 {
     mapheader_run_script_by_tag(6);
 }
@@ -447,7 +447,7 @@ bool8 TryRunOnFrameMapScript(void)
     return 1;
 }
 
-void mapheader_run_first_tag4_script_list_match(void)
+void TryRunOnWarpIntoMapScript(void)
 {
     u8 *ptr = mapheader_get_first_match_from_tagged_ptr_list(4);
     if (ptr)
diff --git a/src/seagallop.c b/src/seagallop.c
index fb55e6bd2..f7405296f 100644
--- a/src/seagallop.c
+++ b/src/seagallop.c
@@ -322,7 +322,7 @@ static void Task_Seagallop_3(void)
     SetWarpDestination(warpInfo[0], warpInfo[1], -1, warpInfo[2], warpInfo[3]);
     PlayRainStoppingSoundEffect();
     PlaySE(SE_KAIDAN);
-    gFieldCallback = FieldCB_UnionRoomWarp;
+    gFieldCallback = FieldCB_DefaultWarpExit;
     WarpIntoMap();
     SetMainCallback2(CB2_LoadMap);
     ResetInitialPlayerAvatarState();
diff --git a/src/strings.c b/src/strings.c
index 547a36138..fbe51254c 100644
--- a/src/strings.c
+++ b/src/strings.c
@@ -958,8 +958,8 @@ const u8 gText_Sorry[] = _("SORRY");
 const u8 gText_YaySmileEmoji[] = _("YAY{EXTRA 0xF9}");
 const u8 gText_ThankYou[] = _("THANK YOU");
 const u8 gText_ByeBye[] = _("BYE-BYE!");
-const u8 gUnknown_841B554[] = _("{PLAYER} scurried to a POKéMON CENTER,\nprotecting the exhausted and fainted\nPOKéMON from further harm‥\p");
-const u8 gUnknown_841B5B6[] = _("{PLAYER} scurried back home, protecting\nthe exhausted and fainted POKéMON from\nfurther harm‥\p");
+const u8 gText_PlayerScurriedToCenter[] = _("{PLAYER} scurried to a POKéMON CENTER,\nprotecting the exhausted and fainted\nPOKéMON from further harm‥\p");
+const u8 gText_PlayerScurriedBackHome[] = _("{PLAYER} scurried back home, protecting\nthe exhausted and fainted POKéMON from\nfurther harm‥\p");
 const u8 gUnknown_841B60E[] = _("PLAYER: {DYNAMIC 0x00}");
 const u8 gUnknown_841B619[] = _("This document is issued in\nrecognition of your magnificent\nachievement - the completion of\nthe {DYNAMIC 0x01} POKéDEX.");
 const u8 gUnknown_841B684[] = _("GAME FREAK");
diff --git a/src/trade.c b/src/trade.c
index bd6860e85..bb2634613 100644
--- a/src/trade.c
+++ b/src/trade.c
@@ -2022,7 +2022,7 @@ static void sub_804E944(void)
             Free(sTradeMenuResourcesPtr);
             FreeAllWindowBuffers();
             DestroyWirelessStatusIndicatorSprite();
-            SetMainCallback2(c2_8056854);
+            SetMainCallback2(CB2_ReturnToFieldFromMultiplayer);
         }
     }
     else
@@ -2032,7 +2032,7 @@ static void sub_804E944(void)
             Free(sSpriteTextTileBuffer);
             Free(sTradeMenuResourcesPtr);
             FreeAllWindowBuffers();
-            SetMainCallback2(c2_8056854);
+            SetMainCallback2(CB2_ReturnToFieldFromMultiplayer);
         }
     }
 }
diff --git a/src/trade_scene.c b/src/trade_scene.c
index d609a9b53..308cd6e5b 100644
--- a/src/trade_scene.c
+++ b/src/trade_scene.c
@@ -2747,7 +2747,7 @@ static void Task_WaitFadeAndStartInGameTradeAnim(u8 taskId)
     if (!gPaletteFade.active)
     {
         SetMainCallback2(CB2_InitTradeAnim_InGameTrade);
-        gFieldCallback = FieldCallback_ReturnToEventScript2;
+        gFieldCallback = FieldCB_ContinueScriptHandleMusic;
         DestroyTask(taskId);
     }
 }
diff --git a/src/vs_seeker.c b/src/vs_seeker.c
index 599e4f9b4..7054a13ed 100644
--- a/src/vs_seeker.c
+++ b/src/vs_seeker.c
@@ -681,7 +681,7 @@ bool8 sub_810C4EC(void)
     return FALSE;
 }
 
-void sub_810C578(void)
+void TryUpdateRandomTrainerRematches(u16 mapGroup, u16 mapNum)
 {
     FlagClear(FLAG_SYS_VS_SEEKER_CHARGING);
     sub_810C640();