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

11 files changed, 3710 insertions, 61 deletions

diff --git a/src/braille_puzzles.c b/src/braille_puzzles.c
index c8055470a..85b2bc509 100755
--- a/src/braille_puzzles.c
+++ b/src/braille_puzzles.c
@@ -13,7 +13,7 @@ extern void DrawWholeMapView(); // field_camera
 extern void SetCameraPanningCallback(void ( *callback)()); // field_camera
 extern void InstallCameraPanAheadCallback(void);
 extern void SetCameraPanning(s16 x, s16 y);
-extern u8 brm_get_pokemon_selection(void);
+extern u8 GetCursorSelectionMonId(void);
 extern void FieldEffectActiveListRemove(u8 id); // field_effect
 extern u8 oei_task_add(void);
 
@@ -220,7 +220,7 @@ bool8 ShouldDoBrailleStrengthEffect(void)
 
 void sub_8179834(void)
 {
-    gFieldEffectArguments[0] = brm_get_pokemon_selection();
+    gFieldEffectArguments[0] = GetCursorSelectionMonId();
     FieldEffectStart(FLDEFF_USE_FLY_ANCIENT_TOMB);
 }
 
@@ -256,7 +256,7 @@ bool8 ShouldDoBrailleFlyEffect(void)
 
 void sub_8179918(void)
 {
-    gFieldEffectArguments[0] = brm_get_pokemon_selection();
+    gFieldEffectArguments[0] = GetCursorSelectionMonId();
     FieldEffectStart(FLDEFF_USE_FLY_ANCIENT_TOMB);
 }
 
diff --git a/src/daycare.c b/src/daycare.c
new file mode 100644
index 000000000..8dd45863a
--- /dev/null
+++ b/src/daycare.c
@@ -0,0 +1,1318 @@
+#include "global.h"
+#include "pokemon.h"
+#include "daycare.h"
+#include "string_util.h"
+#include "species.h"
+#include "items.h"
+#include "mail.h"
+#include "pokemon_storage_system.h"
+#include "event_data.h"
+#include "rng.h"
+#include "main.h"
+#include "moves.h"
+#include "egg_hatch.h"
+#include "text.h"
+#include "menu.h"
+#include "international_string_util.h"
+#include "script.h"
+#include "task.h"
+#include "window.h"
+#include "list_menu.h"
+
+#define EGG_MOVES_ARRAY_COUNT           10
+#define EGG_LVL_UP_MOVES_ARRAY_COUNT    50
+
+extern u16 gMoveToLearn;
+
+// text
+extern const u8 gText_MaleSymbol4[];
+extern const u8 gText_FemaleSymbol4[];
+extern const u8 gText_GenderlessSymbol[];
+extern const u8 gText_NewLine2[];
+extern const u8 gText_Exit4[];
+extern const u8 gText_Lv[];
+extern const u8 gExpandedPlaceholder_Empty[];
+extern const u8 gText_Exit[];
+extern const u8 gDaycareText_GetAlongVeryWell[];
+extern const u8 gDaycareText_GetAlong[];
+extern const u8 gDaycareText_DontLikeOther[];
+extern const u8 gDaycareText_PlayOther[];
+
+extern u8 GetCursorSelectionMonId(void);
+extern u16 ItemIdToBattleMoveId(u16);
+extern s32 ListMenuHandleInput(u8);
+extern void sub_81AE6C8(u8, u16*, u16*);
+extern void sub_819746C(u8, bool8);
+extern void sub_81973FC(u8, bool8);
+extern void sub_81B9328(void);
+extern void sub_81AF078(u32, bool8, struct ListMenu *);
+extern void c2_exit_to_overworld_2_switch(void);
+
+// this file's functions
+static void ClearDaycareMonMisc(struct DaycareMiscMon *misc);
+static void SetInitialEggData(struct Pokemon *mon, u16 species, struct DayCare *daycare);
+static u8 GetDaycareCompatibilityScore(struct DayCare *daycare);
+static void DaycarePrintMonInfo(u8 windowId, s32 daycareSlotId, u8 y);
+
+// RAM buffers used to assist with BuildEggMoveset()
+EWRAM_DATA static u16 sHatchedEggLevelUpMoves[EGG_LVL_UP_MOVES_ARRAY_COUNT] = {0};
+EWRAM_DATA static u16 sHatchedEggFatherMoves[4] = {0};
+EWRAM_DATA static u16 sHatchedEggFinalMoves[4] = {0};
+EWRAM_DATA static u16 sHatchedEggEggMoves[EGG_MOVES_ARRAY_COUNT] = {0};
+EWRAM_DATA static u16 sHatchedEggMotherMoves[4] = {0};
+
+#include "data/pokemon/egg_moves.h"
+
+static const struct WindowTemplate sDaycareLevelMenuWindowTemplate = {0, 0xF, 1, 0xE, 6, 0xF, 8};
+
+static const struct ListMenuItem sLevelMenuItems[] =
+{
+    {gExpandedPlaceholder_Empty, 0},
+    {gExpandedPlaceholder_Empty, 1},
+    {gText_Exit, 5}
+};
+
+static const struct ListMenuTemplate sDaycareListMenuLevelTemplate =
+{
+    .items = sLevelMenuItems,
+    .unk_04 = sub_81AF078,
+    .unk_08 = DaycarePrintMonInfo,
+    .totalItems = 3,
+    .maxShowed = 3,
+    .unk_10 = 0,
+    .unk_11 = 0,
+    .unk_12 = 8,
+    .cursor_Y = 0,
+    .upText_Y = 1,
+    .cursorColor = 2,
+    .fillColor = 1,
+    .cursorShadowColor = 3,
+    .unk_16_0 = TRUE,
+    .spaceBetweenItems = 0,
+    .unk_16_7 = FALSE,
+    .unk_17_0 = 1
+};
+
+static const u8 *const sCompatibilityMessages[] =
+{
+    gDaycareText_GetAlongVeryWell,
+    gDaycareText_GetAlong,
+    gDaycareText_DontLikeOther,
+    gDaycareText_PlayOther
+};
+
+static const u8 sJapaneseEggNickname[] = _("タマゴ"); // "tamago" ("egg" in Japanese)
+
+u8 *GetMonNick(struct Pokemon *mon, u8 *dest)
+{
+    u8 nickname[POKEMON_NAME_LENGTH * 2];
+
+    GetMonData(mon, MON_DATA_NICKNAME, nickname);
+    return StringCopy10(dest, nickname);
+}
+
+u8 *GetBoxMonNick(struct BoxPokemon *mon, u8 *dest)
+{
+    u8 nickname[POKEMON_NAME_LENGTH * 2];
+
+    GetBoxMonData(mon, MON_DATA_NICKNAME, nickname);
+    return StringCopy10(dest, nickname);
+}
+
+u8 CountPokemonInDaycare(struct DayCare *daycare)
+{
+    u8 i, count;
+    count = 0;
+
+    for (i = 0; i < DAYCARE_MON_COUNT; i++)
+    {
+        if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES) != 0)
+            count++;
+    }
+
+    return count;
+}
+
+void InitDaycareMailRecordMixing(struct DayCare *daycare, struct RecordMixingDayCareMail *daycareMail)
+{
+    u8 i;
+    u8 numDaycareMons = 0;
+
+    for (i = 0; i < DAYCARE_MON_COUNT; i++)
+    {
+        if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES) != SPECIES_NONE)
+        {
+            numDaycareMons++;
+            if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_HELD_ITEM) == ITEM_NONE)
+            {
+                daycareMail->holdsItem[i] = FALSE;
+            }
+            else
+            {
+                daycareMail->holdsItem[i] = TRUE;
+            }
+        }
+        else
+        {
+            daycareMail->holdsItem[i] = TRUE;
+        }
+    }
+
+    daycareMail->numDaycareMons = numDaycareMons;
+}
+
+static s8 Daycare_FindEmptySpot(struct DayCare *daycare)
+{
+    u8 i;
+
+    for (i = 0; i < DAYCARE_MON_COUNT; i++)
+    {
+        if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES) == 0)
+            return i;
+    }
+
+    return -1;
+}
+
+static void StorePokemonInDaycare(struct Pokemon *mon, struct DaycareMon *daycareMon)
+{
+    if (MonHasMail(mon))
+    {
+        u8 mailId;
+
+        StringCopy(daycareMon->misc.OT_name, gSaveBlock2Ptr->playerName);
+        GetMonNick(mon, daycareMon->misc.monName);
+        StripExtCtrlCodes(daycareMon->misc.monName);
+        daycareMon->misc.gameLanguage = LANGUAGE_ENGLISH;
+        daycareMon->misc.monLanguage = GetMonData(mon, MON_DATA_LANGUAGE);
+        mailId = GetMonData(mon, MON_DATA_MAIL);
+        daycareMon->misc.mail = gSaveBlock1Ptr->mail[mailId];
+        TakeMailFromMon(mon);
+    }
+
+    daycareMon->mon = mon->box;
+    BoxMonRestorePP(&daycareMon->mon);
+    daycareMon->steps = 0;
+    ZeroMonData(mon);
+    CompactPartySlots();
+    CalculatePlayerPartyCount();
+}
+
+static void StorePokemonInEmptyDaycareSlot(struct Pokemon *mon, struct DayCare *daycare)
+{
+    s8 slotId = Daycare_FindEmptySpot(daycare);
+    StorePokemonInDaycare(mon, &daycare->mons[slotId]);
+}
+
+void StoreSelectedPokemonInDaycare(void)
+{
+    u8 monId = GetCursorSelectionMonId();
+    StorePokemonInEmptyDaycareSlot(&gPlayerParty[monId], &gSaveBlock1Ptr->daycare);
+}
+
+// Shifts the second daycare pokemon slot into the first slot.
+static void ShiftDaycareSlots(struct DayCare *daycare)
+{
+    // This condition is only satisfied when the player takes out the first pokemon from the daycare.
+    if (GetBoxMonData(&daycare->mons[1].mon, MON_DATA_SPECIES) != 0
+        && GetBoxMonData(&daycare->mons[0].mon, MON_DATA_SPECIES) == 0)
+    {
+        daycare->mons[0].mon = daycare->mons[1].mon;
+        ZeroBoxMonData(&daycare->mons[1].mon);
+
+        daycare->mons[0].misc = daycare->mons[1].misc;
+        daycare->mons[0].steps = daycare->mons[1].steps;
+        daycare->mons[1].steps = 0;
+        ClearDaycareMonMisc(&daycare->mons[1].misc);
+    }
+}
+
+static void ApplyDaycareExperience(struct Pokemon *mon)
+{
+    s32 i;
+    bool8 firstMove;
+    u16 learnedMove;
+
+    for (i = 0; i < MAX_MON_LEVEL; i++)
+    {
+        // Add the mon's gained daycare experience level by level until it can't level up anymore.
+        if (TryIncrementMonLevel(mon))
+        {
+            // Teach the mon new moves it learned while in the daycare.
+            firstMove = TRUE;
+            while ((learnedMove = MonTryLearningNewMove(mon, firstMove)) != 0)
+            {
+                firstMove = FALSE;
+                if (learnedMove == 0xFFFF)
+                {
+                    // Mon already knows 4 moves.
+                    DeleteFirstMoveAndGiveMoveToMon(mon, gMoveToLearn);
+                }
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    // Re-calculate the mons stats at its new level.
+    CalculateMonStats(mon);
+}
+
+static u16 TakeSelectedPokemonFromDaycare(struct DaycareMon *daycareMon)
+{
+    u16 species;
+    u32 experience;
+    struct Pokemon pokemon;
+
+    GetBoxMonNick(&daycareMon->mon, gStringVar1);
+    species = GetBoxMonData(&daycareMon->mon, MON_DATA_SPECIES);
+    BoxMonToMon(&daycareMon->mon, &pokemon);
+
+    if (GetMonData(&pokemon, MON_DATA_LEVEL) != MAX_MON_LEVEL)
+    {
+        experience = GetMonData(&pokemon, MON_DATA_EXP) + daycareMon->steps;
+        SetMonData(&pokemon, MON_DATA_EXP, &experience);
+        ApplyDaycareExperience(&pokemon);
+    }
+
+    gPlayerParty[PARTY_SIZE - 1] = pokemon;
+    if (daycareMon->misc.mail.itemId)
+    {
+        GiveMailToMon2(&gPlayerParty[PARTY_SIZE - 1], &daycareMon->misc.mail);
+        ClearDaycareMonMisc(&daycareMon->misc);
+    }
+
+    ZeroBoxMonData(&daycareMon->mon);
+    daycareMon->steps = 0;
+    CompactPartySlots();
+    CalculatePlayerPartyCount();
+    return species;
+}
+
+static u16 TakeSelectedPokemonMonFromDaycareShiftSlots(struct DayCare *daycare, u8 slotId)
+{
+    u16 species = TakeSelectedPokemonFromDaycare(&daycare->mons[slotId]);
+    ShiftDaycareSlots(daycare);
+    return species;
+}
+
+u16 TakePokemonFromDaycare(void)
+{
+    return TakeSelectedPokemonMonFromDaycareShiftSlots(&gSaveBlock1Ptr->daycare, gSpecialVar_0x8004);
+}
+
+static u8 GetLevelAfterDaycareSteps(struct BoxPokemon *mon, u32 steps)
+{
+    struct BoxPokemon tempMon = *mon;
+
+    u32 experience = GetBoxMonData(mon, MON_DATA_EXP) + steps;
+    SetBoxMonData(&tempMon, MON_DATA_EXP,  &experience);
+    return GetLevelFromBoxMonExp(&tempMon);
+}
+
+static u8 GetNumLevelsGainedFromSteps(struct DaycareMon *daycareMon)
+{
+    u8 levelBefore;
+    u8 levelAfter;
+
+    levelBefore = GetLevelFromBoxMonExp(&daycareMon->mon);
+    levelAfter = GetLevelAfterDaycareSteps(&daycareMon->mon, daycareMon->steps);
+    return levelAfter - levelBefore;
+}
+
+static u8 GetNumLevelsGainedForDaycareMon(struct DaycareMon *daycareMon)
+{
+    u8 numLevelsGained = GetNumLevelsGainedFromSteps(daycareMon);
+    ConvertIntToDecimalStringN(gStringVar2, numLevelsGained, STR_CONV_MODE_LEFT_ALIGN, 2);
+    GetBoxMonNick(&daycareMon->mon, gStringVar1);
+    return numLevelsGained;
+}
+
+static u32 GetDaycareCostForSelectedMon(struct DaycareMon *daycareMon)
+{
+    u32 cost;
+
+    u8 numLevelsGained = GetNumLevelsGainedFromSteps(daycareMon);
+    GetBoxMonNick(&daycareMon->mon, gStringVar1);
+    cost = 100 + 100 * numLevelsGained;
+    ConvertIntToDecimalStringN(gStringVar2, cost, STR_CONV_MODE_LEFT_ALIGN, 5);
+    return cost;
+}
+
+static u16 GetDaycareCostForMon(struct DayCare *daycare, u8 slotId)
+{
+    return GetDaycareCostForSelectedMon(&daycare->mons[slotId]);
+}
+
+void GetDaycareCost(void)
+{
+    gSpecialVar_0x8005 = GetDaycareCostForMon(&gSaveBlock1Ptr->daycare, gSpecialVar_0x8004);
+}
+
+static void Debug_AddDaycareSteps(u16 numSteps)
+{
+    gSaveBlock1Ptr->daycare.mons[0].steps += numSteps;
+    gSaveBlock1Ptr->daycare.mons[1].steps += numSteps;
+}
+
+u8 GetNumLevelsGainedFromDaycare(void)
+{
+    if (GetBoxMonData(&gSaveBlock1Ptr->daycare.mons[gSpecialVar_0x8004], MON_DATA_SPECIES) != 0)
+        return GetNumLevelsGainedForDaycareMon(&gSaveBlock1Ptr->daycare.mons[gSpecialVar_0x8004]);
+
+    return 0;
+}
+
+static void ClearDaycareMonMisc(struct DaycareMiscMon *misc)
+{
+    s32 i;
+
+    for (i = 0; i < OT_NAME_LENGTH + 1; i++)
+        misc->OT_name[i] = 0;
+    for (i = 0; i < POKEMON_NAME_LENGTH + 1; i++)
+        misc->monName[i] = 0;
+
+    ClearMailStruct(&misc->mail);
+}
+
+static void ClearDaycareMon(struct DaycareMon *daycareMon)
+{
+    ZeroBoxMonData(&daycareMon->mon);
+    daycareMon->steps = 0;
+    ClearDaycareMonMisc(&daycareMon->misc);
+}
+
+static void ClearAllDaycareData(struct DayCare *daycare)
+{
+    u8 i;
+
+    for (i = 0; i < DAYCARE_MON_COUNT; i++)
+        ClearDaycareMon(&daycare->mons[i]);
+
+    daycare->offspringPersonality = 0;
+    daycare->stepCounter = 0;
+}
+
+// Determines what the species of an Egg would be based on the given species.
+// It determines this by working backwards through the evolution chain of the
+// given species.
+static u16 GetEggSpecies(u16 species)
+{
+    int i, j, k;
+    bool8 found;
+
+    // Working backwards up to 5 times seems arbitrary, since the maximum number
+    // of times would only be 3 for 3-stage evolutions.
+    for (i = 0; i < EVOS_PER_MON; i++)
+    {
+        found = FALSE;
+        for (j = 1; j < NUM_SPECIES; j++)
+        {
+            for (k = 0; k < EVOS_PER_MON; k++)
+            {
+                if (gEvolutionTable[j].evolutions[k].targetSpecies == species)
+                {
+                    species = j;
+                    found = TRUE;
+                    break;
+                }
+            }
+
+            if (found)
+                break;
+        }
+
+        if (j == NUM_SPECIES)
+            break;
+    }
+
+    return species;
+}
+
+static s32 GetSlotToInheritNature(struct DayCare *daycare)
+{
+    u32 species[DAYCARE_MON_COUNT];
+    s32 i;
+    s32 dittoCount;
+    s32 slot = -1;
+
+    // search for female gender
+    for (i = 0; i < DAYCARE_MON_COUNT; i++)
+    {
+        if (GetBoxMonGender(&daycare->mons[i].mon) == MON_FEMALE)
+            slot = i;
+    }
+
+    // search for ditto
+    for (dittoCount = 0, i = 0; i < DAYCARE_MON_COUNT; i++)
+    {
+        species[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES);
+        if (species[i] == SPECIES_DITTO)
+            dittoCount++, slot = i;
+    }
+
+    // coin flip on ...two Dittos
+    if (dittoCount == 2)
+    {
+        if (Random() >= USHRT_MAX / 2)
+            slot = 0;
+        else
+            slot = 1;
+    }
+
+    // nature inheritance only if holds everstone
+    if (GetBoxMonData(&daycare->mons[slot].mon, MON_DATA_HELD_ITEM) != ITEM_EVERSTONE
+        || Random() >= USHRT_MAX / 2)
+    {
+        return -1;
+    }
+
+    return slot;
+}
+
+static void _TriggerPendingDaycareEgg(struct DayCare *daycare)
+{
+    s32 natureSlot;
+    s32 natureTries = 0;
+
+    SeedRng2(gMain.vblankCounter2);
+    natureSlot = GetSlotToInheritNature(daycare);
+
+    if (natureSlot < 0)
+    {
+        daycare->offspringPersonality = (Random2() << 0x10) | ((Random() % 0xfffe) + 1);
+    }
+    else
+    {
+        u8 wantedNature = GetNatureFromPersonality(GetBoxMonData(&daycare->mons[natureSlot].mon, MON_DATA_PERSONALITY, NULL));
+        u32 personality;
+
+        do
+        {
+            personality = (Random2() << 0x10) | (Random());
+            if (wantedNature == GetNatureFromPersonality(personality) && personality != 0)
+                break; // we found a personality with the same nature
+
+            natureTries++;
+        } while (natureTries <= 2400);
+
+        daycare->offspringPersonality = personality;
+    }
+
+    FlagSet(FLAG_PENDING_DAYCARE_EGG);
+}
+
+static void _TriggerPendingDaycareMaleEgg(struct DayCare *daycare)
+{
+    daycare->offspringPersonality = (Random()) | (0x8000);
+    FlagSet(FLAG_PENDING_DAYCARE_EGG);
+}
+
+void TriggerPendingDaycareEgg(void)
+{
+    _TriggerPendingDaycareEgg(&gSaveBlock1Ptr->daycare);
+}
+
+static void TriggerPendingDaycareMaleEgg(void)
+{
+    _TriggerPendingDaycareMaleEgg(&gSaveBlock1Ptr->daycare);
+}
+
+// Removes the selected index from the given IV list and shifts the remaining
+// elements to the left.
+static void RemoveIVIndexFromList(u8 *ivs, u8 selectedIv)
+{
+    s32 i, j;
+    u8 temp[NUM_STATS];
+
+    ivs[selectedIv] = 0xff;
+    for (i = 0; i < NUM_STATS; i++)
+    {
+        temp[i] = ivs[i];
+    }
+
+    j = 0;
+    for (i = 0; i < NUM_STATS; i++)
+    {
+        if (temp[i] != 0xff)
+            ivs[j++] = temp[i];
+    }
+}
+
+static void InheritIVs(struct Pokemon *egg, struct DayCare *daycare)
+{
+    u8 i;
+    u8 selectedIvs[3];
+    u8 availableIVs[NUM_STATS];
+    u8 whichParent[ARRAY_COUNT(selectedIvs)];
+    u8 iv;
+
+    // Initialize a list of IV indices.
+    for (i = 0; i < NUM_STATS; i++)
+    {
+        availableIVs[i] = i;
+    }
+
+    // Select the 3 IVs that will be inherited.
+    for (i = 0; i < ARRAY_COUNT(selectedIvs); i++)
+    {
+        // Randomly pick an IV from the available list.
+        selectedIvs[i] = availableIVs[Random() % (NUM_STATS - i)];
+
+        // Remove the selected IV index from the available IV indices.
+        RemoveIVIndexFromList(availableIVs, i);
+    }
+
+    // Determine which parent each of the selected IVs should inherit from.
+    for (i = 0; i < ARRAY_COUNT(selectedIvs); i++)
+    {
+        whichParent[i] = Random() % 2;
+    }
+
+    // Set each of inherited IVs on the egg mon.
+    for (i = 0; i < ARRAY_COUNT(selectedIvs); i++)
+    {
+        switch (selectedIvs[i])
+        {
+            case 0:
+                iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_HP_IV);
+                SetMonData(egg, MON_DATA_HP_IV, &iv);
+                break;
+            case 1:
+                iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_ATK_IV);
+                SetMonData(egg, MON_DATA_ATK_IV, &iv);
+                break;
+            case 2:
+                iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_DEF_IV);
+                SetMonData(egg, MON_DATA_DEF_IV, &iv);
+                break;
+            case 3:
+                iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_SPEED_IV);
+                SetMonData(egg, MON_DATA_SPEED_IV, &iv);
+                break;
+            case 4:
+                iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_SPATK_IV);
+                SetMonData(egg, MON_DATA_SPATK_IV, &iv);
+                break;
+            case 5:
+                iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_SPDEF_IV);
+                SetMonData(egg, MON_DATA_SPDEF_IV, &iv);
+                break;
+        }
+    }
+}
+
+// Counts the number of egg moves a pokemon learns and stores the moves in
+// the given array.
+static u8 GetEggMoves(struct Pokemon *pokemon, u16 *eggMoves)
+{
+    u16 eggMoveIdx;
+    u16 numEggMoves;
+    u16 species;
+    u16 i;
+
+    numEggMoves = 0;
+    eggMoveIdx = 0;
+    species = GetMonData(pokemon, MON_DATA_SPECIES);
+    for (i = 0; i < ARRAY_COUNT(gEggMoves) - 1; i++)
+    {
+        if (gEggMoves[i] == species + EGG_MOVES_SPECIES_OFFSET)
+        {
+            eggMoveIdx = i + 1;
+            break;
+        }
+    }
+
+    for (i = 0; i < EGG_MOVES_ARRAY_COUNT; i++)
+    {
+        if (gEggMoves[eggMoveIdx + i] > EGG_MOVES_SPECIES_OFFSET)
+        {
+            // TODO: the curly braces around this if statement are required for a matching build.
+            break;
+        }
+
+        eggMoves[i] = gEggMoves[eggMoveIdx + i];
+        numEggMoves++;
+    }
+
+    return numEggMoves;
+}
+
+static void BuildEggMoveset(struct Pokemon *egg, struct BoxPokemon *father, struct BoxPokemon *mother)
+{
+    u16 numSharedParentMoves;
+    u32 numLevelUpMoves;
+    u16 numEggMoves;
+    u16 i, j;
+
+    numSharedParentMoves = 0;
+    for (i = 0; i < 4; i++)
+    {
+        sHatchedEggMotherMoves[i] = 0;
+        sHatchedEggFatherMoves[i] = 0;
+        sHatchedEggFinalMoves[i] = 0;
+    }
+    for (i = 0; i < EGG_MOVES_ARRAY_COUNT; i++)
+        sHatchedEggEggMoves[i] = 0;
+    for (i = 0; i < EGG_LVL_UP_MOVES_ARRAY_COUNT; i++)
+        sHatchedEggLevelUpMoves[i] = 0;
+
+    numLevelUpMoves = GetLevelUpMovesBySpecies(GetMonData(egg, MON_DATA_SPECIES), sHatchedEggLevelUpMoves);
+    for (i = 0; i < 4; i++)
+    {
+        sHatchedEggFatherMoves[i] = GetBoxMonData(father, MON_DATA_MOVE1 + i);
+        sHatchedEggMotherMoves[i] = GetBoxMonData(mother, MON_DATA_MOVE1 + i);
+    }
+
+    numEggMoves = GetEggMoves(egg, sHatchedEggEggMoves);
+
+    for (i = 0; i < 4; i++)
+    {
+        if (sHatchedEggFatherMoves[i] != MOVE_NONE)
+        {
+            for (j = 0; j < numEggMoves; j++)
+            {
+                if (sHatchedEggFatherMoves[i] == sHatchedEggEggMoves[j])
+                {
+                    if (GiveMoveToMon(egg, sHatchedEggFatherMoves[i]) == 0xffff)
+                        DeleteFirstMoveAndGiveMoveToMon(egg, sHatchedEggFatherMoves[i]);
+                    break;
+                }
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+    for (i = 0; i < 4; i++)
+    {
+        if (sHatchedEggFatherMoves[i] != MOVE_NONE)
+        {
+            for (j = 0; j < NUM_TECHNICAL_MACHINES + NUM_HIDDEN_MACHINES; j++)
+            {
+                if (sHatchedEggFatherMoves[i] == ItemIdToBattleMoveId(ITEM_TM01 + j) && CanMonLearnTMHM(egg, j))
+                {
+                    if (GiveMoveToMon(egg, sHatchedEggFatherMoves[i]) == 0xffff)
+                        DeleteFirstMoveAndGiveMoveToMon(egg, sHatchedEggFatherMoves[i]);
+                }
+            }
+        }
+    }
+    for (i = 0; i < 4; i++)
+    {
+        if (sHatchedEggFatherMoves[i] == MOVE_NONE)
+            break;
+        for (j = 0; j < 4; j++)
+        {
+            if (sHatchedEggFatherMoves[i] == sHatchedEggMotherMoves[j] && sHatchedEggFatherMoves[i] != MOVE_NONE)
+                sHatchedEggFinalMoves[numSharedParentMoves++] = sHatchedEggFatherMoves[i];
+        }
+    }
+
+    for (i = 0; i < 4; i++)
+    {
+        if (sHatchedEggFinalMoves[i] == MOVE_NONE)
+            break;
+        for (j = 0; j < numLevelUpMoves; j++)
+        {
+            if (sHatchedEggLevelUpMoves[j] != MOVE_NONE && sHatchedEggFinalMoves[i] == sHatchedEggLevelUpMoves[j])
+            {
+                if (GiveMoveToMon(egg, sHatchedEggFinalMoves[i]) == 0xffff)
+                    DeleteFirstMoveAndGiveMoveToMon(egg, sHatchedEggFinalMoves[i]);
+                break;
+            }
+        }
+    }
+}
+
+static void RemoveEggFromDayCare(struct DayCare *daycare)
+{
+    daycare->offspringPersonality = 0;
+    daycare->stepCounter = 0;
+}
+
+void RejectEggFromDayCare(void)
+{
+    RemoveEggFromDayCare(&gSaveBlock1Ptr->daycare);
+}
+
+static void AlterEggSpeciesWithIncenseItem(u16 *species, struct DayCare *daycare)
+{
+    u16 motherItem, fatherItem;
+    if (*species == SPECIES_WYNAUT || *species == SPECIES_AZURILL)
+    {
+        motherItem = GetBoxMonData(&daycare->mons[0].mon, MON_DATA_HELD_ITEM);
+        fatherItem = GetBoxMonData(&daycare->mons[1].mon, MON_DATA_HELD_ITEM);
+        if (*species == SPECIES_WYNAUT && motherItem != ITEM_LAX_INCENSE && fatherItem != ITEM_LAX_INCENSE)
+        {
+            *species = SPECIES_WOBBUFFET;
+        }
+
+        if (*species == SPECIES_AZURILL && motherItem != ITEM_SEA_INCENSE && fatherItem != ITEM_SEA_INCENSE)
+        {
+            *species = SPECIES_MARILL;
+        }
+    }
+}
+
+static void GiveVoltTackleIfLightBall(struct Pokemon *mon, struct DayCare *daycare)
+{
+    u32 motherItem = GetBoxMonData(&daycare->mons[0].mon, MON_DATA_HELD_ITEM);
+    u32 fatherItem = GetBoxMonData(&daycare->mons[1].mon, MON_DATA_HELD_ITEM);
+
+    if (motherItem == ITEM_LIGHT_BALL || fatherItem == ITEM_LIGHT_BALL)
+    {
+        if (GiveMoveToMon(mon, MOVE_VOLT_TACKLE) == 0xFFFF)
+            DeleteFirstMoveAndGiveMoveToMon(mon, MOVE_VOLT_TACKLE);
+    }
+}
+
+static u16 DetermineEggSpeciesAndParentSlots(struct DayCare *daycare, u8 *parentSlots)
+{
+    u16 i;
+    u16 species[2];
+    u16 eggSpecies;
+
+    // Determine which of the daycare mons is the mother and father of the egg.
+    // The 0th index of the parentSlots array is considered the mother slot, and the
+    // 1st index is the father slot.
+    for (i = 0; i < 2; i++)
+    {
+        species[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES);
+        if (species[i] == SPECIES_DITTO)
+        {
+            parentSlots[0] = i ^ 1;
+            parentSlots[1] = i;
+        }
+        else if (GetBoxMonGender(&daycare->mons[i].mon) == MON_FEMALE)
+        {
+            parentSlots[0] = i;
+            parentSlots[1] = i ^ 1;
+        }
+    }
+
+    eggSpecies = GetEggSpecies(species[parentSlots[0]]);
+    if (eggSpecies == SPECIES_NIDORAN_F && daycare->offspringPersonality & 0x8000)
+    {
+        eggSpecies = SPECIES_NIDORAN_M;
+    }
+    if (eggSpecies == SPECIES_ILLUMISE && daycare->offspringPersonality & 0x8000)
+    {
+        eggSpecies = SPECIES_VOLBEAT;
+    }
+
+    // Make Ditto the "mother" slot if the other daycare mon is male.
+    if (species[parentSlots[1]] == SPECIES_DITTO && GetBoxMonGender(&daycare->mons[parentSlots[0]].mon) != MON_FEMALE)
+    {
+        u8 temp = parentSlots[1];
+        parentSlots[1] = parentSlots[0];
+        parentSlots[0] = temp;
+    }
+
+    return eggSpecies;
+}
+
+static void _GiveEggFromDaycare(struct DayCare *daycare) // give_egg
+{
+    struct Pokemon egg;
+    u16 species;
+    u8 parentSlots[2]; // 0th index is "mother" daycare slot, 1st is "father"
+    bool8 isEgg;
+
+    species = DetermineEggSpeciesAndParentSlots(daycare, parentSlots);
+    AlterEggSpeciesWithIncenseItem(&species, daycare);
+    SetInitialEggData(&egg, species, daycare);
+    InheritIVs(&egg, daycare);
+    BuildEggMoveset(&egg, &daycare->mons[parentSlots[1]].mon, &daycare->mons[parentSlots[0]].mon);
+
+    if (species == SPECIES_PICHU)
+        GiveVoltTackleIfLightBall(&egg, daycare);
+
+    isEgg = TRUE;
+    SetMonData(&egg, MON_DATA_IS_EGG, &isEgg);
+    gPlayerParty[PARTY_SIZE - 1] = egg;
+    CompactPartySlots();
+    CalculatePlayerPartyCount();
+    RemoveEggFromDayCare(daycare);
+}
+
+void CreateEgg(struct Pokemon *mon, u16 species, bool8 setHotSpringsLocation)
+{
+    u8 metLevel;
+    u16 ball;
+    u8 language;
+    u8 metLocation;
+    u8 isEgg;
+
+    CreateMon(mon, species, EGG_HATCH_LEVEL, 0x20, FALSE, 0, FALSE, 0);
+    metLevel = 0;
+    ball = ITEM_POKE_BALL;
+    language = LANGUAGE_JAPANESE;
+    SetMonData(mon, MON_DATA_POKEBALL, &ball);
+    SetMonData(mon, MON_DATA_NICKNAME, sJapaneseEggNickname);
+    SetMonData(mon, MON_DATA_FRIENDSHIP, &gBaseStats[species].eggCycles);
+    SetMonData(mon, MON_DATA_MET_LEVEL, &metLevel);
+    SetMonData(mon, MON_DATA_LANGUAGE, &language);
+    if (setHotSpringsLocation)
+    {
+        metLocation = 253; // hot springs; see PokemonSummaryScreen_PrintEggTrainerMemo
+        SetMonData(mon, MON_DATA_MET_LOCATION, &metLocation);
+    }
+
+    isEgg = TRUE;
+    SetMonData(mon, MON_DATA_IS_EGG, &isEgg);
+}
+
+static void SetInitialEggData(struct Pokemon *mon, u16 species, struct DayCare *daycare)
+{
+    u32 personality;
+    u16 ball;
+    u8 metLevel;
+    u8 language;
+
+    personality = daycare->offspringPersonality;
+    CreateMon(mon, species, EGG_HATCH_LEVEL, 0x20, TRUE, personality, FALSE, 0);
+    metLevel = 0;
+    ball = ITEM_POKE_BALL;
+    language = LANGUAGE_JAPANESE;
+    SetMonData(mon, MON_DATA_POKEBALL, &ball);
+    SetMonData(mon, MON_DATA_NICKNAME, sJapaneseEggNickname);
+    SetMonData(mon, MON_DATA_FRIENDSHIP, &gBaseStats[species].eggCycles);
+    SetMonData(mon, MON_DATA_MET_LEVEL, &metLevel);
+    SetMonData(mon, MON_DATA_LANGUAGE, &language);
+}
+
+void GiveEggFromDaycare(void)
+{
+    _GiveEggFromDaycare(&gSaveBlock1Ptr->daycare);
+}
+
+static bool8 _DoEggActions_CheckHatch(struct DayCare *daycare)
+{
+    u32 i, validEggs = 0;
+
+    for (i = 0; i < DAYCARE_MON_COUNT; i++)
+    {
+        if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SANITY_BIT2))
+            daycare->mons[i].steps++, validEggs++;
+    }
+
+    // try to trigger poke sex
+    if (daycare->offspringPersonality == 0 && validEggs == 2 && (daycare->mons[1].steps & 0xFF) == 0xFF)
+    {
+        u8 loveScore = GetDaycareCompatibilityScore(daycare);
+        if (loveScore > (Random() * 100u) / USHRT_MAX)
+            TriggerPendingDaycareEgg();
+    }
+
+    if (++daycare->stepCounter == 255) // hatch an egg
+    {
+        u32 steps;
+        u8 toSub = GetEggStepsToSubtract();
+
+        for (i = 0; i < gPlayerPartyCount; i++)
+        {
+            if (!GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
+                continue;
+            if (GetMonData(&gPlayerParty[i], MON_DATA_SANITY_BIT1))
+                continue;
+
+            steps = GetMonData(&gPlayerParty[i], MON_DATA_FRIENDSHIP);
+            if (steps != 0) // subtract needed steps
+            {
+                if (steps >= toSub)
+                    steps -= toSub;
+                else
+                    steps -= 1;
+
+                SetMonData(&gPlayerParty[i], MON_DATA_FRIENDSHIP, &steps);
+            }
+            else // hatch the egg
+            {
+                gSpecialVar_0x8004 = i;
+                return TRUE;
+            }
+        }
+    }
+
+    return FALSE; // no hatching
+}
+
+bool8 DoEggActions_CheckHatch(void)
+{
+    return _DoEggActions_CheckHatch(&gSaveBlock1Ptr->daycare);
+}
+
+static bool8 IsEggPending(struct DayCare *daycare)
+{
+    return (daycare->offspringPersonality != 0);
+}
+
+// gStringVar1 = first mon's nickname
+// gStringVar2 = second mon's nickname
+// gStringVar3 = first mon trainer's name
+static void _GetDaycareMonNicknames(struct DayCare *daycare)
+{
+    u8 text[12];
+    if (GetBoxMonData(&daycare->mons[0].mon, MON_DATA_SPECIES) != 0)
+    {
+        GetBoxMonNick(&daycare->mons[0].mon, gStringVar1);
+        GetBoxMonData(&daycare->mons[0].mon, MON_DATA_OT_NAME, text);
+        StringCopy(gStringVar3, text);
+    }
+
+    if (GetBoxMonData(&daycare->mons[1].mon, MON_DATA_SPECIES) != 0)
+    {
+        GetBoxMonNick(&daycare->mons[1].mon, gStringVar2);
+    }
+}
+
+u16 GetSelectedMonNickAndSpecies(void)
+{
+    GetBoxMonNick(&gPlayerParty[GetCursorSelectionMonId()].box, gStringVar1);
+    return GetBoxMonData(&gPlayerParty[GetCursorSelectionMonId()].box, MON_DATA_SPECIES);
+}
+
+void GetDaycareMonNicknames(void)
+{
+    _GetDaycareMonNicknames(&gSaveBlock1Ptr->daycare);
+}
+
+u8 GetDaycareState(void)
+{
+    // The daycare can be in 4 possible states:
+    //   0: default state--no deposited mons, no egg
+    //   1: there is an egg waiting for the player to pick it up
+    //   2: there is a single pokemon in the daycare
+    //   3: there are two pokemon in the daycare, no egg
+
+    u8 numMons;
+    if (IsEggPending(&gSaveBlock1Ptr->daycare))
+    {
+        // There is an Egg waiting for the player.
+        return 1;
+    }
+
+    numMons = CountPokemonInDaycare(&gSaveBlock1Ptr->daycare);
+    if (numMons != 0)
+    {
+        return numMons + 1;
+    }
+
+    return 0;
+}
+
+static u8 GetDaycarePokemonCount(void)
+{
+    u8 ret = CountPokemonInDaycare(&gSaveBlock1Ptr->daycare);
+    if (ret)
+        return ret;
+
+    return 0;
+}
+
+static bool8 EggGroupsOverlap(u16 *eggGroups1, u16 *eggGroups2)
+{
+    // Determine if the two given egg group lists contain any of the
+    // same egg groups.
+    s32 i, j;
+
+    for (i = 0; i < 2; i++)
+    {
+        for (j = 0; j < 2; j++)
+        {
+            if (eggGroups1[i] == eggGroups2[j])
+                return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+static u8 GetDaycareCompatibilityScore(struct DayCare *daycare)
+{
+    u32 i;
+    u16 eggGroups[2][2];
+    u16 species[2];
+    u32 trainerIds[2];
+    u32 genders[2];
+
+    for (i = 0; i < 2; i++)
+    {
+        u32 personality;
+
+        species[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES);
+        trainerIds[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_OT_ID);
+        personality = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_PERSONALITY);
+        genders[i] = GetGenderFromSpeciesAndPersonality(species[i], personality);
+        eggGroups[i][0] = gBaseStats[species[i]].eggGroup1;
+        eggGroups[i][1] = gBaseStats[species[i]].eggGroup2;
+    }
+
+    // check unbreedable egg group
+    if (eggGroups[0][0] == EGG_GROUP_UNDISCOVERED || eggGroups[1][0] == EGG_GROUP_UNDISCOVERED)
+        return 0;
+    // two Ditto can't breed
+    if (eggGroups[0][0] == EGG_GROUP_DITTO && eggGroups[1][0] == EGG_GROUP_DITTO)
+        return 0;
+
+    // now that we checked, one ditto can breed with any other mon
+    if (eggGroups[0][0] == EGG_GROUP_DITTO || eggGroups[1][0] == EGG_GROUP_DITTO)
+    {
+        if (trainerIds[0] == trainerIds[1]) // same trainer
+            return 20;
+
+        return 50; // different trainers, more chance of poke sex
+    }
+    else
+    {
+        if (genders[0] == genders[1]) // no homo
+            return 0;
+        if (genders[0] == MON_GENDERLESS || genders[1] == MON_GENDERLESS)
+            return 0;
+        if (!EggGroupsOverlap(eggGroups[0], eggGroups[1])) // not compatible with each other
+            return 0;
+
+        if (species[0] == species[1]) // same species
+        {
+            if (trainerIds[0] == trainerIds[1]) // same species and trainer
+                return 50;
+
+            return 70; // different trainers, same species
+        }
+        else
+        {
+            if (trainerIds[0] != trainerIds[1]) // different trainers, different species
+                return 50;
+
+            return 20; // different species, same trainer
+        }
+    }
+}
+
+static u8 GetDaycareCompatibilityScoreFromSave(void)
+{
+    return GetDaycareCompatibilityScore(&gSaveBlock1Ptr->daycare);
+}
+
+void SetDaycareCompatibilityString(void)
+{
+    u8 whichString;
+    u8 relationshipScore;
+
+    relationshipScore = GetDaycareCompatibilityScoreFromSave();
+    whichString = 0;
+    if (relationshipScore == 0)
+        whichString = 3;
+    if (relationshipScore == 20)
+        whichString = 2;
+    if (relationshipScore == 50)
+        whichString = 1;
+    if (relationshipScore == 70)
+        whichString = 0;
+
+    StringCopy(gStringVar4, sCompatibilityMessages[whichString]);
+}
+
+bool8 NameHasGenderSymbol(const u8 *name, u8 genderRatio)
+{
+    u8 i;
+    u8 symbolsCount[2]; // male, female
+    symbolsCount[0] = symbolsCount[1] = 0;
+
+    for (i = 0; name[i] != EOS; i++)
+    {
+        if (name[i] == CHAR_MALE)
+            symbolsCount[0]++;
+        if (name[i] == CHAR_FEMALE)
+            symbolsCount[1]++;
+    }
+
+    if (genderRatio == MON_MALE   && symbolsCount[0] != 0 && symbolsCount[1] == 0)
+        return TRUE;
+    if (genderRatio == MON_FEMALE && symbolsCount[1] != 0 && symbolsCount[0] == 0)
+        return TRUE;
+
+    return FALSE;
+}
+
+static u8 *AppendGenderSymbol(u8 *name, u8 gender)
+{
+    if (gender == MON_MALE)
+    {
+        if (!NameHasGenderSymbol(name, MON_MALE))
+            return StringAppend(name, gText_MaleSymbol4);
+    }
+    else if (gender == MON_FEMALE)
+    {
+        if (!NameHasGenderSymbol(name, MON_FEMALE))
+            return StringAppend(name, gText_FemaleSymbol4);
+    }
+
+    return StringAppend(name, gText_GenderlessSymbol);
+}
+
+static u8 *AppendMonGenderSymbol(u8 *name, struct BoxPokemon *boxMon)
+{
+    return AppendGenderSymbol(name, GetBoxMonGender(boxMon));
+}
+
+static void GetDaycareLevelMenuText(struct DayCare *daycare, u8 *dest)
+{
+    u8 monNames[2][20];
+    u8 i;
+
+    *dest = EOS;
+    for (i = 0; i < 2; i++)
+    {
+        GetBoxMonNick(&daycare->mons[i].mon, monNames[i]);
+        AppendMonGenderSymbol(monNames[i], &daycare->mons[i].mon);
+    }
+
+    StringCopy(dest, monNames[0]);
+    StringAppend(dest, gText_NewLine2);
+    StringAppend(dest, monNames[1]);
+    StringAppend(dest, gText_NewLine2);
+    StringAppend(dest, gText_Exit4);
+}
+
+static void GetDaycareLevelMenuLevelText(struct DayCare *daycare, u8 *dest)
+{
+    u8 i;
+    u8 level;
+    u8 text[20];
+
+    *dest = EOS;
+    for (i = 0; i < 2; i++)
+    {
+        StringAppend(dest, gText_Lv);
+        level = GetLevelAfterDaycareSteps(&daycare->mons[i].mon, daycare->mons[i].steps);
+        ConvertIntToDecimalStringN(text, level, STR_CONV_MODE_LEFT_ALIGN, 3);
+        StringAppend(dest, text);
+        StringAppend(dest, gText_NewLine2);
+    }
+}
+
+static void DaycareAddTextPrinter(u8 windowId, const u8 *text, u32 x, u32 y)
+{
+    struct TextSubPrinter printer;
+
+    printer.current_text_offset = text;
+    printer.windowId = windowId;
+    printer.fontId = 1;
+    printer.x = x;
+    printer.y = y;
+    printer.currentX = x;
+    printer.currentY = y;
+    printer.fontColor_l = 0;
+    gTextFlags.flag_1 = 0;
+    printer.letterSpacing = 0;
+    printer.lineSpacing = 1;
+    printer.fontColor_h = 2;
+    printer.bgColor = 1;
+    printer.shadowColor = 3;
+
+    AddTextPrinter(&printer, 0xFF, NULL);
+}
+
+static void DaycarePrintMonNick(struct DayCare *daycare, u8 windowId, u32 daycareSlotId, u32 y)
+{
+    u8 nick[POKEMON_NAME_LENGTH * 2];
+
+    GetBoxMonNick(&daycare->mons[daycareSlotId].mon, nick);
+    AppendMonGenderSymbol(nick, &daycare->mons[daycareSlotId].mon);
+    DaycareAddTextPrinter(windowId, nick, 8, y);
+}
+
+static void DaycarePrintMonLvl(struct DayCare *daycare, u8 windowId, u32 daycareSlotId, u32 y)
+{
+    u8 level;
+    u32 x;
+    u8 lvlText[12];
+    u8 intText[8];
+
+    StringCopy(lvlText, gText_Lv);
+    level = GetLevelAfterDaycareSteps(&daycare->mons[daycareSlotId].mon, daycare->mons[daycareSlotId].steps);
+    ConvertIntToDecimalStringN(intText, level, STR_CONV_MODE_LEFT_ALIGN, 3);
+    StringAppend(lvlText, intText);
+    x = GetStringRightAlignXOffset(1, lvlText, 112);
+    DaycareAddTextPrinter(windowId, lvlText, x, y);
+}
+
+static void DaycarePrintMonInfo(u8 windowId, s32 daycareSlotId, u8 y)
+{
+    if (daycareSlotId < (unsigned) DAYCARE_MON_COUNT)
+    {
+        DaycarePrintMonNick(&gSaveBlock1Ptr->daycare, windowId, daycareSlotId, y);
+        DaycarePrintMonLvl(&gSaveBlock1Ptr->daycare, windowId, daycareSlotId, y);
+    }
+}
+
+#define tMenuListTaskId     data[0]
+#define tWindowId           data[1]
+
+static void Task_HandleDaycareLevelMenuInput(u8 taskId)
+{
+    u32 var = ListMenuHandleInput(gTasks[taskId].tMenuListTaskId);
+
+    if (gMain.newKeys & A_BUTTON)
+    {
+        switch (var)
+        {
+        case 0:
+        case 1:
+            gSpecialVar_Result = var;
+            break;
+        case 5:
+            gSpecialVar_Result = 2;
+            break;
+        }
+        sub_81AE6C8(gTasks[taskId].tMenuListTaskId, NULL, NULL);
+        sub_819746C(gTasks[taskId].tWindowId, TRUE);
+        RemoveWindow(gTasks[taskId].tWindowId);
+        DestroyTask(taskId);
+        EnableBothScriptContexts();
+    }
+    else if (gMain.newKeys & B_BUTTON)
+    {
+        gSpecialVar_Result = 2;
+        sub_81AE6C8(gTasks[taskId].tMenuListTaskId, NULL, NULL);
+        sub_819746C(gTasks[taskId].tWindowId, TRUE);
+        RemoveWindow(gTasks[taskId].tWindowId);
+        DestroyTask(taskId);
+        EnableBothScriptContexts();
+    }
+}
+
+void ShowDaycareLevelMenu(void)
+{
+    struct ListMenuTemplate menuTemplate;
+    u8 windowId;
+    u8 listMenuTaskId;
+    u8 daycareMenuTaskId;
+
+    windowId = AddWindow(&sDaycareLevelMenuWindowTemplate);
+    sub_81973FC(windowId, FALSE);
+
+    menuTemplate = sDaycareListMenuLevelTemplate;
+    menuTemplate.unk_10 = windowId;
+    listMenuTaskId = ListMenuInit(&menuTemplate, 0, 0);
+
+    CopyWindowToVram(windowId, 3);
+
+    daycareMenuTaskId = CreateTask(Task_HandleDaycareLevelMenuInput, 3);
+    gTasks[daycareMenuTaskId].tMenuListTaskId = listMenuTaskId;
+    gTasks[daycareMenuTaskId].tWindowId = windowId;
+}
+
+#undef tMenuListTaskId
+#undef tWindowId
+
+void ChooseSendDaycareMon(void)
+{
+    sub_81B9328();
+    gMain.savedCallback = c2_exit_to_overworld_2_switch;
+}
diff --git a/src/decoration.c b/src/decoration.c
index 37cabf652..adcdc583b 100644
--- a/src/decoration.c
+++ b/src/decoration.c
@@ -1,5 +1,3 @@
-
-// Includes
 #include "global.h"
 #include "decompress.h"
 #include "malloc.h"
@@ -68,27 +66,27 @@ struct DecorRearrangementDataBuffer {
 // Static RAM declarations
 
 EWRAM_DATA u8 *gCurDecorInventoryItems = NULL;
-EWRAM_DATA u8 sSecretBasePCMenuCursorPos = 0;
-EWRAM_DATA u8 sCurDecorCatCount = 0;
-EWRAM_DATA u8 sSecretBaseItemsIndicesBuffer[16] = {};
-EWRAM_DATA u8 sPlayerRoomItemsIndicesBuffer[12] = {};
-EWRAM_DATA u16 sSecretBasePCSelectDecorLineNo = 0;
-EWRAM_DATA u16 sSecretBasePCSelectDecorPageNo = 0;
+EWRAM_DATA static u8 sSecretBasePCMenuCursorPos = 0;
+EWRAM_DATA static u8 sCurDecorCatCount = 0;
+EWRAM_DATA static u8 sSecretBaseItemsIndicesBuffer[16] = {};
+EWRAM_DATA static u8 sPlayerRoomItemsIndicesBuffer[12] = {};
+EWRAM_DATA static u16 sSecretBasePCSelectDecorLineNo = 0;
+EWRAM_DATA static u16 sSecretBasePCSelectDecorPageNo = 0;
 EWRAM_DATA u8 gCurDecorationIndex = 0;
-EWRAM_DATA u8 sCurDecorationCategory = DECORCAT_DESK;
-EWRAM_DATA u32 filler_0203a174[2] = {};
+EWRAM_DATA static u8 sCurDecorationCategory = DECORCAT_DESK;
+EWRAM_DATA static u32 filler_0203a174[2] = {};
 EWRAM_DATA struct DecorPCPointers gUnknown_0203A17C = {};
-EWRAM_DATA u8 sDecorMenuWindowIndices[4] = {};
+EWRAM_DATA static u8 sDecorMenuWindowIndices[4] = {};
 EWRAM_DATA struct DecorPCBuffer *sDecorPCBuffer = NULL;
 EWRAM_DATA struct PlaceDecorationGraphicsDataBuffer sPlaceDecorationGraphicsDataBuffer = {};
-EWRAM_DATA u16 sCurDecorMapX = 0;
-EWRAM_DATA u16 sCurDecorMapY = 0;
-EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx1 = 0;
-EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx2 = 0;
-EWRAM_DATA u8 sDecorationLastDirectionMoved = 0;
-EWRAM_DATA struct OamData sDecorSelectorOam = {};
-EWRAM_DATA struct DecorRearrangementDataBuffer sDecorRearrangementDataBuffer[16] = {};
-EWRAM_DATA u8 sCurDecorSelectedInRearrangement = 0;
+EWRAM_DATA static u16 sCurDecorMapX = 0;
+EWRAM_DATA static u16 sCurDecorMapY = 0;
+EWRAM_DATA static u8 sDecor_CameraSpriteObjectIdx1 = 0;
+EWRAM_DATA static u8 sDecor_CameraSpriteObjectIdx2 = 0;
+EWRAM_DATA static u8 sDecorationLastDirectionMoved = 0;
+EWRAM_DATA static struct OamData sDecorSelectorOam = {};
+EWRAM_DATA static struct DecorRearrangementDataBuffer sDecorRearrangementDataBuffer[16] = {};
+EWRAM_DATA static u8 sCurDecorSelectedInRearrangement = 0;
 
 // Static ROM declarations
 
@@ -800,9 +798,9 @@ void sub_8127330(u8 taskId)
     sDecorPCBuffer->items[i].unk_04 = -2;
     gUnknown_03006310 = gUnknown_085A6BD0;
     gUnknown_03006310.unk_10 = sDecorMenuWindowIndices[1];
-    gUnknown_03006310.unk_0c = sDecorPCBuffer->unk_520;
-    gUnknown_03006310.unk_00 = sDecorPCBuffer->items;
-    gUnknown_03006310.unk_0e = sDecorPCBuffer->unk_521;
+    gUnknown_03006310.totalItems = sDecorPCBuffer->unk_520;
+    gUnknown_03006310.items = sDecorPCBuffer->items;
+    gUnknown_03006310.maxShowed = sDecorPCBuffer->unk_521;
 }
 
 void sub_8127454(u8 *dest, u16 decorId)
@@ -1603,7 +1601,7 @@ void sub_81289F0(u8 taskId)
         ScriptContext1_SetupScript(EventScript_275D1F);
     }
     gSprites[sDecor_CameraSpriteObjectIdx1].pos1.y += 2;
-    if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE)
+    if (gMapHeader.regionMapSectionId == MAPSEC_SECRET_BASE)
     {
         TV_PutSecretBaseVisitOnTheAir();
     }
@@ -2222,7 +2220,7 @@ void sub_81298EC(u8 taskId)
             {
                 StringExpandPlaceholders(gStringVar4, gText_DecorationReturnedToPC);
                 DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64);
-                if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE)
+                if (gMapHeader.regionMapSectionId == MAPSEC_SECRET_BASE)
                 {
                     TV_PutSecretBaseVisitOnTheAir();
                 }
diff --git a/src/egg_hatch.c b/src/egg_hatch.c
index 589e8901d..a3f7c2ab0 100644
--- a/src/egg_hatch.c
+++ b/src/egg_hatch.c
@@ -1,5 +1,6 @@
 #include "global.h"
 #include "pokemon.h"
+#include "egg_hatch.h"
 #include "pokedex.h"
 #include "items.h"
 #include "script.h"
@@ -23,6 +24,7 @@
 #include "m4a.h"
 #include "window.h"
 #include "abilities.h"
+#include "daycare.h"
 #include "battle.h" // to get rid of later
 
 struct EggHatchData
@@ -75,7 +77,7 @@ extern void CreateYesNoMenu(const struct WindowTemplate*, u16, u8, u8);
 extern void DoNamingScreen(u8, const u8*, u16, u8, u32, MainCallback);
 extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor* colors, s8 speed, u8 *str);
 extern u16 sub_80D22D0(void);
-extern u8 sub_80C7050(u8);
+extern u8 CountPartyAliveNonEggMonsExcept(u8);
 
 static void Task_EggHatch(u8 taskID);
 static void CB2_EggHatch_0(void);
@@ -327,7 +329,7 @@ static void CreatedHatchedMon(struct Pokemon *egg, struct Pokemon *temp)
     pokerus = GetMonData(egg, MON_DATA_POKERUS);
     obedience = GetMonData(egg, MON_DATA_OBEDIENCE);
 
-    CreateMon(temp, species, 5, 32, TRUE, personality, 0, 0);
+    CreateMon(temp, species, EGG_HATCH_LEVEL, 32, TRUE, personality, 0, 0);
 
     for (i = 0; i < 4; i++)
     {
@@ -393,19 +395,19 @@ void ScriptHatchMon(void)
     AddHatchedMonToParty(gSpecialVar_0x8004);
 }
 
-static bool8 sub_807158C(struct DaycareData* daycare, u8 daycareId)
+static bool8 sub_807158C(struct DayCare *daycare, u8 daycareId)
 {
     u8 nick[0x20];
-    struct DaycareMon* daycareMon = &daycare->mons[daycareId];
+    struct DaycareMon *daycareMon = &daycare->mons[daycareId];
 
     GetBoxMonNick(&daycareMon->mon, nick);
-    if (daycareMon->mail.itemId != 0
-        && (StringCompareWithoutExtCtrlCodes(nick, daycareMon->monName) != 0
-            || StringCompareWithoutExtCtrlCodes(gSaveBlock2Ptr->playerName, daycareMon->OT_name) != 0))
+    if (daycareMon->misc.mail.itemId != 0
+        && (StringCompareWithoutExtCtrlCodes(nick, daycareMon->misc.monName) != 0
+            || StringCompareWithoutExtCtrlCodes(gSaveBlock2Ptr->playerName, daycareMon->misc.OT_name) != 0))
     {
         StringCopy(gStringVar1, nick);
-        TVShowConvertInternationalString(gStringVar2, daycareMon->OT_name, daycareMon->language_maybe);
-        TVShowConvertInternationalString(gStringVar3, daycareMon->monName, daycareMon->unknown);
+        TVShowConvertInternationalString(gStringVar2, daycareMon->misc.OT_name, daycareMon->misc.gameLanguage);
+        TVShowConvertInternationalString(gStringVar3, daycareMon->misc.monName, daycareMon->misc.monLanguage);
         return TRUE;
     }
     return FALSE;
@@ -888,6 +890,6 @@ u8 GetEggStepsToSubtract(void)
 u16 sub_80722E0(void)
 {
     u16 value = sub_80D22D0();
-    value += sub_80C7050(6);
+    value += CountPartyAliveNonEggMonsExcept(6);
     return value;
 }
diff --git a/src/field_region_map.c b/src/field_region_map.c
new file mode 100644
index 000000000..b7d677c90
--- /dev/null
+++ b/src/field_region_map.c
@@ -0,0 +1,193 @@
+
+// Includes
+#include "global.h"
+#include "main.h"
+#include "malloc.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "text.h"
+#include "window.h"
+#include "text_window.h"
+#include "palette.h"
+#include "menu.h"
+#include "strings.h"
+#include "international_string_util.h"
+#include "region_map.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+static EWRAM_DATA struct {
+    MainCallback callback;
+    u32 filler_004;
+    struct RegionMap regionMap;
+    u16 state;
+} *sFieldRegionMapHandler = NULL;
+
+// Static ROM declarations
+
+static void MCB2_InitRegionMapRegisters(void);
+static void VBCB_FieldUpdateRegionMap(void);
+static void MCB2_FieldUpdateRegionMap(void);
+static void FieldUpdateRegionMap(void);
+static void PrintRegionMapSecName(void);
+
+// .rodata
+
+static const struct BgTemplate gUnknown_085E5068[] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0
+    }, {
+        .bg = 2,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 28,
+        .screenSize = 2,
+        .paletteMode = 1,
+        .priority = 2,
+        .baseTile = 0
+    }
+};
+
+static const struct WindowTemplate gUnknown_085E5070[] = {
+    { 0, 17, 17, 12,  2, 15, 0x0001 },
+    { 0, 22,  1,  7,  2, 15, 0x0019 },
+    DUMMY_WIN_TEMPLATE
+};
+
+// .text
+
+void sub_817018C(MainCallback callback)
+{
+    SetVBlankCallback(NULL);
+    sFieldRegionMapHandler = malloc(sizeof(*sFieldRegionMapHandler));
+    sFieldRegionMapHandler->state = 0;
+    sFieldRegionMapHandler->callback = callback;
+    SetMainCallback2(MCB2_InitRegionMapRegisters);
+}
+
+static void MCB2_InitRegionMapRegisters(void)
+{
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG1HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG1VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG2HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG3HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+    ResetSpriteData();
+    FreeAllSpritePalettes();
+    ResetBgsAndClearDma3BusyFlags(0);
+    InitBgsFromTemplates(1, gUnknown_085E5068, 2);
+    InitWindows(gUnknown_085E5070);
+    DeactivateAllTextPrinters();
+    sub_809882C(0, 0x27, 0xd0);
+    clear_scheduled_bg_copies_to_vram();
+    SetMainCallback2(MCB2_FieldUpdateRegionMap);
+    SetVBlankCallback(VBCB_FieldUpdateRegionMap);
+}
+
+static void VBCB_FieldUpdateRegionMap(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static void MCB2_FieldUpdateRegionMap(void)
+{
+    FieldUpdateRegionMap();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+    do_scheduled_bg_tilemap_copies_to_vram();
+}
+
+static void FieldUpdateRegionMap(void)
+{
+    u8 offset;
+
+    switch (sFieldRegionMapHandler->state)
+    {
+        case 0:
+            InitRegionMap(&sFieldRegionMapHandler->regionMap, 0);
+            CreateRegionMapPlayerIcon(0, 0);
+            CreateRegionMapCursor(1, 1);
+            sFieldRegionMapHandler->state++;
+            break;
+        case 1:
+            SetWindowBorderStyle(1, 0, 0x27, 0xd);
+            offset = GetStringCenterAlignXOffset(1, gText_Hoenn, 0x38);
+            PrintTextOnWindow(1, 1, gText_Hoenn, offset, 1, 0, NULL);
+            schedule_bg_copy_tilemap_to_vram(0);
+            SetWindowBorderStyle(0, 0, 0x27, 0xd);
+            PrintRegionMapSecName();
+            BeginNormalPaletteFade(-1, 0, 16, 0, 0);
+            sFieldRegionMapHandler->state++;
+            break;
+        case 2:
+            SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
+            ShowBg(0);
+            ShowBg(2);
+            sFieldRegionMapHandler->state++;
+            break;
+        case 3:
+            if (!gPaletteFade.active)
+            {
+                sFieldRegionMapHandler->state++;
+            }
+            break;
+        case 4:
+            switch (sub_81230AC())
+            {
+                case INPUT_EVENT_MOVE_END:
+                    PrintRegionMapSecName();
+                    break;
+                case INPUT_EVENT_A_BUTTON:
+                case INPUT_EVENT_B_BUTTON:
+                    sFieldRegionMapHandler->state++;
+                    break;
+            }
+            break;
+        case 5:
+            BeginNormalPaletteFade(-1, 0, 0, 16, 0);
+            sFieldRegionMapHandler->state++;
+            break;
+        case 6:
+            if (!gPaletteFade.active)
+            {
+                FreeRegionMapIconResources();
+                SetMainCallback2(sFieldRegionMapHandler->callback);
+                if (sFieldRegionMapHandler != NULL)
+                {
+                    free(sFieldRegionMapHandler);
+                    sFieldRegionMapHandler = NULL;
+                }
+                FreeAllWindowBuffers();
+            }
+            break;
+    }
+}
+
+static void PrintRegionMapSecName(void)
+{
+    if (sFieldRegionMapHandler->regionMap.iconDrawType != MAPSECTYPE_NONE)
+    {
+        FillWindowPixelBuffer(0, 0x11);
+        PrintTextOnWindow(0, 1, sFieldRegionMapHandler->regionMap.mapSecName, 0, 1, 0, NULL);
+        schedule_bg_copy_tilemap_to_vram(0);
+    }
+    else
+    {
+        FillWindowPixelBuffer(0, 0x11);
+        CopyWindowToVram(0, 3);
+    }
+}
diff --git a/src/heal_location.c b/src/heal_location.c
new file mode 100644
index 000000000..efc534170
--- /dev/null
+++ b/src/heal_location.c
@@ -0,0 +1,83 @@
+
+// Includes
+#include "global.h"
+#include "map_constants.h"
+#include "heal_location.h"
+
+#define HEAL_LOCATION(map, x, y) {MAP_GROUP_##map, MAP_ID_##map, x, y}
+
+// Static type declarations
+
+// Static RAM declarations
+
+// Static ROM declarations
+
+// .rodata
+
+static const struct HealLocation sHealLocations[] = {
+    HEAL_LOCATION(LITTLEROOT_TOWN_BRENDANS_HOUSE_2F,  4,  2),
+    HEAL_LOCATION(LITTLEROOT_TOWN_MAYS_HOUSE_2F,      4,  2),
+    HEAL_LOCATION(PETALBURG_CITY,                    20, 17),
+    HEAL_LOCATION(SLATEPORT_CITY,                    19, 20),
+    HEAL_LOCATION(MAUVILLE_CITY,                     22,  6),
+    HEAL_LOCATION(RUSTBORO_CITY,                     16, 39),
+    HEAL_LOCATION(FORTREE_CITY,                       5,  7),
+    HEAL_LOCATION(LILYCOVE_CITY,                     24, 15),
+    HEAL_LOCATION(MOSSDEEP_CITY,                     28, 17),
+    HEAL_LOCATION(SOOTOPOLIS_CITY,                   43, 32),
+    HEAL_LOCATION(EVER_GRANDE_CITY,                  27, 49),
+    HEAL_LOCATION(LITTLEROOT_TOWN,                    5,  9),
+    HEAL_LOCATION(LITTLEROOT_TOWN,                   14,  9),
+    HEAL_LOCATION(OLDALE_TOWN,                        6, 17),
+    HEAL_LOCATION(DEWFORD_TOWN,                       2, 11),
+    HEAL_LOCATION(LAVARIDGE_TOWN,                     9,  7),
+    HEAL_LOCATION(FALLARBOR_TOWN,                    14,  8),
+    HEAL_LOCATION(VERDANTURF_TOWN,                   16,  4),
+    HEAL_LOCATION(PACIFIDLOG_TOWN,                    8, 16),
+    HEAL_LOCATION(EVER_GRANDE_CITY,                  18,  6),
+    HEAL_LOCATION(SOUTHERN_ISLAND_EXTERIOR,          15, 20),
+    HEAL_LOCATION(BATTLE_FRONTIER_OUTSIDE_EAST,       3, 52)
+};
+
+#define NUM_HEAL_LOCATIONS (ARRAY_COUNT(sHealLocations))
+
+// .text
+
+static u32 GetHealLocationIndexFromMapGroupAndNum(u16 mapGroup, u16 mapNum)
+{
+    u32 i;
+
+    for (i = 0; i < NUM_HEAL_LOCATIONS; i++)
+    {
+        if (sHealLocations[i].group == mapGroup && sHealLocations[i].map == mapNum)
+        {
+            return i + 1;
+        }
+    }
+    return 0;
+}
+
+const struct HealLocation *GetHealLocationPointerFromMapGroupAndNum(u16 mapGroup, u16 mapNum)
+{
+    u32 loc;
+
+    loc = GetHealLocationIndexFromMapGroupAndNum(mapGroup, mapNum);
+    if (loc == 0)
+    {
+        return NULL;
+    }
+    return &sHealLocations[loc - 1];
+}
+
+const struct HealLocation *GetHealLocationPointer(u32 loc)
+{
+    if (loc == 0)
+    {
+        return NULL;
+    }
+    if (loc > NUM_HEAL_LOCATIONS)
+    {
+        return NULL;
+    }
+    return &sHealLocations[loc - 1];
+}
diff --git a/src/pokemon_storage_system.c b/src/pokemon_storage_system.c
index 3e409244c..f82a52d38 100644
--- a/src/pokemon_storage_system.c
+++ b/src/pokemon_storage_system.c
@@ -1,15 +1,122 @@
-
-// Includes
 #include "global.h"
+#include "pokemon_storage_system.h"
+#include "pokemon.h"
+#include "species.h"
+#include "event_data.h"
+#include "string_util.h"
+#include "text.h"
 
-// Static type declarations
+IWRAM_DATA u8 gUnknown_03000F78[0x188];
 
-// Static RAM declarations
+u8 CountMonsInBox(u8 boxId)
+{
+    u16 i, count;
 
-IWRAM_DATA u8 gUnknown_03000F78[0x188];
+    for (i = 0, count = 0; i < IN_BOX_COUNT; i++)
+    {
+        if (GetBoxMonDataFromAnyBox(boxId, i, MON_DATA_SPECIES) != SPECIES_NONE)
+            count++;
+    }
+
+    return count;
+}
+
+s16 GetFirstFreeBoxSpot(u8 boxId)
+{
+    u16 i;
+
+    for (i = 0; i < IN_BOX_COUNT; i++)
+    {
+        if (GetBoxMonDataFromAnyBox(boxId, i, MON_DATA_SPECIES) == SPECIES_NONE)
+            return i;
+    }
+
+    return -1; // all spots are taken
+}
+
+u8 CountPartyNonEggMons(void)
+{
+    u16 i, count;
+
+    for (i = 0, count = 0; i < PARTY_SIZE; i++)
+    {
+        if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
+            && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
+        {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+u8 CountPartyAliveNonEggMonsExcept(u8 slotToIgnore)
+{
+    u16 i, count;
+
+    for (i = 0, count = 0; i < PARTY_SIZE; i++)
+    {
+        if (i != slotToIgnore
+            && GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
+            && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)
+            && GetMonData(&gPlayerParty[i], MON_DATA_HP) != 0)
+        {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+u16 CountPartyAliveNonEggMons_IgnoreVar0x8004Slot(void)
+{
+    return CountPartyAliveNonEggMonsExcept(gSpecialVar_0x8004);
+}
+
+u8 CountPartyMons(void)
+{
+    u16 i, count;
+
+    for (i = 0, count = 0; i < PARTY_SIZE; i++)
+    {
+        if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE)
+        {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+static u8 *StringCopyAndFillWithSpaces(u8 *dst, const u8 *src, u16 n)
+{
+    u8 *str;
+
+    for (str = StringCopy(dst, src); str < dst + n; str++)
+        *str = CHAR_SPACE;
+
+    *str = EOS;
+    return str;
+}
 
-// Static ROM declarations
+/* can't match
+static void sub_80C7128(u16 *dst, u16 dstToAdd, u16 dstToMul, const u16 *src, u16 srcToAdd, u16 srcToMul, u32 size, u16 count, u16 srcBy)
+{
+    u16 i;
 
-// .rodata
+    size <<= 0x11;
+    dst += (dstToMul * 32) + dstToAdd;
+    src += (srcToMul * srcBy) + srcToAdd;
 
-// .text
+    i = 0;
+    if (i < count)
+    {
+        size >>= 1;
+        for (i = 0; i < count; i++)
+        {
+            CpuSet(src, dst, size >> 0x10);
+            dst += 0x20;
+            src += srcBy;
+        }
+    }
+}*/
diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c
index 838e91d90..d09cbc407 100755
--- a/src/pokemon_summary_screen.c
+++ b/src/pokemon_summary_screen.c
@@ -97,7 +97,6 @@ extern u8 gUnknown_08D97D0C;
 extern void reset_temp_tile_data_buffers();
 extern void decompress_and_copy_tile_data_to_vram(u8 a, void* tiledata, u8 b, u8 c, u8 d);
 extern u8 free_temp_tile_data_buffers_if_possible();
-extern void sub_8069004(struct BoxPokemon* a, void* b);
 extern void sub_81C1E20(u8 taskId);
 extern u8 *GetMonNickname(struct Pokemon *mon, u8 *dest);
 extern u16 SpeciesToPokedexNum(u16 species);
@@ -667,7 +666,7 @@ void sub_81C0098(struct Pokemon *mon)
     else
     {
         struct BoxPokemon *boxMon = gUnknown_0203CF1C->unk0->boxMon;
-        sub_8069004(&boxMon[gUnknown_0203CF1C->unk40BE], mon);
+        BoxMonToMon(&boxMon[gUnknown_0203CF1C->unk40BE], mon);
     }
 }
 
@@ -1810,7 +1809,7 @@ void sub_81C171C(u8 taskId)
 void sub_81C174C(u8 taskId)
 {
     s16* data = gTasks[taskId].data;
-    
+
     if (sub_81221EC() != 1)
     {
         if (gPaletteFade.active != 1)
@@ -1857,7 +1856,7 @@ void sub_81C174C(u8 taskId)
                 gUnknown_0203CF21 = 4;
                 gSpecialVar_0x8005 = 4;
                 sub_81C044C(taskId);
-            }   
+            }
         }
     }
 }
@@ -1907,7 +1906,7 @@ void sub_81C1940(u8 taskId)
         {
             if (gUnknown_0203CF1C->unk40C0 != 2)
             {
-                
+
                 ClearWindowTilemap(19);
                 if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
                     ClearWindowTilemap(13);
@@ -2224,7 +2223,7 @@ void sub_81C1E20(u8 taskId)
         {
             if (gUnknown_0203CF1C->unk40C0 == 2)
                 PutWindowTilemap(14);
-            
+
         }
         else
         {
@@ -2277,7 +2276,7 @@ void sub_81C1F80(u8 taskId)
                 PutWindowTilemap(15);
             sub_81C240C(data[2]);
         }
-        else 
+        else
         {
             if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
             {
@@ -3645,7 +3644,7 @@ void sub_81C3D54(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     s16 dataa = data[0] - 1;
-    
+
     switch (dataa)
     {
         case 0:
@@ -3676,4 +3675,4 @@ void sub_81C3D54(u8 taskId)
             return;
     }
     data[0]++;
-}
\ No newline at end of file
+}
diff --git a/src/region_map.c b/src/region_map.c
new file mode 100644
index 000000000..da96475c0
--- /dev/null
+++ b/src/region_map.c
@@ -0,0 +1,1949 @@
+
+// Includes
+#include "global.h"
+#include "main.h"
+#include "menu.h"
+#include "malloc.h"
+#include "gpu_regs.h"
+#include "palette.h"
+#include "party_menu.h"
+#include "trig.h"
+#include "map_constants.h"
+#include "overworld.h"
+#include "flags.h"
+#include "event_data.h"
+#include "rom6.h"
+#include "secret_base.h"
+#include "string_util.h"
+#include "international_string_util.h"
+#include "strings.h"
+#include "text.h"
+#include "text_window.h"
+#include "songs.h"
+#include "m4a.h"
+#include "field_effect.h"
+#include "region_map.h"
+
+#define MAP_WIDTH 28
+#define MAP_HEIGHT 15
+#define MAPCURSOR_X_MIN 1
+#define MAPCURSOR_Y_MIN 2
+#define MAPCURSOR_X_MAX (MAPCURSOR_X_MIN + MAP_WIDTH - 1)
+#define MAPCURSOR_Y_MAX (MAPCURSOR_Y_MIN + MAP_HEIGHT - 1)
+
+// Static type declarations
+
+struct RegionMapLocation
+{
+    u8 x;
+    u8 y;
+    u8 width;
+    u8 height;
+    const u8 *name;
+};
+
+// Static RAM declarations
+
+static EWRAM_DATA struct RegionMap *gRegionMap = NULL;
+static EWRAM_DATA struct {
+    /*0x000*/ void (*unk_000)(void);
+    /*0x004*/ u16 unk_004;
+    /*0x006*/ u16 mapSecId;
+    /*0x008*/ struct RegionMap regionMap;
+    /*0x88c*/ u8 unk_88c[0x1c0];
+    /*0xa4c*/ u8 unk_a4c[0x26];
+    /*0xa72*/ bool8 unk_a72;
+} *gUnknown_0203A148 = NULL; // a74
+
+static bool32 gUnknown_03001180;
+static bool32 gUnknown_03001184;
+
+// Static ROM declarations
+
+static u8 ProcessRegionMapInput_Full(void);
+static u8 MoveRegionMapCursor_Full(void);
+static u8 ProcessRegionMapInput_Zoomed(void);
+static u8 MoveRegionMapCursor_Zoomed(void);
+static void CalcZoomScrollParams(s16 scrollX, s16 scrollY, s16 c, s16 d, u16 e, u16 f, u8 rotation);
+static u16 GetRegionMapSectionIdAt_Internal(u16 x, u16 y);
+static void RegionMap_SetBG2XAndBG2Y(s16 x, s16 y);
+static void RegionMap_InitializeStateBasedOnPlayerLocation(void);
+static void RegionMap_InitializeStateBasedOnSSTidalLocation(void);
+static u8 get_flagnr_blue_points(u16 mapSecId);
+static u16 CorrectSpecialMapSecId_Internal(u16 mapSecId);
+static u16 RegionMap_GetTerraCaveMapSecId(void);
+static void RegionMap_GetMarineCaveCoords(u16 *x, u16 *y);
+static bool32 RegionMap_IsPlayerInCave(u8 mapSecId);
+static void RegionMap_GetPositionOfCursorWithinMapSection(void);
+static bool8 RegionMap_IsMapSecIdInNextRow(u16 y);
+static void SpriteCallback_CursorFull(struct Sprite *sprite);
+static void FreeRegionMapCursorSprite(void);
+static void HideRegionMapPlayerIcon(void);
+static void UnhideRegionMapPlayerIcon(void);
+static void RegionMapPlayerIconSpriteCallback_Zoomed(struct Sprite *sprite);
+static void RegionMapPlayerIconSpriteCallback_Full(struct Sprite *sprite);
+static void RegionMapPlayerIconSpriteCallback(struct Sprite *sprite);
+static void sub_81248C0(void);
+static void sub_81248D4(void);
+static void sub_81248F4(void callback(void));
+static void sub_8124904(void);
+static void sub_8124A70(void);
+static void sub_8124AD4(void);
+static void sub_8124BE4(void);
+static void sub_8124CBC(struct Sprite *sprite);
+static void sub_8124D14(void);
+static void sub_8124D64(void);
+static void sub_8124E0C(void);
+
+// .rodata
+
+static const u16 sRegionMapCursorPal[] = INCBIN_U16("graphics/pokenav/cursor.gbapal");
+static const u8 sRegionMapCursorSmallGfxLZ[] = INCBIN_U8("graphics/pokenav/cursor_small.4bpp.lz");
+static const u8 sRegionMapCursorLargeGfxLZ[] = INCBIN_U8("graphics/pokenav/cursor_large.4bpp.lz");
+static const u16 sRegionMapBkgnd_Pal[] = INCBIN_U16("graphics/pokenav/region_map.gbapal");
+static const u8 sRegionMapBkgnd_GfxLZ[] = INCBIN_U8("graphics/pokenav/region_map.8bpp.lz");
+static const u8 sRegionMapBkgnd_TilemapLZ[] = INCBIN_U8("graphics/pokenav/region_map_map.bin.lz");
+static const u16 sRegionMapPlayerIcon_BrendanPal[] = INCBIN_U16("graphics/pokenav/brendan_icon.gbapal");
+static const u8 sRegionMapPlayerIcon_BrendanGfx[] = INCBIN_U8("graphics/pokenav/brendan_icon.4bpp");
+static const u16 sRegionMapPlayerIcon_MayPal[] = INCBIN_U16("graphics/pokenav/may_icon.gbapal");
+static const u8 sRegionMapPlayerIcon_MayGfx[] = INCBIN_U8("graphics/pokenav/may_icon.4bpp");
+
+static const u8 sRegionMap_MapSectionLayout[] = INCBIN_U8("graphics/pokenav/region_map_section_layout.bin");
+
+#include "data/region_map/region_map_entries.h"
+
+static const u16 sRegionMap_SpecialPlaceLocations[][2] = {
+    {MAPSEC_UNDERWATER_TERRA_CAVE,     MAPSEC_ROUTE_105},
+    {MAPSEC_UNDERWATER_124,            MAPSEC_ROUTE_124},
+    {MAPSEC_UNDERWATER_UNK1,           MAPSEC_ROUTE_129},
+    {MAPSEC_UNDERWATER_125,            MAPSEC_ROUTE_126},
+    {MAPSEC_UNDERWATER_126,            MAPSEC_ROUTE_127},
+    {MAPSEC_UNDERWATER_127,            MAPSEC_ROUTE_128},
+    {MAPSEC_UNDERWATER_129,            MAPSEC_ROUTE_129},
+    {MAPSEC_UNDERWATER_SOOTOPOLIS,     MAPSEC_SOOTOPOLIS_CITY},
+    {MAPSEC_UNDERWATER_128,            MAPSEC_ROUTE_128},
+    {MAPSEC_AQUA_HIDEOUT,              MAPSEC_LILYCOVE_CITY},
+    {MAPSEC_AQUA_HIDEOUT_OLD,          MAPSEC_LILYCOVE_CITY},
+    {MAPSEC_MAGMA_HIDEOUT,             MAPSEC_ROUTE_112},
+    {MAPSEC_UNDERWATER_SEALED_CHAMBER, MAPSEC_ROUTE_134},
+    {MAPSEC_PETALBURG_WOODS,           MAPSEC_ROUTE_104},
+    {MAPSEC_JAGGED_PASS,               MAPSEC_ROUTE_112},
+    {MAPSEC_MT_PYRE,                   MAPSEC_ROUTE_122},
+    {MAPSEC_SKY_PILLAR,                MAPSEC_ROUTE_131},
+    {MAPSEC_MIRAGE_TOWER,              MAPSEC_ROUTE_111},
+    {MAPSEC_TRAINER_HILL,              MAPSEC_ROUTE_111},
+    {MAPSEC_DESERT_UNDERPASS,          MAPSEC_ROUTE_114},
+    {MAPSEC_ALTERING_CAVE_2,           MAPSEC_ROUTE_103},
+    {MAPSEC_ARTISAN_CAVE,              MAPSEC_ROUTE_103},
+    {MAPSEC_ABANDONED_SHIP,            MAPSEC_ROUTE_108},
+    {MAPSEC_NONE,                      MAPSEC_NONE}
+};
+
+static const u16 sRegionMap_MarineCaveMapSecIds[] = {
+    MAPSEC_MARINE_CAVE,
+    MAPSEC_UNDERWATER_MARINE_CAVE,
+    MAPSEC_UNDERWATER_MARINE_CAVE
+};
+
+static const u16 sTerraCaveMapSectionIds[] = {
+    MAPSEC_ROUTE_114,
+    MAPSEC_ROUTE_114,
+    MAPSEC_ROUTE_115,
+    MAPSEC_ROUTE_115,
+    MAPSEC_ROUTE_116,
+    MAPSEC_ROUTE_116,
+    MAPSEC_ROUTE_118,
+    MAPSEC_ROUTE_118,
+    MAPSEC_ROUTE_105,
+    MAPSEC_ROUTE_105,
+    MAPSEC_ROUTE_125,
+    MAPSEC_ROUTE_125,
+    MAPSEC_ROUTE_127,
+    MAPSEC_ROUTE_127,
+    MAPSEC_ROUTE_129,
+    MAPSEC_ROUTE_129
+};
+
+static const struct UCoords16 sTerraCaveLocationCoords[] = {
+    {0x00, 0x0a},
+    {0x00, 0x0c},
+    {0x18, 0x03},
+    {0x19, 0x04},
+    {0x19, 0x06},
+    {0x19, 0x07},
+    {0x18, 0x0a},
+    {0x18, 0x0a}
+};
+
+static const u8 sRegionMap_MapSecAquaHideoutOld[] = {
+    MAPSEC_AQUA_HIDEOUT_OLD
+};
+
+static const struct OamData sRegionMapCursorOam = {
+    .size = 1, .priority = 1
+};
+
+static const union AnimCmd sRegionMapCursorAnim1[] = {
+    ANIMCMD_FRAME(0, 20),
+    ANIMCMD_FRAME(4, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sRegionMapCursorAnim2[] = {
+    ANIMCMD_FRAME( 0, 10),
+    ANIMCMD_FRAME(16, 10),
+    ANIMCMD_FRAME(32, 10),
+    ANIMCMD_FRAME(16, 10),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const sRegionMapCursorAnimTable[] = {
+    sRegionMapCursorAnim1,
+    sRegionMapCursorAnim2
+};
+
+static const struct SpritePalette sRegionMapCursorSpritePalette = { sRegionMapCursorPal, 0 };
+
+static const struct SpriteTemplate sRegionMapCursorSpriteTemplate = {
+    0,
+    0,
+    &sRegionMapCursorOam,
+    sRegionMapCursorAnimTable,
+    NULL,
+    gDummySpriteAffineAnimTable,
+    SpriteCallback_CursorFull
+};
+
+static const struct OamData sRegionMapPlayerIconOam = {
+    .size = 1, .priority = 2
+};
+
+static const union AnimCmd sRegionMapPlayerIconAnim1[] = {
+    ANIMCMD_FRAME(0, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sRegionMapPlayerIconAnimTable[] = {
+    sRegionMapPlayerIconAnim1
+};
+
+static const u8 sRegionMapEventSectionIds[] = {
+    MAPSEC_BIRTH_ISLAND_2,
+    MAPSEC_FARAWAY_ISLAND,
+    MAPSEC_NAVEL_ROCK2
+};
+
+static const u16 sRegionMapFramePal[] = INCBIN_U16("graphics/pokenav/map_frame.gbapal");
+
+static const u8 sRegionMapFrameGfxLZ[] = INCBIN_U8("graphics/pokenav/map_frame.4bpp.lz");
+
+static const u8 sRegionMapFrameTilemapLZ[] = INCBIN_U8("graphics/pokenav/map_frame.bin.lz");
+
+static const u16 Unknown_085A1D48[] = INCBIN_U16("graphics/pokenav/fly_target_icons.gbapal");
+
+static const u8 gUnknown_085A1D68[] = INCBIN_U8("graphics/pokenav/fly_target_icons.4bpp.lz");
+
+static const u8 gUnknown_085A1E3C[][3] = {
+    {MAP_GROUP_LITTLEROOT_TOWN, MAP_ID_LITTLEROOT_TOWN, 1},
+    {MAP_GROUP_OLDALE_TOWN, MAP_ID_OLDALE_TOWN, 14},
+    {MAP_GROUP_DEWFORD_TOWN, MAP_ID_DEWFORD_TOWN, 15},
+    {MAP_GROUP_LAVARIDGE_TOWN, MAP_ID_LAVARIDGE_TOWN, 16},
+    {MAP_GROUP_FALLARBOR_TOWN, MAP_ID_FALLARBOR_TOWN, 17},
+    {MAP_GROUP_VERDANTURF_TOWN, MAP_ID_VERDANTURF_TOWN, 18},
+    {MAP_GROUP_PACIFIDLOG_TOWN, MAP_ID_PACIFIDLOG_TOWN, 19},
+    {MAP_GROUP_PETALBURG_CITY, MAP_ID_PETALBURG_CITY, 3},
+    {MAP_GROUP_SLATEPORT_CITY, MAP_ID_SLATEPORT_CITY, 4},
+    {MAP_GROUP_MAUVILLE_CITY, MAP_ID_MAUVILLE_CITY, 5},
+    {MAP_GROUP_RUSTBORO_CITY, MAP_ID_RUSTBORO_CITY, 6},
+    {MAP_GROUP_FORTREE_CITY, MAP_ID_FORTREE_CITY, 7},
+    {MAP_GROUP_LILYCOVE_CITY, MAP_ID_LILYCOVE_CITY, 8},
+    {MAP_GROUP_MOSSDEEP_CITY, MAP_ID_MOSSDEEP_CITY, 9},
+    {MAP_GROUP_SOOTOPOLIS_CITY, MAP_ID_SOOTOPOLIS_CITY, 10},
+    {MAP_GROUP_EVER_GRANDE_CITY, MAP_ID_EVER_GRANDE_CITY, 11},
+    {MAP_GROUP_ROUTE101, MAP_ID_ROUTE101, 0},
+    {MAP_GROUP_ROUTE102, MAP_ID_ROUTE102, 0},
+    {MAP_GROUP_ROUTE103, MAP_ID_ROUTE103, 0},
+    {MAP_GROUP_ROUTE104, MAP_ID_ROUTE104, 0},
+    {MAP_GROUP_ROUTE105, MAP_ID_ROUTE105, 0},
+    {MAP_GROUP_ROUTE106, MAP_ID_ROUTE106, 0},
+    {MAP_GROUP_ROUTE107, MAP_ID_ROUTE107, 0},
+    {MAP_GROUP_ROUTE108, MAP_ID_ROUTE108, 0},
+    {MAP_GROUP_ROUTE109, MAP_ID_ROUTE109, 0},
+    {MAP_GROUP_ROUTE110, MAP_ID_ROUTE110, 0},
+    {MAP_GROUP_ROUTE111, MAP_ID_ROUTE111, 0},
+    {MAP_GROUP_ROUTE112, MAP_ID_ROUTE112, 0},
+    {MAP_GROUP_ROUTE113, MAP_ID_ROUTE113, 0},
+    {MAP_GROUP_ROUTE114, MAP_ID_ROUTE114, 0},
+    {MAP_GROUP_ROUTE115, MAP_ID_ROUTE115, 0},
+    {MAP_GROUP_ROUTE116, MAP_ID_ROUTE116, 0},
+    {MAP_GROUP_ROUTE117, MAP_ID_ROUTE117, 0},
+    {MAP_GROUP_ROUTE118, MAP_ID_ROUTE118, 0},
+    {MAP_GROUP_ROUTE119, MAP_ID_ROUTE119, 0},
+    {MAP_GROUP_ROUTE120, MAP_ID_ROUTE120, 0},
+    {MAP_GROUP_ROUTE121, MAP_ID_ROUTE121, 0},
+    {MAP_GROUP_ROUTE122, MAP_ID_ROUTE122, 0},
+    {MAP_GROUP_ROUTE123, MAP_ID_ROUTE123, 0},
+    {MAP_GROUP_ROUTE124, MAP_ID_ROUTE124, 0},
+    {MAP_GROUP_ROUTE125, MAP_ID_ROUTE125, 0},
+    {MAP_GROUP_ROUTE126, MAP_ID_ROUTE126, 0},
+    {MAP_GROUP_ROUTE127, MAP_ID_ROUTE127, 0},
+    {MAP_GROUP_ROUTE128, MAP_ID_ROUTE128, 0},
+    {MAP_GROUP_ROUTE129, MAP_ID_ROUTE129, 0},
+    {MAP_GROUP_ROUTE130, MAP_ID_ROUTE130, 0},
+    {MAP_GROUP_ROUTE131, MAP_ID_ROUTE131, 0},
+    {MAP_GROUP_ROUTE132, MAP_ID_ROUTE132, 0},
+    {MAP_GROUP_ROUTE133, MAP_ID_ROUTE133, 0},
+    {MAP_GROUP_ROUTE134, MAP_ID_ROUTE134, 0}
+};
+
+static const u8 *const gUnknown_085A1ED4[] = {
+    gText_PokemonLeague,
+    gText_PokemonCenter
+};
+
+static const struct {
+    const u8 *const *name;
+    u16 mapSecId;
+    u16 flag;
+} gUnknown_085A1EDC[] = {
+    gUnknown_085A1ED4,
+    MAPSEC_EVER_GRANDE_CITY,
+    FLAG_SYS_POKEMON_LEAGUE_FLY
+};
+
+static const struct BgTemplate gUnknown_085A1EE4[] = {
+    { .bg = 0, .charBaseIndex = 0, .mapBaseIndex = 31, .screenSize = 0, .paletteMode = 0, .priority = 0 },
+    { .bg = 1, .charBaseIndex = 3, .mapBaseIndex = 30, .screenSize = 0, .paletteMode = 0, .priority = 1 },
+    { .bg = 2, .charBaseIndex = 2, .mapBaseIndex = 28, .screenSize = 2, .paletteMode = 1, .priority = 2 }
+};
+
+static const struct WindowTemplate gUnknown_085A1EF0[] = {
+    { 0, 17, 17, 12,  2, 15, 0x01 },
+    { 0, 17, 15, 12,  4, 15, 0x19 },
+    { 0,  1, 18, 14,  2, 15, 0x49 },
+    DUMMY_WIN_TEMPLATE
+};
+
+static const struct SpritePalette gUnknown_085A1F10 = {
+    Unknown_085A1D48, 2
+};
+
+static const u16 gUnknown_085A1F18[][2] = {
+    {FLAG_UNLOCK_BATTLE_FRONTIER, MAPSEC_BATTLE_FRONTIER},
+    {-1, MAPSEC_NONE}
+};
+
+static const struct OamData gOamData_085A1F20 = {
+    .priority = 2
+};
+
+static const union AnimCmd gUnknown_085A1F28[] = {
+    ANIMCMD_FRAME( 0, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_085A1F30[] = {
+    ANIMCMD_FRAME( 1, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_085A1F38[] = {
+    ANIMCMD_FRAME( 3, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_085A1F40[] = {
+    ANIMCMD_FRAME( 5, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_085A1F48[] = {
+    ANIMCMD_FRAME( 6, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_085A1F50[] = {
+    ANIMCMD_FRAME( 8, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_085A1F58[] = {
+    ANIMCMD_FRAME(10, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const gUnknown_085A1F60[] = {
+    gUnknown_085A1F28,
+    gUnknown_085A1F30,
+    gUnknown_085A1F38,
+    gUnknown_085A1F40,
+    gUnknown_085A1F48,
+    gUnknown_085A1F50,
+    gUnknown_085A1F58
+};
+
+static const struct SpriteTemplate gUnknown_085A1F7C = {
+    2,
+    2,
+    &gOamData_085A1F20,
+    gUnknown_085A1F60,
+    NULL,
+    gDummySpriteAffineAnimTable,
+    SpriteCallbackDummy
+};
+
+// .text
+
+void InitRegionMap(struct RegionMap *regionMap, bool8 zoomed)
+{
+    sub_8122CF8(regionMap, NULL, zoomed);
+    while (sub_8122DB0());
+}
+
+void sub_8122CF8(struct RegionMap *regionMap, struct BgTemplate *template, bool8 zoomed)
+{
+    gRegionMap = regionMap;
+    gRegionMap->initStep = 0;
+    gRegionMap->zoomed = zoomed;
+    gRegionMap->inputCallback = zoomed == TRUE ? ProcessRegionMapInput_Zoomed : ProcessRegionMapInput_Full;
+    if (template != NULL)
+    {
+        gRegionMap->bgNum = template->bg;
+        gRegionMap->charBaseIdx = template->charBaseIndex;
+        gRegionMap->mapBaseIdx = template->mapBaseIndex;
+        gRegionMap->bgManaged = TRUE;
+    }
+    else
+    {
+        gRegionMap->bgNum = 2;
+        gRegionMap->charBaseIdx = 2;
+        gRegionMap->mapBaseIdx = 28;
+        gRegionMap->bgManaged = FALSE;
+    }
+}
+
+void sub_8122D88(struct RegionMap *regionMap)
+{
+    gRegionMap = regionMap;
+    RegionMap_InitializeStateBasedOnPlayerLocation();
+    gRegionMap->playerIconSpritePosX = gRegionMap->cursorPosX;
+    gRegionMap->playerIconSpritePosY = gRegionMap->cursorPosY;
+}
+
+bool8 sub_8122DB0(void)
+{
+    switch (gRegionMap->initStep)
+    {
+        case 0:
+            if (gRegionMap->bgManaged)
+            {
+                decompress_and_copy_tile_data_to_vram(gRegionMap->bgNum, sRegionMapBkgnd_GfxLZ, 0, 0, 0);
+            }
+            else
+            {
+                LZ77UnCompVram(sRegionMapBkgnd_GfxLZ, (u16 *)BG_CHAR_ADDR(2));
+            }
+            break;
+        case 1:
+            if (gRegionMap->bgManaged)
+            {
+                if (!free_temp_tile_data_buffers_if_possible())
+                {
+                    decompress_and_copy_tile_data_to_vram(gRegionMap->bgNum, sRegionMapBkgnd_TilemapLZ, 0, 0, 1);
+                }
+            }
+            else
+            {
+                LZ77UnCompVram(sRegionMapBkgnd_TilemapLZ, (u16 *)BG_SCREEN_ADDR(28));
+            }
+            break;
+        case 2:
+            if (!free_temp_tile_data_buffers_if_possible())
+            {
+                LoadPalette(sRegionMapBkgnd_Pal, 0x70, 0x60);
+            }
+            break;
+        case 3:
+            LZ77UnCompWram(sRegionMapCursorSmallGfxLZ, gRegionMap->cursorSmallImage);
+            break;
+        case 4:
+            LZ77UnCompWram(sRegionMapCursorLargeGfxLZ, gRegionMap->cursorLargeImage);
+            break;
+        case 5:
+            RegionMap_InitializeStateBasedOnPlayerLocation();
+            gRegionMap->playerIconSpritePosX = gRegionMap->cursorPosX;
+            gRegionMap->playerIconSpritePosY = gRegionMap->cursorPosY;
+            gRegionMap->mapSecId = CorrectSpecialMapSecId_Internal(gRegionMap->mapSecId);
+            gRegionMap->iconDrawType = get_flagnr_blue_points(gRegionMap->mapSecId);
+            GetMapName(gRegionMap->mapSecName, gRegionMap->mapSecId, 16);
+            break;
+        case 6:
+            if (gRegionMap->zoomed == FALSE)
+            {
+                CalcZoomScrollParams(0, 0, 0, 0, 0x100, 0x100, 0);
+            }
+            else
+            {
+                gRegionMap->scrollX = gRegionMap->cursorPosX * 8 - 0x34;
+                gRegionMap->scrollY = gRegionMap->cursorPosY * 8 - 0x44;
+                gRegionMap->zoomedCursorPosX = gRegionMap->cursorPosX;
+                gRegionMap->zoomedCursorPosY = gRegionMap->cursorPosY;
+                CalcZoomScrollParams(gRegionMap->scrollX, gRegionMap->scrollY, 0x38, 0x48, 0x80, 0x80, 0);
+            }
+            break;
+        case 7:
+            RegionMap_GetPositionOfCursorWithinMapSection();
+            UpdateRegionMapVideoRegs();
+            gRegionMap->cursorSprite = NULL;
+            gRegionMap->playerIconSprite = NULL;
+            gRegionMap->cursorMovementFrameCounter = 0;
+            gRegionMap->blinkPlayerIcon = FALSE;
+            if (gRegionMap->bgManaged)
+            {
+                SetBgAttribute(gRegionMap->bgNum, BG_CTRL_ATTR_MAPBASEINDEX, 2);
+                SetBgAttribute(gRegionMap->bgNum, BG_CTRL_ATTR_VISIBLE, gRegionMap->charBaseIdx);
+                SetBgAttribute(gRegionMap->bgNum, BG_CTRL_ATTR_CHARBASEINDEX, gRegionMap->mapBaseIdx);
+                SetBgAttribute(gRegionMap->bgNum, BG_CTRL_ATTR_PRIORITY, 1);
+                SetBgAttribute(gRegionMap->bgNum, BG_CTRL_ATTR_SCREENSIZE, 1);
+            }
+            gRegionMap->initStep++;
+            return FALSE;
+        default:
+            return FALSE;
+    }
+    gRegionMap->initStep++;
+    return TRUE;
+}
+
+void sub_8123030(u16 a0, u32 a1)
+{
+    BlendPalettes(0x380, a1, a0);
+    CpuCopy16(gPlttBufferFaded + 0x70, gPlttBufferUnfaded + 0x70, 0x60);
+}
+
+void FreeRegionMapIconResources(void)
+{
+    if (gRegionMap->cursorSprite != NULL)
+    {
+        DestroySprite(gRegionMap->cursorSprite);
+        FreeSpriteTilesByTag(gRegionMap->cursorTileTag);
+        FreeSpritePaletteByTag(gRegionMap->cursorPaletteTag);
+    }
+    if (gRegionMap->playerIconSprite != NULL)
+    {
+        DestroySprite(gRegionMap->playerIconSprite);
+        FreeSpriteTilesByTag(gRegionMap->playerIconTileTag);
+        FreeSpritePaletteByTag(gRegionMap->playerIconPaletteTag);
+    }
+}
+
+u8 sub_81230AC(void)
+{
+    return gRegionMap->inputCallback();
+}
+
+static u8 ProcessRegionMapInput_Full(void)
+{
+    u8 input;
+
+    input = INPUT_EVENT_NONE;
+    gRegionMap->cursorDeltaX = 0;
+    gRegionMap->cursorDeltaY = 0;
+    if (gMain.heldKeys & DPAD_UP && gRegionMap->cursorPosY > MAPCURSOR_Y_MIN)
+    {
+        gRegionMap->cursorDeltaY = -1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.heldKeys & DPAD_DOWN && gRegionMap->cursorPosY < MAPCURSOR_Y_MAX)
+    {
+        gRegionMap->cursorDeltaY = +1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.heldKeys & DPAD_LEFT && gRegionMap->cursorPosX > MAPCURSOR_X_MIN)
+    {
+        gRegionMap->cursorDeltaX = -1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.heldKeys & DPAD_RIGHT && gRegionMap->cursorPosX < MAPCURSOR_X_MAX)
+    {
+        gRegionMap->cursorDeltaX = +1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.newKeys & A_BUTTON)
+    {
+        input = INPUT_EVENT_A_BUTTON;
+    }
+    else if (gMain.newKeys & B_BUTTON)
+    {
+        input = INPUT_EVENT_B_BUTTON;
+    }
+    if (input == INPUT_EVENT_MOVE_START)
+    {
+        gRegionMap->cursorMovementFrameCounter = 4;
+        gRegionMap->inputCallback = MoveRegionMapCursor_Full;
+    }
+    return input;
+}
+
+static u8 MoveRegionMapCursor_Full(void)
+{
+    u16 mapSecId;
+
+    if (gRegionMap->cursorMovementFrameCounter != 0)
+    {
+        return INPUT_EVENT_MOVE_CONT;
+    }
+    if (gRegionMap->cursorDeltaX > 0)
+    {
+        gRegionMap->cursorPosX++;
+    }
+    if (gRegionMap->cursorDeltaX < 0)
+    {
+        gRegionMap->cursorPosX--;
+    }
+    if (gRegionMap->cursorDeltaY > 0)
+    {
+        gRegionMap->cursorPosY++;
+    }
+    if (gRegionMap->cursorDeltaY < 0)
+    {
+        gRegionMap->cursorPosY--;
+    }
+    mapSecId = GetRegionMapSectionIdAt_Internal(gRegionMap->cursorPosX, gRegionMap->cursorPosY);
+    gRegionMap->iconDrawType = get_flagnr_blue_points(mapSecId);
+    if (mapSecId != gRegionMap->mapSecId)
+    {
+        gRegionMap->mapSecId = mapSecId;
+        GetMapName(gRegionMap->mapSecName, gRegionMap->mapSecId, 16);
+    }
+    RegionMap_GetPositionOfCursorWithinMapSection();
+    gRegionMap->inputCallback = ProcessRegionMapInput_Full;
+    return INPUT_EVENT_MOVE_END;
+}
+
+static u8 ProcessRegionMapInput_Zoomed(void)
+{
+    u8 input;
+
+    input = INPUT_EVENT_NONE;
+    gRegionMap->zoomedCursorDeltaX = 0;
+    gRegionMap->zoomedCursorDeltaY = 0;
+    if (gMain.heldKeys & DPAD_UP && gRegionMap->scrollY > -0x34)
+    {
+        gRegionMap->zoomedCursorDeltaY = -1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.heldKeys & DPAD_DOWN && gRegionMap->scrollY < 0x3c)
+    {
+        gRegionMap->zoomedCursorDeltaY = +1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.heldKeys & DPAD_LEFT && gRegionMap->scrollX > -0x2c)
+    {
+        gRegionMap->zoomedCursorDeltaX = -1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.heldKeys & DPAD_RIGHT && gRegionMap->scrollX < 0xac)
+    {
+        gRegionMap->zoomedCursorDeltaX = +1;
+        input = INPUT_EVENT_MOVE_START;
+    }
+    if (gMain.newKeys & A_BUTTON)
+    {
+        input = INPUT_EVENT_A_BUTTON;
+    }
+    if (gMain.newKeys & B_BUTTON)
+    {
+        input = INPUT_EVENT_B_BUTTON;
+    }
+    if (input == INPUT_EVENT_MOVE_START)
+    {
+        gRegionMap->inputCallback = MoveRegionMapCursor_Zoomed;
+        gRegionMap->zoomedCursorMovementFrameCounter = 0;
+    }
+    return input;
+}
+
+static u8 MoveRegionMapCursor_Zoomed(void)
+{
+    u16 x;
+    u16 y;
+    u16 mapSecId;
+
+    gRegionMap->scrollY += gRegionMap->zoomedCursorDeltaY;
+    gRegionMap->scrollX += gRegionMap->zoomedCursorDeltaX;
+    RegionMap_SetBG2XAndBG2Y(gRegionMap->scrollX, gRegionMap->scrollY);
+    gRegionMap->zoomedCursorMovementFrameCounter++;
+    if (gRegionMap->zoomedCursorMovementFrameCounter == 8)
+    {
+        x = (gRegionMap->scrollX + 0x2c) / 8 + 1;
+        y = (gRegionMap->scrollY + 0x34) / 8 + 2;
+        if (x != gRegionMap->zoomedCursorPosX || y != gRegionMap->zoomedCursorPosY)
+        {
+            gRegionMap->zoomedCursorPosX = x;
+            gRegionMap->zoomedCursorPosY = y;
+            mapSecId = GetRegionMapSectionIdAt_Internal(x, y);
+            gRegionMap->iconDrawType = get_flagnr_blue_points(mapSecId);
+            if (mapSecId != gRegionMap->mapSecId)
+            {
+                gRegionMap->mapSecId = mapSecId;
+                GetMapName(gRegionMap->mapSecName, gRegionMap->mapSecId, 16);
+            }
+            RegionMap_GetPositionOfCursorWithinMapSection();
+        }
+        gRegionMap->zoomedCursorMovementFrameCounter = 0;
+        gRegionMap->inputCallback = ProcessRegionMapInput_Zoomed;
+        return INPUT_EVENT_MOVE_END;
+    }
+    return INPUT_EVENT_MOVE_CONT;
+}
+
+void sub_8123418(void)
+{
+    if (gRegionMap->zoomed == FALSE)
+    {
+        gRegionMap->scrollY = 0;
+        gRegionMap->scrollX = 0;
+        gRegionMap->unk_040 = 0;
+        gRegionMap->unk_03c = 0;
+        gRegionMap->unk_060 = gRegionMap->cursorPosX * 8 - 0x34;
+        gRegionMap->unk_062 = gRegionMap->cursorPosY * 8 - 0x44;
+        gRegionMap->unk_044 = (gRegionMap->unk_060 << 8) / 16;
+        gRegionMap->unk_048 = (gRegionMap->unk_062 << 8) / 16;
+        gRegionMap->zoomedCursorPosX = gRegionMap->cursorPosX;
+        gRegionMap->zoomedCursorPosY = gRegionMap->cursorPosY;
+        gRegionMap->unk_04c = 0x10000;
+        gRegionMap->unk_050 = -0x800;
+    }
+    else
+    {
+        gRegionMap->unk_03c = gRegionMap->scrollX * 0x100;
+        gRegionMap->unk_040 = gRegionMap->scrollY * 0x100;
+        gRegionMap->unk_060 = 0;
+        gRegionMap->unk_062 = 0;
+        gRegionMap->unk_044 = -(gRegionMap->unk_03c / 16);
+        gRegionMap->unk_048 = -(gRegionMap->unk_040 / 16);
+        gRegionMap->cursorPosX = gRegionMap->zoomedCursorPosX;
+        gRegionMap->cursorPosY = gRegionMap->zoomedCursorPosY;
+        gRegionMap->unk_04c = 0x8000;
+        gRegionMap->unk_050 = 0x800;
+    }
+    gRegionMap->unk_06e = 0;
+    FreeRegionMapCursorSprite();
+    HideRegionMapPlayerIcon();
+}
+
+bool8 sub_8123514(void)
+{
+    bool8 retVal;
+
+    if (gRegionMap->unk_06e >= 16)
+    {
+        return 0;
+    }
+    gRegionMap->unk_06e++;
+    if (gRegionMap->unk_06e == 16)
+    {
+        gRegionMap->unk_044 = 0;
+        gRegionMap->unk_048 = 0;
+        gRegionMap->scrollX = gRegionMap->unk_060;
+        gRegionMap->scrollY = gRegionMap->unk_062;
+        gRegionMap->unk_04c = (gRegionMap->zoomed == FALSE) ? (128 << 8) : (256 << 8);
+        gRegionMap->zoomed = !gRegionMap->zoomed;
+        gRegionMap->inputCallback = (gRegionMap->zoomed == FALSE) ? ProcessRegionMapInput_Full : ProcessRegionMapInput_Zoomed;
+        CreateRegionMapCursor(gRegionMap->cursorTileTag, gRegionMap->cursorPaletteTag);
+        UnhideRegionMapPlayerIcon();
+        retVal = FALSE;
+    }
+    else
+    {
+        gRegionMap->unk_03c += gRegionMap->unk_044;
+        gRegionMap->unk_040 += gRegionMap->unk_048;
+        gRegionMap->scrollX = gRegionMap->unk_03c >> 8;
+        gRegionMap->scrollY = gRegionMap->unk_040 >> 8;
+        gRegionMap->unk_04c += gRegionMap->unk_050;
+        if ((gRegionMap->unk_044 < 0 && gRegionMap->scrollX < gRegionMap->unk_060) || (gRegionMap->unk_044 > 0 && gRegionMap->scrollX > gRegionMap->unk_060))
+        {
+            gRegionMap->scrollX = gRegionMap->unk_060;
+            gRegionMap->unk_044 = 0;
+        }
+        if ((gRegionMap->unk_048 < 0 && gRegionMap->scrollY < gRegionMap->unk_062) || (gRegionMap->unk_048 > 0 && gRegionMap->scrollY > gRegionMap->unk_062))
+        {
+            gRegionMap->scrollY = gRegionMap->unk_062;
+            gRegionMap->unk_048 = 0;
+        }
+        if (gRegionMap->zoomed == FALSE)
+        {
+            if (gRegionMap->unk_04c < (128 << 8))
+            {
+                gRegionMap->unk_04c = (128 << 8);
+                gRegionMap->unk_050 = 0;
+            }
+        }
+        else
+        {
+            if (gRegionMap->unk_04c > (256 << 8))
+            {
+                gRegionMap->unk_04c = (256 << 8);
+                gRegionMap->unk_050 = 0;
+            }
+        }
+        retVal = TRUE;
+    }
+    CalcZoomScrollParams(gRegionMap->scrollX, gRegionMap->scrollY, 0x38, 0x48, gRegionMap->unk_04c >> 8, gRegionMap->unk_04c >> 8, 0);
+    return retVal;
+}
+
+static void CalcZoomScrollParams(s16 scrollX, s16 scrollY, s16 c, s16 d, u16 e, u16 f, u8 rotation)
+{
+    s32 var1;
+    s32 var2;
+    s32 var3;
+    s32 var4;
+
+    gRegionMap->bg2pa = e * gSineTable[rotation + 64] >> 8;
+    gRegionMap->bg2pc = e * -gSineTable[rotation] >> 8;
+    gRegionMap->bg2pb = f * gSineTable[rotation] >> 8;
+    gRegionMap->bg2pd = f * gSineTable[rotation + 64] >> 8;
+
+    var1 = (scrollX << 8) + (c << 8);
+    var2 = d * gRegionMap->bg2pb + gRegionMap->bg2pa * c;
+    gRegionMap->bg2x = var1 - var2;
+
+    var3 = (scrollY << 8) + (d << 8);
+    var4 = gRegionMap->bg2pd * d + gRegionMap->bg2pc * c;
+    gRegionMap->bg2y = var3 - var4;
+
+    gRegionMap->needUpdateVideoRegs = TRUE;
+}
+
+static void RegionMap_SetBG2XAndBG2Y(s16 x, s16 y)
+{
+    gRegionMap->bg2x = (x << 8) + 0x1c00;
+    gRegionMap->bg2y = (y << 8) + 0x2400;
+    gRegionMap->needUpdateVideoRegs = TRUE;
+}
+
+void UpdateRegionMapVideoRegs(void)
+{
+    if (gRegionMap->needUpdateVideoRegs)
+    {
+        SetGpuReg(REG_OFFSET_BG2PA, gRegionMap->bg2pa);
+        SetGpuReg(REG_OFFSET_BG2PB, gRegionMap->bg2pb);
+        SetGpuReg(REG_OFFSET_BG2PC, gRegionMap->bg2pc);
+        SetGpuReg(REG_OFFSET_BG2PD, gRegionMap->bg2pd);
+        SetGpuReg(REG_OFFSET_BG2X_L, gRegionMap->bg2x);
+        SetGpuReg(REG_OFFSET_BG2X_H, gRegionMap->bg2x >> 16);
+        SetGpuReg(REG_OFFSET_BG2Y_L, gRegionMap->bg2y);
+        SetGpuReg(REG_OFFSET_BG2Y_H, gRegionMap->bg2y >> 16);
+        gRegionMap->needUpdateVideoRegs = FALSE;
+    }
+}
+
+void PokedexAreaScreen_UpdateRegionMapVariablesAndVideoRegs(s16 x, s16 y)
+{
+    CalcZoomScrollParams(x, y, 0x38, 0x48, 0x100, 0x100, 0);
+    UpdateRegionMapVideoRegs();
+    if (gRegionMap->playerIconSprite != NULL)
+    {
+        gRegionMap->playerIconSprite->pos2.x = -x;
+        gRegionMap->playerIconSprite->pos2.y = -y;
+    }
+}
+
+static u16 GetRegionMapSectionIdAt_Internal(u16 x, u16 y)
+{
+    if (y < MAPCURSOR_Y_MIN || y > MAPCURSOR_Y_MAX || x < MAPCURSOR_X_MIN || x > MAPCURSOR_X_MAX)
+    {
+        return MAPSEC_NONE;
+    }
+    y -= MAPCURSOR_Y_MIN;
+    x -= MAPCURSOR_X_MIN;
+    return sRegionMap_MapSectionLayout[x + y * MAP_WIDTH];
+}
+
+static void RegionMap_InitializeStateBasedOnPlayerLocation(void)
+{
+    const struct MapHeader *mapHeader;
+    u16 mapWidth;
+    u16 mapHeight;
+    u16 x;
+    u16 y;
+    u16 dimensionScale;
+    u16 xOnMap;
+    struct WarpData *storedWarp;
+
+    if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP_SS_TIDAL_CORRIDOR
+        && (gSaveBlock1Ptr->location.mapNum == MAP_ID_SS_TIDAL_CORRIDOR
+            || gSaveBlock1Ptr->location.mapNum == MAP_ID_SS_TIDAL_LOWER_DECK
+            || gSaveBlock1Ptr->location.mapNum == MAP_ID_SS_TIDAL_ROOMS))
+    {
+        RegionMap_InitializeStateBasedOnSSTidalLocation();
+        return;
+    }
+
+    switch (get_map_light_level_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum))
+    {
+        default:
+        case 1:
+        case 2:
+        case 3:
+        case 5:
+        case 6:
+            gRegionMap->mapSecId = gMapHeader.regionMapSectionId;
+            gRegionMap->playerIsInCave = FALSE;
+            mapWidth = gMapHeader.mapData->width;
+            mapHeight = gMapHeader.mapData->height;
+            x = gSaveBlock1Ptr->pos.x;
+            y = gSaveBlock1Ptr->pos.y;
+            if (gRegionMap->mapSecId == MAPSEC_UNDERWATER_128 || gRegionMap->mapSecId == MAPSEC_UNDERWATER_MARINE_CAVE)
+            {
+                gRegionMap->playerIsInCave = TRUE;
+            }
+            break;
+        case 4:
+        case 7:
+            if (gMapHeader.flags & 0x02)
+            {
+                mapHeader = get_mapheader_by_bank_and_number(gSaveBlock1Ptr->warp4.mapGroup, gSaveBlock1Ptr->warp4.mapNum);
+                gRegionMap->mapSecId = mapHeader->regionMapSectionId;
+                gRegionMap->playerIsInCave = TRUE;
+                mapWidth = mapHeader->mapData->width;
+                mapHeight = mapHeader->mapData->height;
+                x = gSaveBlock1Ptr->warp4.x;
+                y = gSaveBlock1Ptr->warp4.y;
+            }
+            else
+            {
+                gRegionMap->mapSecId = gMapHeader.regionMapSectionId;
+                gRegionMap->playerIsInCave = TRUE;
+                mapWidth = 1;
+                mapHeight = 1;
+                x = 1;
+                y = 1;
+            }
+            break;
+        case 9:
+            mapHeader = get_mapheader_by_bank_and_number((u16)gSaveBlock1Ptr->warp2.mapGroup, (u16)gSaveBlock1Ptr->warp2.mapNum);
+            gRegionMap->mapSecId = mapHeader->regionMapSectionId;
+            gRegionMap->playerIsInCave = TRUE;
+            mapWidth = mapHeader->mapData->width;
+            mapHeight = mapHeader->mapData->height;
+            x = gSaveBlock1Ptr->warp2.x;
+            y = gSaveBlock1Ptr->warp2.y;
+            break;
+        case 8:
+
+            gRegionMap->mapSecId = gMapHeader.regionMapSectionId;
+            if (gRegionMap->mapSecId != MAPSEC_DYNAMIC)
+            {
+                storedWarp = &gSaveBlock1Ptr->warp4;
+                mapHeader = get_mapheader_by_bank_and_number(storedWarp->mapGroup, storedWarp->mapNum);
+            }
+            else
+            {
+                storedWarp = &gSaveBlock1Ptr->warp2;
+                mapHeader = get_mapheader_by_bank_and_number(storedWarp->mapGroup, storedWarp->mapNum);
+                gRegionMap->mapSecId = mapHeader->regionMapSectionId;
+            }
+            if (RegionMap_IsPlayerInCave(gRegionMap->mapSecId))
+            {
+                gRegionMap->playerIsInCave = TRUE;
+            }
+            else
+            {
+                gRegionMap->playerIsInCave = FALSE;
+            }
+            mapWidth = mapHeader->mapData->width;
+            mapHeight = mapHeader->mapData->height;
+            x = storedWarp->x;
+            y = storedWarp->y;
+            break;
+    }
+
+    xOnMap = x;
+
+    dimensionScale = mapWidth / gRegionMapEntries[gRegionMap->mapSecId].width;
+    if (dimensionScale == 0)
+    {
+        dimensionScale = 1;
+    }
+    x /= dimensionScale;
+    if (x >= gRegionMapEntries[gRegionMap->mapSecId].width)
+    {
+        x = gRegionMapEntries[gRegionMap->mapSecId].width - 1;
+    }
+
+    dimensionScale = mapHeight / gRegionMapEntries[gRegionMap->mapSecId].height;
+    if (dimensionScale == 0)
+    {
+        dimensionScale = 1;
+    }
+    y /= dimensionScale;
+    if (y >= gRegionMapEntries[gRegionMap->mapSecId].height)
+    {
+        y = gRegionMapEntries[gRegionMap->mapSecId].height - 1;
+    }
+
+    switch (gRegionMap->mapSecId)
+    {
+        case MAPSEC_ROUTE_114:
+            if (y != 0)
+            {
+                x = 0;
+            }
+            break;
+        case MAPSEC_ROUTE_126:
+        case MAPSEC_UNDERWATER_125:
+            x = 0;
+            if (gSaveBlock1Ptr->pos.x > 32)
+            {
+                x = 1;
+            }
+            if (gSaveBlock1Ptr->pos.x > 0x33)
+            {
+                x++;
+            }
+            y = 0;
+            if (gSaveBlock1Ptr->pos.y > 0x25)
+            {
+                y = 1;
+            }
+            if (gSaveBlock1Ptr->pos.y > 0x38)
+            {
+                y++;
+            }
+            break;
+        case MAPSEC_ROUTE_121:
+            x = 0;
+            if (xOnMap > 14)
+            {
+                x = 1;
+            }
+            if (xOnMap > 0x1C)
+            {
+                x++;
+            }
+            if (xOnMap > 0x36)
+            {
+                x++;
+            }
+            break;
+        case MAPSEC_UNDERWATER_MARINE_CAVE:
+            RegionMap_GetMarineCaveCoords(&gRegionMap->cursorPosX, &gRegionMap->cursorPosY);
+            return;
+    }
+    gRegionMap->cursorPosX = gRegionMapEntries[gRegionMap->mapSecId].x + x + MAPCURSOR_X_MIN;
+    gRegionMap->cursorPosY = gRegionMapEntries[gRegionMap->mapSecId].y + y + MAPCURSOR_Y_MIN;
+}
+
+static void RegionMap_InitializeStateBasedOnSSTidalLocation(void)
+{
+    u16 y;
+    u16 x;
+    u8 mapGroup;
+    u8 mapNum;
+    u16 dimensionScale;
+    s16 xOnMap;
+    s16 yOnMap;
+    const struct MapHeader *mapHeader;
+
+    y = 0;
+    x = 0;
+    switch (GetSSTidalLocation(&mapGroup, &mapNum, &xOnMap, &yOnMap))
+    {
+        case 1:
+            gRegionMap->mapSecId = MAPSEC_SLATEPORT_CITY;
+            break;
+        case 2:
+            gRegionMap->mapSecId = MAPSEC_LILYCOVE_CITY;
+            break;
+        case 3:
+            gRegionMap->mapSecId = MAPSEC_ROUTE_124;
+            break;
+        case 4:
+            gRegionMap->mapSecId = MAPSEC_ROUTE_131;
+            break;
+        default:
+        case 0:
+            mapHeader = get_mapheader_by_bank_and_number(mapGroup, mapNum);
+
+            gRegionMap->mapSecId = mapHeader->regionMapSectionId;
+            dimensionScale = mapHeader->mapData->width / gRegionMapEntries[gRegionMap->mapSecId].width;
+            if (dimensionScale == 0)
+                dimensionScale = 1;
+            x = xOnMap / dimensionScale;
+            if (x >= gRegionMapEntries[gRegionMap->mapSecId].width)
+                x = gRegionMapEntries[gRegionMap->mapSecId].width - 1;
+
+            dimensionScale = mapHeader->mapData->height / gRegionMapEntries[gRegionMap->mapSecId].height;
+            if (dimensionScale == 0)
+                dimensionScale = 1;
+            y = yOnMap / dimensionScale;
+            if (y >= gRegionMapEntries[gRegionMap->mapSecId].height)
+                y = gRegionMapEntries[gRegionMap->mapSecId].height - 1;
+            break;
+    }
+    gRegionMap->playerIsInCave = FALSE;
+    gRegionMap->cursorPosX = gRegionMapEntries[gRegionMap->mapSecId].x + x + MAPCURSOR_X_MIN;
+    gRegionMap->cursorPosY = gRegionMapEntries[gRegionMap->mapSecId].y + y + MAPCURSOR_Y_MIN;
+}
+
+static u8 get_flagnr_blue_points(u16 mapSecId)
+{
+    switch (mapSecId)
+    {
+        case MAPSEC_NONE:
+            return MAPSECTYPE_NONE;
+        case MAPSEC_LITTLEROOT_TOWN:
+            return FlagGet(FLAG_VISITED_LITTLEROOT_TOWN) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_OLDALE_TOWN:
+            return FlagGet(FLAG_VISITED_OLDALE_TOWN) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_DEWFORD_TOWN:
+            return FlagGet(FLAG_VISITED_DEWFORD_TOWN) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_LAVARIDGE_TOWN:
+            return FlagGet(FLAG_VISITED_LAVARIDGE_TOWN) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_FALLARBOR_TOWN:
+            return FlagGet(FLAG_VISITED_FALLARBOR_TOWN) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_VERDANTURF_TOWN:
+            return FlagGet(FLAG_VISITED_VERDANTURF_TOWN) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_PACIFIDLOG_TOWN:
+            return FlagGet(FLAG_VISITED_PACIFIDLOG_TOWN) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_PETALBURG_CITY:
+            return FlagGet(FLAG_VISITED_PETALBURG_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_SLATEPORT_CITY:
+            return FlagGet(FLAG_VISITED_SLATEPORT_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_MAUVILLE_CITY:
+            return FlagGet(FLAG_VISITED_MAUVILLE_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_RUSTBORO_CITY:
+            return FlagGet(FLAG_VISITED_RUSTBORO_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_FORTREE_CITY:
+            return FlagGet(FLAG_VISITED_FORTREE_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_LILYCOVE_CITY:
+            return FlagGet(FLAG_VISITED_LILYCOVE_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_MOSSDEEP_CITY:
+            return FlagGet(FLAG_VISITED_MOSSDEEP_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_SOOTOPOLIS_CITY:
+            return FlagGet(FLAG_VISITED_SOOTOPOLIS_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_EVER_GRANDE_CITY:
+            return FlagGet(FLAG_VISITED_EVER_GRANDE_CITY) ? MAPSECTYPE_CITY_CANFLY : MAPSECTYPE_CITY_CANTFLY;
+        case MAPSEC_BATTLE_FRONTIER:
+            return FlagGet(FLAG_UNLOCK_BATTLE_FRONTIER) ? MAPSECTYPE_BATTLE_FRONTIER : MAPSECTYPE_NONE;
+        case MAPSEC_SOUTHERN_ISLAND:
+            return FlagGet(FLAG_UNLOCK_SOUTHERN_ISLAND) ? MAPSECTYPE_PLAIN : MAPSECTYPE_NONE;
+        default:
+            return MAPSECTYPE_PLAIN;
+    }
+}
+
+u16 GetRegionMapSectionIdAt(u16 x, u16 y)
+{
+    return GetRegionMapSectionIdAt_Internal(x, y);
+}
+
+static u16 CorrectSpecialMapSecId_Internal(u16 mapSecId)
+{
+    u32 i;
+
+    for (i = 0; i < 3; i++)
+    {
+        if (sRegionMap_MarineCaveMapSecIds[i] == mapSecId)
+        {
+            return RegionMap_GetTerraCaveMapSecId();
+        }
+    }
+    for (i = 0; sRegionMap_SpecialPlaceLocations[i][0] != MAPSEC_NONE; i++)
+    {
+        if (sRegionMap_SpecialPlaceLocations[i][0] == mapSecId)
+        {
+            return sRegionMap_SpecialPlaceLocations[i][1];
+        }
+    }
+    return mapSecId;
+}
+
+static u16 RegionMap_GetTerraCaveMapSecId(void)
+{
+    s16 idx;
+
+    idx = VarGet(VAR_0x4037) - 1;
+    if (idx < 0 || idx > 15)
+    {
+        idx = 0;
+    }
+    return sTerraCaveMapSectionIds[idx];
+}
+
+static void RegionMap_GetMarineCaveCoords(u16 *x, u16 *y)
+{
+    u16 idx;
+
+    idx = VarGet(VAR_0x4037);
+    if (idx < 9 || idx > 16)
+    {
+        idx = 9;
+    }
+    idx -= 9;
+    *x = sTerraCaveLocationCoords[idx].x + MAPCURSOR_X_MIN;
+    *y = sTerraCaveLocationCoords[idx].y + MAPCURSOR_Y_MIN;
+}
+
+static bool32 RegionMap_IsPlayerInCave(u8 mapSecId)
+{
+    u32 i;
+
+    for (i = 0; i < 1; i++)
+    {
+        if (sRegionMap_MapSecAquaHideoutOld[i] == mapSecId)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+u16 CorrectSpecialMapSecId(u16 mapSecId)
+{
+    return CorrectSpecialMapSecId_Internal(mapSecId);
+}
+
+static void RegionMap_GetPositionOfCursorWithinMapSection(void)
+{
+    u16 x;
+    u16 y;
+    u16 posWithinMapSec;
+
+    if (gRegionMap->mapSecId == MAPSEC_NONE)
+    {
+        gRegionMap->posWithinMapSec = 0;
+        return;
+    }
+    if (!gRegionMap->zoomed)
+    {
+        x = gRegionMap->cursorPosX;
+        y = gRegionMap->cursorPosY;
+    }
+    else
+    {
+        x = gRegionMap->zoomedCursorPosX;
+        y = gRegionMap->zoomedCursorPosY;
+    }
+    posWithinMapSec = 0;
+    while (1)
+    {
+        if (x <= MAPCURSOR_X_MIN)
+        {
+            if (RegionMap_IsMapSecIdInNextRow(y))
+            {
+                y--;
+                x = MAPCURSOR_X_MAX + 1;
+            }
+            else
+            {
+                break;
+            }
+        }
+        else
+        {
+            x--;
+            if (GetRegionMapSectionIdAt_Internal(x, y) == gRegionMap->mapSecId)
+            {
+                posWithinMapSec++;
+            }
+        }
+    }
+    gRegionMap->posWithinMapSec = posWithinMapSec;
+}
+
+static bool8 RegionMap_IsMapSecIdInNextRow(u16 y)
+{
+    u16 x;
+
+    if (y-- == 0)
+    {
+        return FALSE;
+    }
+    for (x = MAPCURSOR_X_MIN; x <= MAPCURSOR_X_MAX; x++)
+    {
+        if (GetRegionMapSectionIdAt_Internal(x, y) == gRegionMap->mapSecId)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+static void SpriteCallback_CursorFull(struct Sprite *sprite)
+{
+    if (gRegionMap->cursorMovementFrameCounter != 0)
+    {
+        sprite->pos1.x += 2 * gRegionMap->cursorDeltaX;
+        sprite->pos1.y += 2 * gRegionMap->cursorDeltaY;
+        gRegionMap->cursorMovementFrameCounter--;
+    }
+}
+
+static void SpriteCallback_CursorZoomed(struct Sprite *sprite)
+{
+
+}
+
+void CreateRegionMapCursor(u16 tileTag, u16 paletteTag)
+{
+    u8 spriteId;
+    struct SpriteTemplate template;
+    struct SpritePalette palette;
+    struct SpriteSheet sheet;
+
+    palette = sRegionMapCursorSpritePalette;
+    template = sRegionMapCursorSpriteTemplate;
+    sheet.tag = tileTag;
+    template.tileTag = tileTag;
+    gRegionMap->cursorTileTag = tileTag;
+    palette.tag = paletteTag;
+    template.paletteTag = paletteTag;
+    gRegionMap->cursorPaletteTag = paletteTag;
+    if (!gRegionMap->zoomed)
+    {
+        sheet.data = gRegionMap->cursorSmallImage;
+        sheet.size = sizeof(gRegionMap->cursorSmallImage);
+        template.callback = SpriteCallback_CursorFull;
+    }
+    else
+    {
+        sheet.data = gRegionMap->cursorLargeImage;
+        sheet.size = sizeof(gRegionMap->cursorLargeImage);
+        template.callback = SpriteCallback_CursorZoomed;
+    }
+    LoadSpriteSheet(&sheet);
+    LoadSpritePalette(&palette);
+    spriteId = CreateSprite(&template, 0x38, 0x48, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        gRegionMap->cursorSprite = &gSprites[spriteId];
+        if (gRegionMap->zoomed == TRUE)
+        {
+            gRegionMap->cursorSprite->oam.size = 2;
+            gRegionMap->cursorSprite->pos1.x -= 8;
+            gRegionMap->cursorSprite->pos1.y -= 8;
+            StartSpriteAnim(gRegionMap->cursorSprite, 1);
+        }
+        else
+        {
+            gRegionMap->cursorSprite->oam.size = 1;
+            gRegionMap->cursorSprite->pos1.x = 8 * gRegionMap->cursorPosX + 4;
+            gRegionMap->cursorSprite->pos1.y = 8 * gRegionMap->cursorPosY + 4;
+        }
+        gRegionMap->cursorSprite->data1 = 2;
+        gRegionMap->cursorSprite->data2 = (IndexOfSpritePaletteTag(paletteTag) << 4) + 0x101;
+        gRegionMap->cursorSprite->data3 = TRUE;
+    }
+}
+
+static void FreeRegionMapCursorSprite(void)
+{
+    if (gRegionMap->cursorSprite != NULL)
+    {
+        DestroySprite(gRegionMap->cursorSprite);
+        FreeSpriteTilesByTag(gRegionMap->cursorTileTag);
+        FreeSpritePaletteByTag(gRegionMap->cursorPaletteTag);
+    }
+}
+
+void sub_8124268(void)
+{
+    gRegionMap->cursorSprite->data3 = TRUE;
+}
+
+void sub_8124278(void)
+{
+    gRegionMap->cursorSprite->data3 = FALSE;
+}
+
+void CreateRegionMapPlayerIcon(u16 tileTag, u16 paletteTag)
+{
+    u8 spriteId;
+    struct SpriteSheet sheet = {sRegionMapPlayerIcon_BrendanGfx, 0x80, tileTag};
+    struct SpritePalette palette = {sRegionMapPlayerIcon_BrendanPal, paletteTag};
+    struct SpriteTemplate template = {tileTag, paletteTag, &sRegionMapPlayerIconOam, sRegionMapPlayerIconAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
+
+    if (sub_8124668(gMapHeader.regionMapSectionId))
+    {
+        gRegionMap->playerIconSprite = NULL;
+        return;
+    }
+    if (gSaveBlock2Ptr->playerGender == FEMALE)
+    {
+        sheet.data = sRegionMapPlayerIcon_MayGfx;
+        palette.data = sRegionMapPlayerIcon_MayPal;
+    }
+    LoadSpriteSheet(&sheet);
+    LoadSpritePalette(&palette);
+    spriteId = CreateSprite(&template, 0, 0, 1);
+    gRegionMap->playerIconSprite = &gSprites[spriteId];
+    if (!gRegionMap->zoomed)
+    {
+        gRegionMap->playerIconSprite->pos1.x = gRegionMap->playerIconSpritePosX * 8 + 4;
+        gRegionMap->playerIconSprite->pos1.y = gRegionMap->playerIconSpritePosY * 8 + 4;
+        gRegionMap->playerIconSprite->callback = RegionMapPlayerIconSpriteCallback_Full;
+    }
+    else
+    {
+        gRegionMap->playerIconSprite->pos1.x = gRegionMap->playerIconSpritePosX * 16 - 0x30;
+        gRegionMap->playerIconSprite->pos1.y = gRegionMap->playerIconSpritePosY * 16 - 0x42;
+        gRegionMap->playerIconSprite->callback = RegionMapPlayerIconSpriteCallback_Zoomed;
+    }
+}
+
+static void HideRegionMapPlayerIcon(void)
+{
+    if (gRegionMap->playerIconSprite != NULL)
+    {
+        gRegionMap->playerIconSprite->invisible = TRUE;
+        gRegionMap->playerIconSprite->callback = SpriteCallbackDummy;
+    }
+}
+
+static void UnhideRegionMapPlayerIcon(void)
+{
+    if (gRegionMap->playerIconSprite != NULL)
+    {
+        if (gRegionMap->zoomed == TRUE)
+        {
+            gRegionMap->playerIconSprite->pos1.x = gRegionMap->playerIconSpritePosX * 16 - 0x30;
+            gRegionMap->playerIconSprite->pos1.y = gRegionMap->playerIconSpritePosY * 16 - 0x42;
+            gRegionMap->playerIconSprite->callback = RegionMapPlayerIconSpriteCallback_Zoomed;
+            gRegionMap->playerIconSprite->invisible = FALSE;
+        }
+        else
+        {
+            gRegionMap->playerIconSprite->pos1.x = gRegionMap->playerIconSpritePosX * 8 + 4;
+            gRegionMap->playerIconSprite->pos1.y = gRegionMap->playerIconSpritePosY * 8 + 4;
+            gRegionMap->playerIconSprite->pos2.x = 0;
+            gRegionMap->playerIconSprite->pos2.y = 0;
+            gRegionMap->playerIconSprite->callback = RegionMapPlayerIconSpriteCallback_Full;
+            gRegionMap->playerIconSprite->invisible = FALSE;
+        }
+    }
+}
+
+static void RegionMapPlayerIconSpriteCallback_Zoomed(struct Sprite *sprite)
+{
+    sprite->pos2.x = -2 * gRegionMap->scrollX;
+    sprite->pos2.y = -2 * gRegionMap->scrollY;
+    sprite->data0 = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY;
+    sprite->data1 = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX;
+    if (sprite->data0 < -8 || sprite->data0 > 0xa8 || sprite->data1 < -8 || sprite->data1 > 0xf8)
+    {
+        sprite->data2 = FALSE;
+    }
+    else
+    {
+        sprite->data2 = TRUE;
+    }
+    if (sprite->data2 == TRUE)
+    {
+        RegionMapPlayerIconSpriteCallback(sprite);
+    }
+    else
+    {
+        sprite->invisible = TRUE;
+    }
+}
+
+static void RegionMapPlayerIconSpriteCallback_Full(struct Sprite *sprite)
+{
+    RegionMapPlayerIconSpriteCallback(sprite);
+}
+
+static void RegionMapPlayerIconSpriteCallback(struct Sprite *sprite)
+{
+    if (gRegionMap->blinkPlayerIcon)
+    {
+        if (++sprite->data7 > 16)
+        {
+            sprite->data7 = 0;
+            sprite->invisible = sprite->invisible ? FALSE : TRUE;
+        }
+    }
+    else
+    {
+        sprite->invisible = FALSE;
+    }
+}
+
+void sub_812454C(void)
+{
+    if (gRegionMap->playerIsInCave)
+    {
+        gRegionMap->blinkPlayerIcon = TRUE;
+    }
+}
+
+u8 *GetMapName(u8 *dest, u16 regionMapId, u16 padLength)
+{
+    u8 *str;
+    u16 i;
+
+    if (regionMapId == MAPSEC_SECRET_BASE)
+    {
+        str = GetSecretBaseMapName(dest);
+    }
+    else if (regionMapId < MAPSEC_NONE)
+    {
+        str = StringCopy(dest, gRegionMapEntries[regionMapId].name);
+    }
+    else
+    {
+        if (padLength == 0)
+        {
+            padLength = 18;
+        }
+        return StringFill(dest, CHAR_SPACE, padLength);
+    }
+    if (padLength != 0)
+    {
+        for (i = str - dest; i < padLength; i++)
+        {
+            *str++ = CHAR_SPACE;
+        }
+        *str = EOS;
+    }
+    return str;
+}
+
+u8 *sub_81245DC(u8 *dest, u16 mapSecId)
+{
+    switch (mapSecId)
+    {
+        case MAPSEC_DYNAMIC:
+            return StringCopy(dest, gText_Ferry);
+        case MAPSEC_SECRET_BASE:
+            return StringCopy(dest, gText_SecretBase);
+        default:
+            return GetMapName(dest, mapSecId, 0);
+    }
+}
+
+u8 *sub_8124610(u8 *dest, u16 mapSecId)
+{
+    if (mapSecId == MAPSEC_AQUA_HIDEOUT_OLD)
+    {
+        return StringCopy(dest, gText_Hideout);
+    }
+    else
+    {
+        return sub_81245DC(dest, mapSecId);
+    }
+}
+
+void sub_8124630(u16 mapSecId, u16 *x, u16 *y, u16 *width, u16 *height)
+{
+    *x = gRegionMapEntries[mapSecId].x;
+    *y = gRegionMapEntries[mapSecId].y;
+    *width = gRegionMapEntries[mapSecId].width;
+    *height = gRegionMapEntries[mapSecId].height;
+}
+
+bool8 sub_8124658(void)
+{
+    return gRegionMap->zoomed;
+}
+
+bool32 sub_8124668(u8 mapSecId)
+{
+    u32 i;
+
+    for (i = 0; i < 3; i++)
+    {
+        if (mapSecId == sRegionMapEventSectionIds[i])
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void MCB2_FlyMap(void)
+{
+    switch (gMain.state)
+    {
+        case 0:
+            SetVBlankCallback(NULL);
+            SetGpuReg(REG_OFFSET_DISPCNT, 0);
+            SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+            SetGpuReg(REG_OFFSET_BG1HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG1VOFS, 0);
+            SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+            SetGpuReg(REG_OFFSET_BG2HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG3HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+            gUnknown_0203A148 = malloc(sizeof(*gUnknown_0203A148));
+            if (gUnknown_0203A148 == NULL)
+            {
+                SetMainCallback2(sub_8086194);
+            }
+            else
+            {
+                ResetPaletteFade();
+                ResetSpriteData();
+                FreeSpriteTileRanges();
+                FreeAllSpritePalettes();
+                gMain.state++;
+            }
+            break;
+        case 1:
+            ResetBgsAndClearDma3BusyFlags(0);
+            InitBgsFromTemplates(1, gUnknown_085A1EE4, 3);
+            gMain.state++;
+            break;
+        case 2:
+            InitWindows(gUnknown_085A1EF0);
+            DeactivateAllTextPrinters();
+            gMain.state++;
+            break;
+        case 3:
+            sub_809882C(0, 0x65, 0xd0);
+            clear_scheduled_bg_copies_to_vram();
+            gMain.state++;
+            break;
+        case 4:
+            InitRegionMap(&gUnknown_0203A148->regionMap, FALSE);
+            CreateRegionMapCursor(0, 0);
+            CreateRegionMapPlayerIcon(1, 1);
+            gUnknown_0203A148->mapSecId = gUnknown_0203A148->regionMap.mapSecId;
+            StringFill(gUnknown_0203A148->unk_a4c, CHAR_SPACE, 16);
+            gUnknown_03001180 = TRUE;
+            sub_8124904();
+            gMain.state++;
+            break;
+        case 5:
+            LZ77UnCompVram(sRegionMapFrameGfxLZ, (u16 *)BG_CHAR_ADDR(3));
+            gMain.state++;
+            break;
+        case 6:
+            LZ77UnCompVram(sRegionMapFrameTilemapLZ, (u16 *)BG_SCREEN_ADDR(30));
+            gMain.state++;
+            break;
+        case 7:
+            LoadPalette(sRegionMapFramePal, 0x10, 0x20);
+            PutWindowTilemap(2);
+            FillWindowPixelBuffer(2, 0x00);
+            PrintTextOnWindow(2, 1, gText_FlyToWhere, 0, 1, 0, NULL);
+            schedule_bg_copy_tilemap_to_vram(0);
+            gMain.state++;
+            break;
+        case 8:
+            sub_8124A70();
+            gMain.state++;
+            break;
+        case 9:
+            BlendPalettes(-1, 16, 0);
+            SetVBlankCallback(sub_81248C0);
+            gMain.state++;
+            break;
+        case 10:
+            SetGpuReg(REG_OFFSET_BLDCNT, 0);
+            SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
+            ShowBg(0);
+            ShowBg(1);
+            ShowBg(2);
+            sub_81248F4(sub_8124D14);
+            SetMainCallback2(sub_81248D4);
+            gMain.state++;
+            break;
+    }
+}
+
+static void sub_81248C0(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static void sub_81248D4(void)
+{
+    gUnknown_0203A148->unk_000();
+    AnimateSprites();
+    BuildOamBuffer();
+    do_scheduled_bg_tilemap_copies_to_vram();
+}
+
+static void sub_81248F4(void callback(void))
+{
+    gUnknown_0203A148->unk_000 = callback;
+    gUnknown_0203A148->unk_004 = 0;
+}
+
+static void sub_8124904(void)
+{
+    u16 i;
+    bool32 flag;
+    const u8 *name;
+
+    if (gUnknown_0203A148->regionMap.iconDrawType > MAPSECTYPE_NONE && gUnknown_0203A148->regionMap.iconDrawType <= MAPSECTYPE_BATTLE_FRONTIER)
+    {
+        flag = FALSE;
+        for (i = 0; i < 1; i++)
+        {
+            if (gUnknown_0203A148->regionMap.mapSecId == gUnknown_085A1EDC[i].mapSecId)
+            {
+                if (FlagGet(gUnknown_085A1EDC[i].flag))
+                {
+                    StringLength(gUnknown_085A1EDC[i].name[gUnknown_0203A148->regionMap.posWithinMapSec]);
+                    flag = TRUE;
+                    sub_8198070(0, FALSE);
+                    SetWindowBorderStyle(1, FALSE, 0x65, 0x0d);
+                    PrintTextOnWindow(1, 1, gUnknown_0203A148->regionMap.mapSecName, 0, 1, 0, NULL);
+                    name = gUnknown_085A1EDC[i].name[gUnknown_0203A148->regionMap.posWithinMapSec];
+                    PrintTextOnWindow(1, 1, name, GetStringRightAlignXOffset(1, name, 0x60), 0x11, 0, NULL);
+                    schedule_bg_copy_tilemap_to_vram(0);
+                    gUnknown_03001180 = TRUE;
+                }
+                break;
+            }
+        }
+        if (!flag)
+        {
+            if (gUnknown_03001180 == TRUE)
+            {
+                sub_8198070(1, FALSE);
+                SetWindowBorderStyle(0, FALSE, 0x65, 0x0d);
+            }
+            else
+            {
+                FillWindowPixelBuffer(0, 0x11);
+            }
+            PrintTextOnWindow(0, 1, gUnknown_0203A148->regionMap.mapSecName, 0, 1, 0, NULL);
+            schedule_bg_copy_tilemap_to_vram(0);
+            gUnknown_03001180 = FALSE;
+        }
+    }
+    else
+    {
+        if (gUnknown_03001180 == TRUE)
+        {
+            sub_8198070(1, FALSE);
+            SetWindowBorderStyle(0, FALSE, 0x65, 0x0d);
+        }
+        FillWindowPixelBuffer(0, 0x11);
+        CopyWindowToVram(0, 2);
+        schedule_bg_copy_tilemap_to_vram(0);
+        gUnknown_03001180 = FALSE;
+    }
+}
+
+
+static void sub_8124A70(void)
+{
+    struct SpriteSheet sheet;
+
+    LZ77UnCompWram(gUnknown_085A1D68, gUnknown_0203A148->unk_88c);
+    sheet.data = gUnknown_0203A148->unk_88c;
+    sheet.size = 0x1c0;
+    sheet.tag = 2;
+    LoadSpriteSheet(&sheet);
+    LoadSpritePalette(&gUnknown_085A1F10);
+    sub_8124AD4();
+    sub_8124BE4();
+}
+
+static void sub_8124AD4(void)
+{
+    u16 canFlyFlag;
+    u16 i;
+    u16 x;
+    u16 y;
+    u16 width;
+    u16 height;
+    u16 shape;
+    u8 spriteId;
+
+    canFlyFlag = FLAG_VISITED_LITTLEROOT_TOWN;
+    for (i = 0; i < 16; i++)
+    {
+        sub_8124630(i, &x, &y, &width, &height);
+        x = (x + MAPCURSOR_X_MIN) * 8 + 4;
+        y = (y + MAPCURSOR_Y_MIN) * 8 + 4;
+        if (width == 2)
+        {
+            shape = ST_OAM_H_RECTANGLE;
+        }
+        else if (height == 2)
+        {
+            shape = ST_OAM_V_RECTANGLE;
+        }
+        else
+        {
+            shape = ST_OAM_SQUARE;
+        }
+        spriteId = CreateSprite(&gUnknown_085A1F7C, x, y, 10);
+        if (spriteId != MAX_SPRITES)
+        {
+            gSprites[spriteId].oam.shape = shape;
+            if (FlagGet(canFlyFlag))
+            {
+                gSprites[spriteId].callback = sub_8124CBC;
+            }
+            else
+            {
+                shape += 3;
+            }
+            StartSpriteAnim(&gSprites[spriteId], shape);
+            gSprites[spriteId].data0 = i;
+        }
+        canFlyFlag++;
+    }
+}
+
+static void sub_8124BE4(void)
+{
+    u16 i;
+    u16 x;
+    u16 y;
+    u16 width;
+    u16 height;
+    u16 mapSecId;
+    u8 spriteId;
+
+    for (i = 0; gUnknown_085A1F18[i][1] != MAPSEC_NONE; i++)
+    {
+        if (FlagGet(gUnknown_085A1F18[i][0]))
+        {
+            mapSecId = gUnknown_085A1F18[i][1];
+            sub_8124630(mapSecId, &x, &y, &width, &height);
+            x = (x + MAPCURSOR_X_MIN) * 8;
+            y = (y + MAPCURSOR_Y_MIN) * 8;
+            spriteId = CreateSprite(&gUnknown_085A1F7C, x, y, 10);
+            if (spriteId != MAX_SPRITES)
+            {
+                gSprites[spriteId].oam.size = 1;
+                gSprites[spriteId].callback = sub_8124CBC;
+                StartSpriteAnim(&gSprites[spriteId], 6);
+                gSprites[spriteId].data0 = mapSecId;
+            }
+        }
+    }
+}
+
+static void sub_8124CBC(struct Sprite *sprite)
+{
+    if (gUnknown_0203A148->regionMap.mapSecId == sprite->data0)
+    {
+        if (++sprite->data1 > 16)
+        {
+            sprite->data1 = 0;
+            sprite->invisible = sprite->invisible ? FALSE : TRUE;
+        }
+    }
+    else
+    {
+        sprite->data1 = 16;
+        sprite->invisible = FALSE;
+    }
+}
+
+static void sub_8124D14(void)
+{
+    switch (gUnknown_0203A148->unk_004)
+    {
+        case 0:
+            BeginNormalPaletteFade(-1, 0, 16, 0, 0);
+            gUnknown_0203A148->unk_004++;
+            break;
+        case 1:
+            if (!UpdatePaletteFade())
+            {
+                sub_81248F4(sub_8124D64);
+            }
+            break;
+    }
+}
+
+static void sub_8124D64(void)
+{
+    if (gUnknown_0203A148->unk_004 == 0)
+    {
+        switch (sub_81230AC())
+        {
+            case INPUT_EVENT_NONE:
+            case INPUT_EVENT_MOVE_START:
+            case INPUT_EVENT_MOVE_CONT:
+                break;
+            case INPUT_EVENT_MOVE_END:
+                sub_8124904();
+                break;
+            case INPUT_EVENT_A_BUTTON:
+                if (gUnknown_0203A148->regionMap.iconDrawType == MAPSECTYPE_CITY_CANFLY || gUnknown_0203A148->regionMap.iconDrawType == MAPSECTYPE_BATTLE_FRONTIER)
+                {
+                    m4aSongNumStart(SE_SELECT);
+                    gUnknown_0203A148->unk_a72 = TRUE;
+                    sub_81248F4(sub_8124E0C);
+                }
+                break;
+            case INPUT_EVENT_B_BUTTON:
+                m4aSongNumStart(SE_SELECT);
+                gUnknown_0203A148->unk_a72 = FALSE;
+                sub_81248F4(sub_8124E0C);
+                break;
+        }
+    }
+}
+
+static void sub_8124E0C(void)
+{
+    switch (gUnknown_0203A148->unk_004)
+    {
+        case 0:
+            BeginNormalPaletteFade(-1, 0, 0, 16, 0);
+            gUnknown_0203A148->unk_004++;
+            break;
+        case 1:
+            if (!UpdatePaletteFade())
+            {
+                FreeRegionMapIconResources();
+                if (gUnknown_0203A148->unk_a72)
+                {
+                    switch (gUnknown_0203A148->regionMap.mapSecId)
+                    {
+                        case MAPSEC_SOUTHERN_ISLAND:
+                            sub_8084CCC(0x15);
+                            break;
+                        case MAPSEC_BATTLE_FRONTIER:
+                            sub_8084CCC(0x16);
+                            break;
+                        case MAPSEC_LITTLEROOT_TOWN:
+                            sub_8084CCC(gSaveBlock2Ptr->playerGender == MALE ? 0x0C : 0x0D);
+                            break;
+                        case MAPSEC_EVER_GRANDE_CITY:
+                            sub_8084CCC(FlagGet(FLAG_SYS_POKEMON_LEAGUE_FLY) && gUnknown_0203A148->regionMap.posWithinMapSec == 0 ? 0x14 : 0x0B);
+                            break;
+                        default:
+                            if (gUnknown_085A1E3C[gUnknown_0203A148->regionMap.mapSecId][2] != 0)
+                            {
+                                sub_8084CCC(gUnknown_085A1E3C[gUnknown_0203A148->regionMap.mapSecId][2]);
+                            }
+                            else
+                            {
+                                warp1_set_2(gUnknown_085A1E3C[gUnknown_0203A148->regionMap.mapSecId][0], gUnknown_085A1E3C[gUnknown_0203A148->regionMap.mapSecId][1], -1);
+                            }
+                            break;
+                    }
+                    sub_80B69DC();
+                }
+                else
+                {
+                    SetMainCallback2(sub_81B58A8);
+                }
+                if (gUnknown_0203A148 != NULL)
+                {
+                    free(gUnknown_0203A148);
+                    gUnknown_0203A148 = NULL;
+                }
+                FreeAllWindowBuffers();
+            }
+            break;
+    }
+}
diff --git a/src/secret_base.c b/src/secret_base.c
index 89e276e80..de2b7221a 100644
--- a/src/secret_base.c
+++ b/src/secret_base.c
@@ -1099,9 +1099,9 @@ void game_continue(u8 taskId)
     }
     gUnknown_03006310 = gUnknown_0858D07C;
     gUnknown_03006310.unk_10 = data[6];
-    gUnknown_03006310.unk_0c = data[0];
-    gUnknown_03006310.unk_00 = gUnknown_0203A020->items;
-    gUnknown_03006310.unk_0e = data[3];
+    gUnknown_03006310.totalItems = data[0];
+    gUnknown_03006310.items = gUnknown_0203A020->items;
+    gUnknown_03006310.maxShowed = data[3];
 }
 
 void sub_80E9DEC(u32 a0, bool8 flag, struct ListMenu *menu)
@@ -1866,7 +1866,7 @@ void sub_80EAF80(void *records, size_t recordSize, u8 linkIdx)
 {
     struct SecretBaseRecordMixer mixers[3];
     u16 i;
-    
+
     if (FlagGet(0x60))
     {
         switch (GetLinkPlayerCount())
diff --git a/src/tv.c b/src/tv.c
index 2cb1d4384..c1d648652 100644
--- a/src/tv.c
+++ b/src/tv.c
@@ -6432,10 +6432,10 @@ void DoTVShowTodaysRivalTrainer(void)
                 default:
                     sTVShowState = 7;
                     break;
-                case REGION_MAP_SECRET_BASE:
+                case MAPSEC_SECRET_BASE:
                     sTVShowState = 8;
                     break;
-                case REGION_MAP_NONE:
+                case MAPSEC_DYNAMIC:
                     switch (show->rivalTrainer.mapDataId)
                     {
                         case 0x115 ... 0x117:
@@ -6633,7 +6633,7 @@ void DoTVShowHoennTreasureInvestigators(void)
     {
         case 0:
             StringCopy(gStringVar1, ItemId_GetItem(show->treasureInvestigators.item)->name);
-            if (show->treasureInvestigators.location == REGION_MAP_NONE)
+            if (show->treasureInvestigators.location == MAPSEC_DYNAMIC)
             {
                 switch (show->treasureInvestigators.mapDataId)
                 {