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

42 files changed, 3787 insertions, 580 deletions

diff --git a/src/battle_anim.c b/src/battle_anim.c
index 0a5395b02..590e34cb6 100644
--- a/src/battle_anim.c
+++ b/src/battle_anim.c
@@ -1262,39 +1262,39 @@ s8 BattleAnimAdjustPanning(s8 pan)
     if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive)
     {
         if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
-            pan = PAN_SIDE_OPPONENT;
+            pan = SOUND_PAN_TARGET;
         else
-            pan = PAN_SIDE_PLAYER;
+            pan = SOUND_PAN_ATTACKER;
     }
     else if (IsContest())
     {
-        if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != PAN_SIDE_OPPONENT)
+        if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != SOUND_PAN_TARGET)
             pan *= -1;
     }
     else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER)
     {
         if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER)
         {
-            if (pan == PAN_SIDE_OPPONENT)
-                pan = PAN_SIDE_PLAYER;
-            else if (pan != PAN_SIDE_PLAYER)
+            if (pan == SOUND_PAN_TARGET)
+                pan = SOUND_PAN_ATTACKER;
+            else if (pan != SOUND_PAN_ATTACKER)
                 pan *= -1;
         }
     }
     else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT)
     {
-        if (pan == PAN_SIDE_PLAYER)
-            pan = PAN_SIDE_OPPONENT;
+        if (pan == SOUND_PAN_ATTACKER)
+            pan = SOUND_PAN_TARGET;
     }
     else
     {
         pan *= -1;
     }
 
-    if (pan > PAN_SIDE_OPPONENT)
-        pan = PAN_SIDE_OPPONENT;
-    else if (pan < PAN_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+    if (pan > SOUND_PAN_TARGET)
+        pan = SOUND_PAN_TARGET;
+    else if (pan < SOUND_PAN_ATTACKER)
+        pan = SOUND_PAN_ATTACKER;
 
     return pan;
 }
@@ -1304,9 +1304,9 @@ s8 BattleAnimAdjustPanning2(s8 pan)
     if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive)
     {
         if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
-            pan = PAN_SIDE_OPPONENT;
+            pan = SOUND_PAN_TARGET;
         else
-            pan = PAN_SIDE_PLAYER;
+            pan = SOUND_PAN_ATTACKER;
     }
     else
     {
@@ -1320,10 +1320,10 @@ s16 KeepPanInRange(s16 panArg)
 {
     s16 pan = panArg;
 
-    if (pan > PAN_SIDE_OPPONENT)
-        pan = PAN_SIDE_OPPONENT;
-    else if (pan < PAN_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+    if (pan > SOUND_PAN_TARGET)
+        pan = SOUND_PAN_TARGET;
+    else if (pan < SOUND_PAN_ATTACKER)
+        pan = SOUND_PAN_ATTACKER;
 
     return pan;
 }
diff --git a/src/battle_anim_sound_tasks.c b/src/battle_anim_sound_tasks.c
index 6993bd2ee..7b8eb4ed7 100644
--- a/src/battle_anim_sound_tasks.c
+++ b/src/battle_anim_sound_tasks.c
@@ -23,8 +23,8 @@ void sub_8158B30(u8 taskId)
     gTasks[taskId].data[0] = gBattleAnimArgs[0];
     gTasks[taskId].data[1] = gBattleAnimArgs[1];
 
-    pan1 = BattleAnimAdjustPanning(PAN_SIDE_PLAYER);
-    pan2 = BattleAnimAdjustPanning(PAN_SIDE_OPPONENT);
+    pan1 = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER);
+    pan2 = BattleAnimAdjustPanning(SOUND_PAN_TARGET);
     panIncrement = CalculatePanIncrement(pan1, pan2, 2);
 
     gTasks[taskId].data[2] = pan1;
@@ -64,7 +64,7 @@ static void sub_8158C04(u8 taskId)
         s8 pan;
 
         gTasks[taskId].data[10] = 0;
-        pan = BattleAnimAdjustPanning(PAN_SIDE_OPPONENT);
+        pan = BattleAnimAdjustPanning(SOUND_PAN_TARGET);
         PlaySE12WithPanning(gTasks[taskId].data[1], pan);
         if (++gTasks[taskId].data[11] == 2)
             DestroyAnimSoundTask(taskId);
@@ -127,7 +127,7 @@ static void sub_8158D08(u8 taskId)
 void sub_8158D8C(u8 taskId)
 {
     u16 species = 0;
-    s8 pan = BattleAnimAdjustPanning(PAN_SIDE_PLAYER);
+    s8 pan = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER);
     if (IsContest())
     {
         if (gBattleAnimArgs[0] == ANIM_ATTACKER)
@@ -173,7 +173,7 @@ void sub_8158D8C(u8 taskId)
 void sub_8158E9C(u8 taskId)
 {
     u16 species = 0;
-    s8 pan = BattleAnimAdjustPanning(PAN_SIDE_PLAYER);
+    s8 pan = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER);
     if (IsContest())
     {
         if (gBattleAnimArgs[0] == ANIM_ATTACKER)
@@ -278,7 +278,7 @@ void sub_81590B8(u8 taskId)
     s8 pan;
 
     gTasks[taskId].data[10] = gBattleAnimArgs[0];
-    pan = BattleAnimAdjustPanning(PAN_SIDE_PLAYER);
+    pan = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER);
 
     if (IsContest())
         species = gContestResources->field_18->unk0;
diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c
index 637b8c702..4fea3aca8 100644
--- a/src/battle_controller_link_opponent.c
+++ b/src/battle_controller_link_opponent.c
@@ -1364,7 +1364,7 @@ static void LinkOpponentHandleFaintAnimation(void)
         if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
         {
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_OPPONENT);
+            PlaySE12WithPanning(SE_POKE_DEAD, SOUND_PAN_TARGET);
             gSprites[gBattlerSpriteIds[gActiveBattler]].callback = SpriteCB_FaintOpponentMon;
             gBattlerControllerFuncs[gActiveBattler] = sub_8064C14;
         }
@@ -1660,9 +1660,9 @@ static void LinkOpponentHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     LinkOpponentBufferExecCompleted();
diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c
index bfaaf9e82..51e26b620 100644
--- a/src/battle_controller_link_partner.c
+++ b/src/battle_controller_link_partner.c
@@ -1187,7 +1187,7 @@ static void LinkPartnerHandleFaintAnimation(void)
         {
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
             HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-            PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_PLAYER);
+            PlaySE12WithPanning(SE_POKE_DEAD, SOUND_PAN_ATTACKER);
             gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0;
             gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = 5;
             gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_8039C00;
@@ -1485,9 +1485,9 @@ static void LinkPartnerHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     LinkPartnerBufferExecCompleted();
diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c
index c490ad314..b8b5bd3b8 100644
--- a/src/battle_controller_opponent.c
+++ b/src/battle_controller_opponent.c
@@ -1402,7 +1402,7 @@ static void OpponentHandleFaintAnimation(void)
         if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
         {
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_OPPONENT);
+            PlaySE12WithPanning(SE_POKE_DEAD, SOUND_PAN_TARGET);
             gSprites[gBattlerSpriteIds[gActiveBattler]].callback = SpriteCB_FaintOpponentMon;
             gBattlerControllerFuncs[gActiveBattler] = sub_805FAC4;
         }
@@ -1810,9 +1810,9 @@ static void OpponentHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     OpponentBufferExecCompleted();
diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c
index 57a4efa9f..6bc6c6f49 100644
--- a/src/battle_controller_player.c
+++ b/src/battle_controller_player.c
@@ -2407,7 +2407,7 @@ static void PlayerHandleFaintAnimation(void)
         {
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
             HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-            PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_PLAYER);
+            PlaySE12WithPanning(SE_POKE_DEAD, SOUND_PAN_ATTACKER);
             gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0;
             gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = 5;
             gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_8039C00;
@@ -2710,7 +2710,7 @@ static void PlayerHandleExpUpdate(void)
 {
     u8 monId = gBattleBufferA[gActiveBattler][1];
 
-    if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_MON_LEVEL)
+    if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_LEVEL)
     {
         PlayerBufferExecCompleted();
     }
@@ -2882,9 +2882,9 @@ static void PlayerHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     PlayerBufferExecCompleted();
diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c
index 7795c5656..e893d2f3d 100644
--- a/src/battle_controller_player_partner.c
+++ b/src/battle_controller_player_partner.c
@@ -1382,7 +1382,7 @@ static void PlayerPartnerHandleFaintAnimation(void)
         {
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
             HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-            PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_PLAYER);
+            PlaySE12WithPanning(SE_POKE_DEAD, SOUND_PAN_ATTACKER);
             gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0;
             gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = 5;
             gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_8039C00;
@@ -1597,7 +1597,7 @@ static void PlayerPartnerHandleExpUpdate(void)
 {
     u8 monId = gBattleBufferA[gActiveBattler][1];
 
-    if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_MON_LEVEL)
+    if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_LEVEL)
     {
         PlayerPartnerBufferExecCompleted();
     }
@@ -1739,9 +1739,9 @@ static void PlayerPartnerHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     PlayerPartnerBufferExecCompleted();
diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c
index 963c535db..57eb6842e 100644
--- a/src/battle_controller_recorded_opponent.c
+++ b/src/battle_controller_recorded_opponent.c
@@ -1295,7 +1295,7 @@ static void RecordedOpponentHandleFaintAnimation(void)
         if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
         {
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_OPPONENT);
+            PlaySE12WithPanning(SE_POKE_DEAD, SOUND_PAN_TARGET);
             gSprites[gBattlerSpriteIds[gActiveBattler]].callback = SpriteCB_FaintOpponentMon;
             gBattlerControllerFuncs[gActiveBattler] = sub_8186D58;
         }
@@ -1603,9 +1603,9 @@ static void RecordedOpponentHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     RecordedOpponentBufferExecCompleted();
diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c
index 1a043573f..f6c19121d 100644
--- a/src/battle_controller_recorded_player.c
+++ b/src/battle_controller_recorded_player.c
@@ -1624,9 +1624,9 @@ static void RecordedPlayerHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     RecordedPlayerBufferExecCompleted();
diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c
index 898e18294..148f13865 100644
--- a/src/battle_controller_safari.c
+++ b/src/battle_controller_safari.c
@@ -594,9 +594,9 @@ static void SafariHandlePlaySE(void)
     s8 pan;
 
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        pan = PAN_SIDE_PLAYER;
+        pan = SOUND_PAN_ATTACKER;
     else
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
     SafariBufferExecCompleted();
diff --git a/src/battle_interface.c b/src/battle_interface.c
index d2750bf9d..ad9737668 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -20,6 +20,7 @@
 #include "international_string_util.h"
 #include "safari_zone.h"
 #include "battle_anim.h"
+#include "constants/battle_anim.h"
 #include "constants/rgb.h"
 #include "data2.h"
 
@@ -1889,9 +1890,9 @@ static void SpriteCB_StatusSummaryBallsOnBattleStart(struct Sprite *sprite)
 
     if (sprite->pos2.x == 0)
     {
-        pan = PAN_SIDE_OPPONENT;
+        pan = SOUND_PAN_TARGET;
         if (var1 != 0)
-            pan = PAN_SIDE_PLAYER;
+            pan = SOUND_PAN_ATTACKER;
 
         if (sprite->data[7] != 0)
             PlaySE2WithPanning(SE_TB_KARA, pan);
@@ -2341,7 +2342,7 @@ static void MoveBattleBarGraphically(u8 battlerId, u8 whichBar)
                     &gBattleSpritesDataPtr->battleBars[battlerId].currValue,
                     array, B_EXPBAR_PIXELS / 8);
         level = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_LEVEL);
-        if (level == MAX_MON_LEVEL)
+        if (level == MAX_LEVEL)
         {
             for (i = 0; i < 8; i++)
                 array[i] = 0;
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index 685f0db7a..33d86924f 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -3347,7 +3347,7 @@ static void atk23_getexp(void)
                 gBattleScripting.atk23_state = 5;
                 gBattleMoveDamage = 0; // used for exp
             }
-            else if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) == MAX_MON_LEVEL)
+            else if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) == MAX_LEVEL)
             {
                 *(&gBattleStruct->sentInPokes) >>= 1;
                 gBattleScripting.atk23_state = 5;
@@ -3382,17 +3382,17 @@ static void atk23_getexp(void)
                         // check if the pokemon doesn't belong to the player
                         if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gBattleStruct->expGetterMonId >= 3)
                         {
-                            i = 0x149;
+                            i = STRINGID_EMPTYSTRING4;
                         }
                         else
                         {
                             gBattleMoveDamage = (gBattleMoveDamage * 150) / 100;
-                            i = 0x14A;
+                            i = STRINGID_ABOOSTED;
                         }
                     }
                     else
                     {
-                        i = 0x149;
+                        i = STRINGID_EMPTYSTRING4;
                     }
 
                     // get exp getter battlerId
@@ -3430,7 +3430,7 @@ static void atk23_getexp(void)
         if (gBattleControllerExecFlags == 0)
         {
             gBattleBufferB[gBattleStruct->expGetterBattlerId][0] = 0;
-            if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP) && GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) != MAX_MON_LEVEL)
+            if (GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_HP) && GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_LEVEL) != MAX_LEVEL)
             {
                 gBattleResources->statsBeforeLvlUp->hp = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_MAX_HP);
                 gBattleResources->statsBeforeLvlUp->atk = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_ATK);
diff --git a/src/battle_setup.c b/src/battle_setup.c
index 5cb60ebca..d74fef9cc 100644
--- a/src/battle_setup.c
+++ b/src/battle_setup.c
@@ -56,8 +56,8 @@ extern bool8 InBattlePyramid(void);
 extern bool8 InBattlePike(void);
 extern bool32 InTrainerHill(void);
 extern bool32 FieldPoisonEffectIsRunning(void);
-extern void prev_quest_postbuffer_cursor_backup_reset(void);
-extern void ResetPoisonStepCounter(void);
+extern void RestartWildEncounterImmunitySteps(void);
+extern void ClearPoisonStepCounter(void);
 extern void sub_81BE72C(void);
 extern void sub_808BCF4(void);
 extern void sub_80EECC8(void);
@@ -354,8 +354,8 @@ static void Task_BattleStart(u8 taskId)
         {
             overworld_free_bg_tilemaps();
             SetMainCallback2(CB2_InitBattle);
-            prev_quest_postbuffer_cursor_backup_reset();
-            ResetPoisonStepCounter();
+            RestartWildEncounterImmunitySteps();
+            ClearPoisonStepCounter();
             DestroyTask(taskId);
         }
         break;
@@ -921,8 +921,8 @@ static void CB2_StartFirstBattle(void)
         gMain.savedCallback = CB2_EndFirstBattle;
         FreeAllWindowBuffers();
         SetMainCallback2(CB2_InitBattle);
-        prev_quest_postbuffer_cursor_backup_reset();
-        ResetPoisonStepCounter();
+        RestartWildEncounterImmunitySteps();
+        ClearPoisonStepCounter();
         IncrementGameStat(GAME_STAT_TOTAL_BATTLES);
         IncrementGameStat(GAME_STAT_WILD_BATTLES);
         sub_80EECC8();
diff --git a/src/berry.c b/src/berry.c
index ce2a29901..7b0b2cdb0 100644
--- a/src/berry.c
+++ b/src/berry.c
@@ -12,7 +12,7 @@
 extern u8 EventObjectGetBerryTreeId(u8 eventObjectId);
 extern void sub_8092EF0(u8 mapId, u8 mapNumber, u8 mapGroup);
 extern void CB2_ChooseBerry(void);
-extern const u8* GetEventObjectScriptPointerForComparison(void);
+extern const u8* GetEventObjectScriptPointerPlayerFacing(void);
 extern bool8 IsBerryTreeSparkling(u8, u8, u8);
 
 extern u16 gSpecialVar_ItemId;
@@ -943,7 +943,7 @@ bool32 EventObjectInteractionWaterBerryTree(void)
 
 bool8 IsPlayerFacingPlantedBerryTree(void)
 {
-    if (GetEventObjectScriptPointerForComparison() == BerryTreeScript
+    if (GetEventObjectScriptPointerPlayerFacing() == BerryTreeScript
      && GetStageByBerryTreeId(EventObjectGetBerryTreeId(gSelectedEventObject)) == 0)
         return TRUE;
     else
@@ -952,7 +952,7 @@ bool8 IsPlayerFacingPlantedBerryTree(void)
 
 bool8 TryToWaterBerryTree(void)
 {
-    if (GetEventObjectScriptPointerForComparison() != BerryTreeScript)
+    if (GetEventObjectScriptPointerPlayerFacing() != BerryTreeScript)
         return FALSE;
     else
         return EventObjectInteractionWaterBerryTree();
diff --git a/src/berry_blender.c b/src/berry_blender.c
index a5b940189..8e0bc8043 100644
--- a/src/berry_blender.c
+++ b/src/berry_blender.c
@@ -1124,7 +1124,7 @@ static void Blender_SetPlayerNamesLocal(u8 opponentsNum)
         sBerryBlenderData->playersNo = 2;
         StringCopy(gLinkPlayers[0].name, gSaveBlock2Ptr->playerName);
 
-        if (!FlagGet(FLAG_0x340))
+        if (!FlagGet(FLAG_HIDE_LILYCOVE_CONTEST_HALL_BLEND_MASTER_ONLOOKERS))
             StringCopy(gLinkPlayers[1].name, sBlenderOpponentsNames[BLENDER_MASTER]);
         else
             StringCopy(gLinkPlayers[1].name, sBlenderOpponentsNames[BLENDER_MISTER]);
@@ -1647,7 +1647,7 @@ static void sub_80808D4(void)
 
         if (gSpecialVar_0x8004 == 1)
         {
-            if (!FlagGet(FLAG_0x340))
+            if (!FlagGet(FLAG_HIDE_LILYCOVE_CONTEST_HALL_BLEND_MASTER_ONLOOKERS))
                 sBerryBlenderData->field_120[0] = CreateTask(sub_8081224, 10);
             else
                 sBerryBlenderData->field_120[0] = CreateTask(sUnknown_083399EC[0], 10);
diff --git a/src/bike.c b/src/bike.c
index 742b2a6bb..b9d247c5d 100644
--- a/src/bike.c
+++ b/src/bike.c
@@ -18,7 +18,7 @@ extern u8 sub_808B980(u8 direction);
 extern u8 sub_808B9BC(u8 direction);
 extern u8 sub_808B9A4(u8 direction);
 extern u8 sub_808C1B4(u8 direction);
-extern u8 npc_use_some_d2s(u8 direction);
+extern u8 sub_808B9D4(u8 direction);
 extern void Overworld_ClearSavedMusic(void);
 extern void Overworld_PlaySpecialMapMusic(void);
 
@@ -575,7 +575,7 @@ static void AcroBikeTransition_Moving(u8 direction)
     }
     else
     {
-        PlayerGoSpeed3(direction);
+        PlayerRideWaterCurrent(direction);
     }
 }
 
@@ -768,7 +768,7 @@ static void AcroBikeTransition_WheelieLoweringMoving(u8 direction)
             PlayerEndWheelie(direction);
         return;
     }
-    npc_use_some_d2s(direction);
+    sub_808B9D4(direction);
 }
 
 void Bike_TryAcroBikeHistoryUpdate(u16 newKeys, u16 heldKeys)
diff --git a/src/braille_puzzles.c b/src/braille_puzzles.c
index 4765141de..76394e937 100644
--- a/src/braille_puzzles.c
+++ b/src/braille_puzzles.c
@@ -431,9 +431,9 @@ bool8 ShouldDoBrailleRegicePuzzle(void)
     {
         if (FlagGet(FLAG_SYS_BRAILLE_WAIT) != FALSE)
             return FALSE;
-        if (FlagGet(FLAG_0x002) == FALSE)
+        if (FlagGet(FLAG_TEMP_2) == FALSE)
             return FALSE;
-        if (FlagGet(FLAG_0x003) == TRUE)
+        if (FlagGet(FLAG_TEMP_3) == TRUE)
             return FALSE;
 
         for (i = 0; i < 36; i++)
@@ -474,8 +474,8 @@ bool8 ShouldDoBrailleRegicePuzzle(void)
             }
         }
 
-        FlagSet(FLAG_0x003);
-        FlagClear(FLAG_0x002);
+        FlagSet(FLAG_TEMP_3);
+        FlagClear(FLAG_TEMP_2);
     }
 
     return FALSE;
diff --git a/src/data/pokemon/experience_tables.h b/src/data/pokemon/experience_tables.h
index 58474b6f1..9fd5a2fae 100644
--- a/src/data/pokemon/experience_tables.h
+++ b/src/data/pokemon/experience_tables.h
@@ -18,7 +18,7 @@
     :(n <= 36) ? ((n + 14)           * CUBE(n) / 50)        \
     :            (((n / 2) + 32)     * CUBE(n) / 50)
 
-const u32 gExperienceTables[][MAX_MON_LEVEL + 1] =
+const u32 gExperienceTables[][MAX_LEVEL + 1] =
 {
     { // Medium Fast
         0, // 0
diff --git a/src/daycare.c b/src/daycare.c
index 934cdea43..c80a8b743 100644
--- a/src/daycare.c
+++ b/src/daycare.c
@@ -241,7 +241,7 @@ static void ApplyDaycareExperience(struct Pokemon *mon)
     bool8 firstMove;
     u16 learnedMove;
 
-    for (i = 0; i < MAX_MON_LEVEL; i++)
+    for (i = 0; i < MAX_LEVEL; i++)
     {
         // Add the mon's gained daycare experience level by level until it can't level up anymore.
         if (TryIncrementMonLevel(mon))
@@ -278,7 +278,7 @@ static u16 TakeSelectedPokemonFromDaycare(struct DaycareMon *daycareMon)
     species = GetBoxMonData(&daycareMon->mon, MON_DATA_SPECIES);
     BoxMonToMon(&daycareMon->mon, &pokemon);
 
-    if (GetMonData(&pokemon, MON_DATA_LEVEL) != MAX_MON_LEVEL)
+    if (GetMonData(&pokemon, MON_DATA_LEVEL) != MAX_LEVEL)
     {
         experience = GetMonData(&pokemon, MON_DATA_EXP) + daycareMon->steps;
         SetMonData(&pokemon, MON_DATA_EXP, &experience);
@@ -949,7 +949,7 @@ static bool8 _DoEggActions_CheckHatch(struct DayCare *daycare)
     return FALSE; // no hatching
 }
 
-bool8 DoEggActions_CheckHatch(void)
+bool8 ShouldEggHatch(void)
 {
     return _DoEggActions_CheckHatch(&gSaveBlock1Ptr->daycare);
 }
diff --git a/src/event_object_movement.c b/src/event_object_movement.c
index d3c8da3b5..078cc0fae 100644
--- a/src/event_object_movement.c
+++ b/src/event_object_movement.c
@@ -17,7 +17,6 @@
 #include "pokenav.h"
 #include "random.h"
 #include "rom_818CFC8.h"
-#include "rom_81BE66C.h"
 #include "sprite.h"
 #include "trainer_see.h"
 #include "util.h"
@@ -2621,10 +2620,10 @@ void sub_808F28C(u8 localId, u8 mapNum, u8 mapGroup, u8 decorCat)
         switch (decorCat)
         {
             case DECORCAT_DOLL:
-                OverrideMovementTypeForEventObject(&gEventObjects[eventObjectId], EventScript_2766A2);
+                OverrideMovementTypeForEventObject(&gEventObjects[eventObjectId], EventScript_SecretPower1);
                 break;
             case DECORCAT_CUSHION:
-                OverrideMovementTypeForEventObject(&gEventObjects[eventObjectId], EventScript_2766A6);
+                OverrideMovementTypeForEventObject(&gEventObjects[eventObjectId], EventScript_SecretPower2);
                 break;
         }
     }
diff --git a/src/evolution_scene.c b/src/evolution_scene.c
index c00aaeb15..067e103c2 100644
--- a/src/evolution_scene.c
+++ b/src/evolution_scene.c
@@ -27,6 +27,7 @@
 #include "link.h"
 #include "util.h"
 #include "trig.h"
+#include "data2.h"
 
 struct EvoInfo
 {
@@ -48,8 +49,6 @@ extern u16 gBattle_BG2_X;
 extern u16 gBattle_BG2_Y;
 extern u16 gBattle_BG3_X;
 extern u16 gBattle_BG3_Y;
-extern bool8 gAffineAnimsDisabled;
-extern const u8 gSpeciesNames[][11];
 
 #define sEvoCursorPos           gBattleCommunication[1] // when learning a new move
 #define sEvoGraphicsTaskID      gBattleCommunication[2]
@@ -60,12 +59,9 @@ extern const struct CompressedSpriteSheet gMonFrontPicTable[];
 // strings
 extern const u8 gText_CommunicationStandby5[];
 
-extern void sub_80356D0(void);
 extern void sub_807B154(void);
 extern void sub_807F19C(void);
 extern void sub_807B140(void);
-extern void EvolutionRenameMon(struct Pokemon *mon, u16 oldSpecies, u16 newSpecies);
-extern void Overworld_PlaySpecialMapMusic(void);
 extern void ShowSelectMovePokemonSummaryScreen(struct Pokemon *party, u8 monId, u8 partyCount, void *CB2_ptr, u16 move);
 extern u8 sub_81C1B94(void);
 extern void sub_807F1A8(u8 arg0, const u8 *arg1, u8 arg2);
diff --git a/src/field_control_avatar.c b/src/field_control_avatar.c
new file mode 100644
index 000000000..7fd07af5c
--- /dev/null
+++ b/src/field_control_avatar.c
@@ -0,0 +1,1058 @@
+#include "global.h"
+#include "battle_setup.h"
+#include "battle_frontier_1.h"
+#include "bike.h"
+#include "coord_event_weather.h"
+#include "daycare.h"
+#include "event_data.h"
+#include "event_object_movement.h"
+#include "fieldmap.h"
+#include "field_control_avatar.h"
+#include "field_fadetransition.h"
+#include "field_player_avatar.h"
+#include "field_poison.h"
+#include "field_screen.h"
+#include "field_specials.h"
+#include "fldeff_80F9BCC.h"
+#include "item_menu.h"
+#include "link.h"
+#include "metatile_behavior.h"
+#include "overworld.h"
+#include "pokemon.h"
+#include "pokenav.h"
+#include "safari_zone.h"
+#include "script.h"
+#include "secret_base.h"
+#include "sound.h"
+#include "start_menu.h"
+#include "trainer_see.h"
+#include "wild_encounter.h"
+#include "constants/bg_event_constants.h"
+#include "constants/map_types.h"
+#include "constants/songs.h"
+
+static EWRAM_DATA u8 sWildEncounterImmunitySteps = 0;
+static EWRAM_DATA u16 sPreviousPlayerMetatileBehavior = 0;
+
+u8 gSelectedEventObject;
+
+//scripts
+extern const u8 EventScript_PlayerPCMale[];
+extern const u8 EventScript_PlayerPCFemale[];
+extern const u8 EventScript_SecretBasePC[];
+extern const u8 EventScript_RecordMixingSecretBasePC[];
+extern const u8 EventScript_SecretPower1[];
+extern const u8 EventScript_SecretPower2[];
+extern const u8 EventScript_PC[];
+extern const u8 EventScript_TestSignpostMsg[];
+extern const u8 EventScript_HiddenItemScript[];
+extern const u8 EventScript_2759F1[];
+extern const u8 EventScript_TV[];
+extern const u8 EventScript_ClosedSootopolisDoor[];
+extern const u8 SkyPillar_Outside_EventScript_2393F9[];
+extern const u8 EventScript_CableBoxResults[];
+extern const u8 EventScript_2A4BAC[];
+extern const u8 Route110_TrickHouseEntrance_EventScript_26A22A[];
+extern const u8 EventScript_RegionMap[];
+extern const u8 EventScript_RunningShoesManual[];
+extern const u8 EventScript_PictureBookShelf[];
+extern const u8 EventScript_BookShelf[];
+extern const u8 EventScript_PokemonCenterBookshelf[];
+extern const u8 EventScript_Vase[];
+extern const u8 EventScript_TrashCan[];
+extern const u8 EventScript_ShopShelf[];
+extern const u8 EventScript_Blueprint[];
+extern const u8 EventScript_WirelessBoxResults[];
+extern const u8 EventScript_CableBoxResults[];
+extern const u8 EventScript_Questionnaire[];
+extern const u8 EventScript_TrainerHillTimer[];
+extern const u8 EventScript_SecretBaseSandOrnament[];
+extern const u8 EventScript_SecretBaseShieldOrToyTV[];
+extern const u8 EventScript_UseSurf[];
+extern const u8 EventScript_UseWaterfall[];
+extern const u8 EventScript_CannotUseWaterfall[];
+extern const u8 EventScript_UseDive[];
+extern const u8 EventScript_UseDiveUnderwater[];
+extern const u8 EventScript_FallDownHole[];
+extern const u8 BattleFrontier_BattlePyramidEmptySquare_EventScript_252BE8[];
+extern const u8 EventScript_Poison[];
+extern const u8 EventScript_EggHatch[];
+extern const u8 gUnknown_08273D1F[];
+extern const u8 IslandCave_EventScript_238EAF[];
+extern const u8 MauvilleCity_EventScript_1DF7BA[];
+extern const u8 Route119_EventScript_1F49EC[];
+extern const u8 LittlerootTown_ProfessorBirchsLab_EventScript_1FA4D6[];
+extern const u8 RustboroCity_Gym_EventScript_21307B[];
+extern const u8 MossdeepCity_SpaceCenter_2F_EventScript_224175[];
+extern const u8 SSTidalCorridor_EventScript_23C050[];
+extern const u8 gUnknown_082A8350[];
+
+static void GetPlayerPosition(struct MapPosition *);
+static void GetInFrontOfPlayerPosition(struct MapPosition *);
+static u16 GetPlayerCurMetatileBehavior(int);
+static bool8 TryStartInteractionScript(struct MapPosition*, u16, u8);
+static const u8 *GetInteractionScript(struct MapPosition*, u8, u8);
+static const u8 *GetInteractedEventObjectScript(struct MapPosition *, u8, u8);
+static const u8 *GetInteractedBackgroundEventScript(struct MapPosition *, u8, u8);
+static const u8 *GetInteractedMetatileScript(struct MapPosition *, u8, u8);
+static const u8 *GetInteractedWaterScript(struct MapPosition *, u8, u8);
+static bool32 TrySetupDiveDownScript(void);
+static bool32 TrySetupDiveEmergeScript(void);
+static bool8 TryStartStepBasedScript(struct MapPosition *, u16, u16);
+static bool8 CheckStandardWildEncounter(u16);
+static bool8 mapheader_run_first_tag2_script_list_match_conditionally(struct MapPosition *, u16, u8);
+static bool8 IsWarpMetatileBehavior(u16);
+static bool8 IsArrowWarpMetatileBehavior(u16, u8);
+static s8 GetWarpEventAtMapPosition(struct MapHeader *, struct MapPosition *);
+static void sub_809CEB0(struct MapHeader *, s8, struct MapPosition *);
+static bool8 map_warp_consider_2_to_inside(struct MapPosition *, u16, u8);
+static s8 GetWarpEventAtPosition(struct MapHeader *, u16, u16, u8);
+static u8 *GetCoordEventScriptAtPosition(struct MapHeader *, u16, u16, u8);
+static struct BgEvent *GetBackgroundEventAtPosition(struct MapHeader *, u16, u16, u8);
+static bool8 TryStartCoordEventScript(struct MapPosition *);
+static bool8 TryStartWarpEventScript(struct MapPosition *, u16);
+static bool8 TryStartMiscWalkingScripts(u16);
+static bool8 TryStartStepCountScript(u16);
+static void UpdateHappinessStepCounter(void);
+static bool8 UpdatePoisonStepCounter(void);
+
+void FieldClearPlayerInput(struct FieldInput *input)
+{
+    input->pressedAButton = FALSE;
+    input->checkStandardWildEncounter = FALSE;
+    input->pressedStartButton = FALSE;
+    input->pressedSelectButton = FALSE;
+    input->input_field_0_4 = FALSE;
+    input->input_field_0_5 = FALSE;
+    input->tookStep = FALSE;
+    input->pressedBButton = FALSE;
+    input->input_field_1_0 = FALSE;
+    input->input_field_1_1 = FALSE;
+    input->input_field_1_2 = FALSE;
+    input->input_field_1_3 = FALSE;
+    input->dpadDirection = 0;
+}
+
+void FieldGetPlayerInput(struct FieldInput *input, u16 newKeys, u16 heldKeys)
+{
+    u8 tileTransitionState = gPlayerAvatar.tileTransitionState;
+    u8 runningState = gPlayerAvatar.runningState;
+    bool8 forcedMove = MetatileBehavior_IsForcedMovementTile(GetPlayerCurMetatileBehavior(runningState));
+
+    if ((tileTransitionState == T_TILE_CENTER && forcedMove == FALSE) || tileTransitionState == T_NOT_MOVING)
+    {
+        if (GetPlayerSpeed() != 4)
+        {
+            if (newKeys & START_BUTTON)
+                input->pressedStartButton = TRUE;
+            if (newKeys & SELECT_BUTTON)
+                input->pressedSelectButton = TRUE;
+            if (newKeys & A_BUTTON)
+                input->pressedAButton = TRUE;
+            if (newKeys & B_BUTTON)
+                input->pressedBButton = TRUE;
+        }
+
+        if (heldKeys & (DPAD_UP | DPAD_DOWN | DPAD_LEFT | DPAD_RIGHT))
+        {
+            input->input_field_0_4 = TRUE;
+            input->input_field_0_5 = TRUE;
+        }
+    }
+
+    if (forcedMove == FALSE)
+    {
+        if (tileTransitionState == T_TILE_CENTER && runningState == MOVING)
+            input->tookStep = TRUE;
+        if (forcedMove == FALSE && tileTransitionState == T_TILE_CENTER)
+            input->checkStandardWildEncounter = TRUE;
+    }
+
+    if (heldKeys & DPAD_UP)
+        input->dpadDirection = DIR_NORTH;
+    else if (heldKeys & DPAD_DOWN)
+        input->dpadDirection = DIR_SOUTH;
+    else if (heldKeys & DPAD_LEFT)
+        input->dpadDirection = DIR_WEST;
+    else if (heldKeys & DPAD_RIGHT)
+        input->dpadDirection = DIR_EAST;
+}
+
+int ProcessPlayerFieldInput(struct FieldInput *input)
+{
+    struct MapPosition position;
+    u8 playerDirection;
+    u16 metatileBehavior;
+
+    gSpecialVar_LastTalked = 0;
+    gSelectedEventObject = 0;
+
+    playerDirection = GetPlayerFacingDirection();
+    GetPlayerPosition(&position);
+    metatileBehavior = MapGridGetMetatileBehaviorAt(position.x, position.y);
+
+    if (CheckForTrainersWantingBattle() == TRUE)
+        return TRUE;
+
+    if (mapheader_run_first_tag2_script_list_match() == 1)
+        return TRUE;
+
+    if (input->pressedBButton && TrySetupDiveEmergeScript() == TRUE)
+        return TRUE;
+    if (input->tookStep)
+    {
+        IncrementGameStat(GAME_STAT_STEPS);
+        increment_var_x4026_on_birth_island_modulo_100();
+        if (TryStartStepBasedScript(&position, metatileBehavior, playerDirection) == TRUE)
+            return TRUE;
+    }
+    if (input->checkStandardWildEncounter && CheckStandardWildEncounter(metatileBehavior) == TRUE)
+        return TRUE;
+    if (input->input_field_0_4 && input->dpadDirection == playerDirection)
+    {
+        if (mapheader_run_first_tag2_script_list_match_conditionally(&position, metatileBehavior, playerDirection) == TRUE)
+            return TRUE;
+    }
+
+    GetInFrontOfPlayerPosition(&position);
+    metatileBehavior = MapGridGetMetatileBehaviorAt(position.x, position.y);
+    if (input->pressedAButton && TryStartInteractionScript(&position, metatileBehavior, playerDirection) == TRUE)
+        return TRUE;
+
+    if (input->input_field_0_5 && input->dpadDirection == playerDirection)
+    {
+        if (map_warp_consider_2_to_inside(&position, metatileBehavior, playerDirection) == TRUE)
+            return TRUE;
+    }
+    if (input->pressedAButton && TrySetupDiveDownScript() == TRUE)
+        return TRUE;
+    if (input->pressedStartButton)
+    {
+        PlaySE(SE_WIN_OPEN);
+        ShowStartMenu();
+        return TRUE;
+    }
+    if (input->pressedSelectButton && UseRegisteredKeyItemOnField() == TRUE)
+        return TRUE;
+
+    return FALSE;
+}
+
+static void GetPlayerPosition(struct MapPosition *position)
+{
+    PlayerGetDestCoords(&position->x, &position->y);
+    position->height = PlayerGetZCoord();
+}
+
+static void GetInFrontOfPlayerPosition(struct MapPosition *position)
+{
+    s16 x, y;
+
+    GetXYCoordsOneStepInFrontOfPlayer(&position->x, &position->y);
+    PlayerGetDestCoords(&x, &y);
+    if (MapGridGetZCoordAt(x, y) != 0)
+        position->height = PlayerGetZCoord();
+    else
+        position->height = 0;
+}
+
+static u16 GetPlayerCurMetatileBehavior(int runningState)
+{
+    s16 x, y;
+
+    PlayerGetDestCoords(&x, &y);
+    return MapGridGetMetatileBehaviorAt(x, y);
+}
+
+static bool8 TryStartInteractionScript(struct MapPosition *position, u16 metatileBehavior, u8 direction)
+{
+    const u8 *script = GetInteractionScript(position, metatileBehavior, direction);
+    if (script == NULL)
+        return FALSE;
+
+    // Don't play interaction sound for certain scripts.
+    if (script != EventScript_PlayerPCMale
+     && script != EventScript_PlayerPCFemale
+     && script != EventScript_SecretBasePC
+     && script != EventScript_RecordMixingSecretBasePC
+     && script != EventScript_SecretPower1
+     && script != EventScript_SecretPower2
+     && script != EventScript_PC)
+        PlaySE(SE_SELECT);
+
+    ScriptContext1_SetupScript(script);
+    return TRUE;
+}
+
+static const u8 *GetInteractionScript(struct MapPosition *position, u8 metatileBehavior, u8 direction)
+{
+    const u8 *script = GetInteractedEventObjectScript(position, metatileBehavior, direction);
+    if (script != NULL)
+        return script;
+
+    script = GetInteractedBackgroundEventScript(position, metatileBehavior, direction);
+    if (script != NULL)
+        return script;
+
+    script = GetInteractedMetatileScript(position, metatileBehavior, direction);
+    if (script != NULL)
+        return script;
+
+    script = GetInteractedWaterScript(position, metatileBehavior, direction);
+    if (script != NULL)
+        return script;
+
+    return NULL;
+}
+
+const u8 *GetInteractedLinkPlayerScript(struct MapPosition *position, u8 metatileBehavior, u8 direction)
+{
+    u8 eventObjectId;
+    s32 i;
+
+    if (!MetatileBehavior_IsCounter(MapGridGetMetatileBehaviorAt(position->x, position->y)))
+        eventObjectId = GetEventObjectIdByXYZ(position->x, position->y, position->height);
+    else
+        eventObjectId = GetEventObjectIdByXYZ(position->x + gDirectionToVectors[direction].x, position->y + gDirectionToVectors[direction].y, position->height);
+
+    if (eventObjectId == 16 || gEventObjects[eventObjectId].localId == 0xFF)
+        return NULL;
+
+    for (i = 0; i < 4; i++)
+    {
+        if (gLinkPlayerEventObjects[i].active == TRUE && gLinkPlayerEventObjects[i].eventObjId == eventObjectId)
+            return NULL;
+    }
+
+    gSelectedEventObject = eventObjectId;
+    gSpecialVar_LastTalked = gEventObjects[eventObjectId].localId;
+    gSpecialVar_Facing = direction;
+    return GetEventObjectScriptPointerByEventObjectId(eventObjectId);
+}
+
+static const u8 *GetInteractedEventObjectScript(struct MapPosition *position, u8 metatileBehavior, u8 direction)
+{
+    u8 eventObjectId;
+    const u8 *script;
+
+    eventObjectId = GetEventObjectIdByXYZ(position->x, position->y, position->height);
+    if (eventObjectId == 16 || gEventObjects[eventObjectId].localId == 0xFF)
+    {
+        if (MetatileBehavior_IsCounter(metatileBehavior) != TRUE)
+            return NULL;
+
+        // Look for an event object on the other side of the counter.
+        eventObjectId = GetEventObjectIdByXYZ(position->x + gDirectionToVectors[direction].x, position->y + gDirectionToVectors[direction].y, position->height);
+        if (eventObjectId == 16 || gEventObjects[eventObjectId].localId == 0xFF)
+            return NULL;
+    }
+
+    gSelectedEventObject = eventObjectId;
+    gSpecialVar_LastTalked = gEventObjects[eventObjectId].localId;
+    gSpecialVar_Facing = direction;
+
+    if (InTrainerHill() == TRUE)
+    {
+        script = sub_81D62AC();
+    }
+    else
+    {
+        script = GetEventObjectScriptPointerByEventObjectId(eventObjectId);
+    }
+    script = GetRamScript(gSpecialVar_LastTalked, script);
+    return script;
+}
+
+static const u8 *GetInteractedBackgroundEventScript(struct MapPosition *position, u8 metatileBehavior, u8 direction)
+{
+    struct BgEvent *bgEvent = GetBackgroundEventAtPosition(&gMapHeader, position->x - 7, position->y - 7, position->height);
+
+    if (bgEvent == NULL)
+        return NULL;
+    if (bgEvent->bgUnion.script == NULL)
+        return EventScript_TestSignpostMsg;
+
+    switch (bgEvent->kind)
+    {
+    case BG_EVENT_PLAYER_FACING_ANY:
+    default:
+        return bgEvent->bgUnion.script;
+    case BG_EVENT_PLAYER_FACING_NORTH:
+        if (direction != DIR_NORTH)
+            return NULL;
+        break;
+    case BG_EVENT_PLAYER_FACING_SOUTH:
+        if (direction != DIR_SOUTH)
+            return NULL;
+        break;
+    case BG_EVENT_PLAYER_FACING_EAST:
+        if (direction != DIR_EAST)
+            return NULL;
+        break;
+    case BG_EVENT_PLAYER_FACING_WEST:
+        if (direction != DIR_WEST)
+            return NULL;
+        break;
+    case 5:
+    case 6:
+    case BG_EVENT_HIDDEN_ITEM:
+        gSpecialVar_0x8004 = ((u32)bgEvent->bgUnion.script >> 16) + FLAG_HIDDEN_ITEMS_START;
+        gSpecialVar_0x8005 = (u32)bgEvent->bgUnion.script;
+        if (FlagGet(gSpecialVar_0x8004) == TRUE)
+            return NULL;
+        return EventScript_HiddenItemScript;
+    case BG_EVENT_SECRET_BASE:
+        if (direction == DIR_NORTH)
+        {
+            gSpecialVar_0x8004 = bgEvent->bgUnion.secretBaseId;
+            if (sub_80E9680())
+                return EventScript_2759F1;
+        }
+        return NULL;
+    }
+
+    return bgEvent->bgUnion.script;
+}
+
+static const u8 *GetInteractedMetatileScript(struct MapPosition *position, u8 metatileBehavior, u8 direction)
+{
+    s8 height;
+
+    if (MetatileBehavior_IsPlayerFacingTVScreen(metatileBehavior, direction) == TRUE)
+        return EventScript_TV;
+    if (MetatileBehavior_IsPC(metatileBehavior) == TRUE)
+        return EventScript_PC;
+    if (MetatileBehavior_IsClosedSootopolisDoor(metatileBehavior) == TRUE)
+        return EventScript_ClosedSootopolisDoor;
+    if (MetatileBehavior_IsUnknownClosedDoor(metatileBehavior) == TRUE)
+        return SkyPillar_Outside_EventScript_2393F9;
+    if (MetatileBehavior_IsCableBoxResults1(metatileBehavior) == TRUE)
+        return EventScript_CableBoxResults;
+    if (MetatileBehavior_IsPokeblockFeeder(metatileBehavior) == TRUE)
+        return EventScript_2A4BAC;
+    if (MetatileBehavior_IsTrickHousePuzzleDoor(metatileBehavior) == TRUE)
+        return Route110_TrickHouseEntrance_EventScript_26A22A;
+    if (MetatileBehavior_IsRegionMap(metatileBehavior) == TRUE)
+        return EventScript_RegionMap;
+    if (MetatileBehavior_IsRunningShoesManual(metatileBehavior) == TRUE)
+        return EventScript_RunningShoesManual;
+    if (MetatileBehavior_IsPictureBookShelf(metatileBehavior) == TRUE)
+        return EventScript_PictureBookShelf;
+    if (MetatileBehavior_IsBookShelf(metatileBehavior) == TRUE)
+        return EventScript_BookShelf;
+    if (MetatileBehavior_IsPokeCenterBookShelf(metatileBehavior) == TRUE)
+        return EventScript_PokemonCenterBookshelf;
+    if (MetatileBehavior_IsVase(metatileBehavior) == TRUE)
+        return EventScript_Vase;
+    if (MetatileBehavior_IsTrashCan(metatileBehavior) == TRUE)
+        return EventScript_TrashCan;
+    if (MetatileBehavior_IsShopShelf(metatileBehavior) == TRUE)
+        return EventScript_ShopShelf;
+    if (MetatileBehavior_IsBlueprint(metatileBehavior) == TRUE)
+        return EventScript_Blueprint;
+    if (MetatileBehavior_IsPlayerFacingWirelessBoxResults(metatileBehavior, direction) == TRUE)
+        return EventScript_WirelessBoxResults;
+    if (MetatileBehavior_IsCableBoxResults2(metatileBehavior, direction) == TRUE)
+        return EventScript_CableBoxResults;
+    if (MetatileBehavior_IsQuestionnaire(metatileBehavior) == TRUE)
+        return EventScript_Questionnaire;
+    if (MetatileBehavior_IsTrainerHillTimer(metatileBehavior) == TRUE)
+        return EventScript_TrainerHillTimer;
+
+    height = position->height;
+    if (height == MapGridGetZCoordAt(position->x, position->y))
+    {
+        if (MetatileBehavior_IsSecretBasePC(metatileBehavior) == TRUE)
+            return EventScript_SecretBasePC;
+        if (MetatileBehavior_IsRecordMixingSecretBasePC(metatileBehavior) == TRUE)
+            return EventScript_RecordMixingSecretBasePC;
+        if (MetatileBehavior_IsSecretBaseSandOrnament(metatileBehavior) == TRUE)
+            return EventScript_SecretBaseSandOrnament;
+        if (MetatileBehavior_IsSecretBaseShieldOrToyTV(metatileBehavior) == TRUE)
+            return EventScript_SecretBaseShieldOrToyTV;
+        if (MetatileBehavior_IsMB_C6(metatileBehavior) == TRUE)
+        {
+            sub_80EB56C();
+            return NULL;
+        }
+        if (MetatileBehavior_IsLargeMatCenter(metatileBehavior) == TRUE)
+        {
+            sub_80EB9E0();
+            return NULL;
+        }
+        if (MetatileBehavior_IsSecretBaseLargeMatEdge(metatileBehavior) == TRUE)
+        {
+            sub_80EBB28();
+            return NULL;
+        }
+    }
+    else if (MetatileBehavior_IsSecretBasePoster(metatileBehavior) == TRUE)
+    {
+        sub_80EB498();
+        return NULL;
+    }
+
+    return NULL;
+}
+
+static const u8 *GetInteractedWaterScript(struct MapPosition *unused1, u8 metatileBehavior, u8 direction)
+{
+    if (FlagGet(FLAG_BADGE05_GET) == TRUE && PartyHasMonWithSurf() == TRUE && IsPlayerFacingSurfableFishableWater() == TRUE)
+        return EventScript_UseSurf;
+
+    if (MetatileBehavior_IsWaterfall(metatileBehavior) == TRUE)
+    {
+        if (FlagGet(FLAG_BADGE08_GET) == TRUE && IsPlayerSurfingNorth() == TRUE)
+            return EventScript_UseWaterfall;
+        else
+            return EventScript_CannotUseWaterfall;
+    }
+    return NULL;
+}
+
+static bool32 TrySetupDiveDownScript(void)
+{
+    if (FlagGet(FLAG_BADGE07_GET) && TrySetDiveWarp() == 2)
+    {
+        ScriptContext1_SetupScript(EventScript_UseDive);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool32 TrySetupDiveEmergeScript(void)
+{
+    if (FlagGet(FLAG_BADGE07_GET) && gMapHeader.mapType == MAP_TYPE_UNDERWATER && TrySetDiveWarp() == 1)
+    {
+        ScriptContext1_SetupScript(EventScript_UseDiveUnderwater);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool8 TryStartStepBasedScript(struct MapPosition *position, u16 metatileBehavior, u16 direction)
+{
+    if (TryStartCoordEventScript(position) == TRUE)
+        return TRUE;
+    if (TryStartWarpEventScript(position, metatileBehavior) == TRUE)
+        return TRUE;
+    if (TryStartMiscWalkingScripts(metatileBehavior) == TRUE)
+        return TRUE;
+    if (TryStartStepCountScript(metatileBehavior) == TRUE)
+        return TRUE;
+    if (UpdateRepelCounter() == TRUE)
+        return TRUE;
+    return FALSE;
+}
+
+static bool8 TryStartCoordEventScript(struct MapPosition *position)
+{
+    u8 *script = GetCoordEventScriptAtPosition(&gMapHeader, position->x - 7, position->y - 7, position->height);
+
+    if (script == NULL)
+        return FALSE;
+    ScriptContext1_SetupScript(script);
+    return TRUE;
+}
+
+static bool8 TryStartMiscWalkingScripts(u16 metatileBehavior)
+{
+    s16 x;
+    s16 y;
+
+    if (MetatileBehavior_IsCrackedFloorHole(metatileBehavior))
+    {
+        ScriptContext1_SetupScript(EventScript_FallDownHole);
+        return TRUE;
+    }
+    else if (MetatileBehavior_IsBattlePyramidWarp(metatileBehavior))
+    {
+        ScriptContext1_SetupScript(BattleFrontier_BattlePyramidEmptySquare_EventScript_252BE8);
+        return TRUE;
+    }
+    else if (MetatileBehavior_IsSecretBaseGlitterMat(metatileBehavior) == TRUE)
+    {
+        sub_80FA9D0();
+        return FALSE;
+    }
+    else if (MetatileBehavior_IsSecretBaseSoundMat(metatileBehavior) == TRUE)
+    {
+        PlayerGetDestCoords(&x, &y);
+        sub_80FA970(MapGridGetMetatileIdAt(x, y));
+        return FALSE;
+    }
+    return FALSE;
+}
+
+static bool8 TryStartStepCountScript(u16 metatileBehavior)
+{
+    if (InUnionRoom() == TRUE)
+    {
+        return FALSE;
+    }
+
+    IncrementRematchStepCounter();
+    UpdateHappinessStepCounter();
+    sub_81D4998();
+
+    if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_6) && !MetatileBehavior_IsForcedMovementTile(metatileBehavior))
+    {
+        if (UpdatePoisonStepCounter() == TRUE)
+        {
+            ScriptContext1_SetupScript(EventScript_Poison);
+            return TRUE;
+        }
+        if (ShouldEggHatch())
+        {
+            IncrementGameStat(GAME_STAT_HATCHED_EGGS);
+            ScriptContext1_SetupScript(EventScript_EggHatch);
+            return TRUE;
+        }
+        if (sub_813B3B0() == TRUE)
+        {
+            ScriptContext1_SetupScript(gUnknown_08273D1F);
+            return TRUE;
+        }
+        if (ShouldDoBrailleRegicePuzzle() == TRUE)
+        {
+            ScriptContext1_SetupScript(IslandCave_EventScript_238EAF);
+            return TRUE;
+        }
+        if (is_tile_that_overrides_player_control() == TRUE)
+        {
+            ScriptContext1_SetupScript(MauvilleCity_EventScript_1DF7BA);
+            return TRUE;
+        }
+        if (sub_8138120() == TRUE)
+        {
+            ScriptContext1_SetupScript(Route119_EventScript_1F49EC);
+            return TRUE;
+        }
+        if (sub_8138168() == TRUE)
+        {
+            ScriptContext1_SetupScript(LittlerootTown_ProfessorBirchsLab_EventScript_1FA4D6);
+            return TRUE;
+        }
+        if (sub_81381B0() == TRUE)
+        {
+            ScriptContext1_SetupScript(RustboroCity_Gym_EventScript_21307B);
+            return TRUE;
+        }
+        if (sub_81381F8() == TRUE)
+        {
+            ScriptContext1_SetupScript(MossdeepCity_SpaceCenter_2F_EventScript_224175);
+            return TRUE;
+        }
+    }
+
+    if (SafariZoneTakeStep() == TRUE)
+        return TRUE;
+    if (CountSSTidalStep(1) == TRUE)
+    {
+        ScriptContext1_SetupScript(SSTidalCorridor_EventScript_23C050);
+        return TRUE;
+    }
+    if (sub_8196034())
+        return TRUE;
+    return FALSE;
+}
+
+void Unref_ClearHappinessStepCounter(void)
+{
+    VarSet(VAR_HAPPINESS_STEP_COUNTER, 0);
+}
+
+static void UpdateHappinessStepCounter(void)
+{
+    u16 *ptr = GetVarPointer(VAR_HAPPINESS_STEP_COUNTER);
+    int i;
+
+    (*ptr)++;
+    (*ptr) %= 128;
+    if (*ptr == 0)
+    {
+        struct Pokemon *mon = gPlayerParty;
+        for (i = 0; i < PARTY_SIZE; i++)
+        {
+            AdjustFriendship(mon, FRIENDSHIP_EVENT_WALKING);
+            mon++;
+        }
+    }
+}
+
+void ClearPoisonStepCounter(void)
+{
+    VarSet(VAR_POISON_STEP_COUNTER, 0);
+}
+
+static bool8 UpdatePoisonStepCounter(void)
+{
+    u16 *ptr;
+
+    if (gMapHeader.mapType != MAP_TYPE_SECRET_BASE)
+    {
+        ptr = GetVarPointer(VAR_POISON_STEP_COUNTER);
+        (*ptr)++;
+        (*ptr) %= 4;
+        if (*ptr == 0)
+        {
+            switch (DoPoisonFieldEffect())
+            {
+            case 0:
+                return FALSE;
+            case 1:
+                return FALSE;
+            case 2:
+                return TRUE;
+            }
+        }
+    }
+    return FALSE;
+}
+
+void RestartWildEncounterImmunitySteps(void)
+{
+    // Starts at 0 and counts up to 4 steps.
+    sWildEncounterImmunitySteps = 0;
+}
+
+static bool8 CheckStandardWildEncounter(u16 metatileBehavior)
+{
+    if (sWildEncounterImmunitySteps < 4)
+    {
+        sWildEncounterImmunitySteps++;
+        sPreviousPlayerMetatileBehavior = metatileBehavior;
+        return FALSE;
+    }
+
+    if (StandardWildEncounter(metatileBehavior, sPreviousPlayerMetatileBehavior) == TRUE)
+    {
+        sWildEncounterImmunitySteps = 0;
+        sPreviousPlayerMetatileBehavior = metatileBehavior;
+        return TRUE;
+    }
+
+    sPreviousPlayerMetatileBehavior = metatileBehavior;
+    return FALSE;
+}
+
+static bool8 mapheader_run_first_tag2_script_list_match_conditionally(struct MapPosition *position, u16 metatileBehavior, u8 direction)
+{
+    s8 warpEventId = GetWarpEventAtMapPosition(&gMapHeader, position);
+
+    if (IsArrowWarpMetatileBehavior(metatileBehavior, direction) == TRUE && warpEventId != -1)
+    {
+        StoreInitialPlayerAvatarState();
+        sub_809CEB0(&gMapHeader, warpEventId, position);
+        sub_80AF734();
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool8 TryStartWarpEventScript(struct MapPosition *position, u16 metatileBehavior)
+{
+    s8 warpEventId = GetWarpEventAtMapPosition(&gMapHeader, position);
+
+    if (warpEventId != -1 && IsWarpMetatileBehavior(metatileBehavior) == TRUE)
+    {
+        StoreInitialPlayerAvatarState();
+        sub_809CEB0(&gMapHeader, warpEventId, position);
+        if (MetatileBehavior_IsEscalator(metatileBehavior) == TRUE)
+        {
+            sub_80AF80C(metatileBehavior);
+            return TRUE;
+        }
+        if (MetatileBehavior_IsLavaridgeB1FWarp(metatileBehavior) == TRUE)
+        {
+            sub_80AF828();
+            return TRUE;
+        }
+        if (MetatileBehavior_IsLavaridge1FWarp(metatileBehavior) == TRUE)
+        {
+            sub_80AF838();
+            return TRUE;
+        }
+        if (MetatileBehavior_IsAquaHideoutWarp(metatileBehavior) == TRUE)
+        {
+            sub_80AF848();
+            return TRUE;
+        }
+        if (MetatileBehavior_IsWarpOrBridge(metatileBehavior) == TRUE)
+        {
+            sub_80B0268();
+            return TRUE;
+        }
+        if (MetatileBehavior_IsMtPyreHole(metatileBehavior) == TRUE)
+        {
+            ScriptContext1_SetupScript(gUnknown_082A8350);
+            return TRUE;
+        }
+        if (MetatileBehavior_IsMossdeepGymWarp(metatileBehavior) == TRUE)
+        {
+            sub_80AF87C();
+            return TRUE;
+        }
+        sub_80AF734();
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool8 IsWarpMetatileBehavior(u16 metatileBehavior)
+{
+    if (MetatileBehavior_IsWarpDoor(metatileBehavior) != TRUE
+     && MetatileBehavior_IsLadder(metatileBehavior) != TRUE
+     && MetatileBehavior_IsEscalator(metatileBehavior) != TRUE
+     && MetatileBehavior_IsNonAnimDoor(metatileBehavior) != TRUE
+     && MetatileBehavior_IsLavaridgeB1FWarp(metatileBehavior) != TRUE
+     && MetatileBehavior_IsLavaridge1FWarp(metatileBehavior) != TRUE
+     && MetatileBehavior_IsAquaHideoutWarp(metatileBehavior) != TRUE
+     && MetatileBehavior_IsMtPyreHole(metatileBehavior) != TRUE
+     && MetatileBehavior_IsMossdeepGymWarp(metatileBehavior) != TRUE
+     && MetatileBehavior_IsWarpOrBridge(metatileBehavior) != TRUE)
+        return FALSE;
+    return TRUE;
+}
+
+static bool8 IsArrowWarpMetatileBehavior(u16 metatileBehavior, u8 direction)
+{
+    switch (direction)
+    {
+    case DIR_NORTH:
+        return MetatileBehavior_IsNorthArrowWarp(metatileBehavior);
+    case DIR_SOUTH:
+        return MetatileBehavior_IsSouthArrowWarp(metatileBehavior);
+    case DIR_WEST:
+        return MetatileBehavior_IsWestArrowWarp(metatileBehavior);
+    case DIR_EAST:
+        return MetatileBehavior_IsEastArrowWarp(metatileBehavior);
+    }
+    return FALSE;
+}
+
+static s8 GetWarpEventAtMapPosition(struct MapHeader *mapHeader, struct MapPosition *position)
+{
+    return GetWarpEventAtPosition(mapHeader, position->x - 7, position->y - 7, position->height);
+}
+
+static void sub_809CEB0(struct MapHeader *unused, s8 warpEventId, struct MapPosition *position)
+{
+    const struct WarpEvent *warpEvent;
+
+    u8 trainerHillMapId = GetCurrentTrainerHillMapId();
+
+    if (trainerHillMapId)
+    {
+        if (trainerHillMapId == sub_81D6490())
+        {
+            if (warpEventId == 0)
+            {
+                warpEvent = &gMapHeader.events->warps[0];
+            }
+            else
+            {
+                warpEvent = sub_81D6120();
+            }
+        }
+        else if (trainerHillMapId == 5)
+        {
+            warpEvent = sub_81D6134(warpEventId);
+        }
+        else
+        {
+            warpEvent = &gMapHeader.events->warps[warpEventId];
+        }
+    }
+    else
+    {
+        warpEvent = &gMapHeader.events->warps[warpEventId];
+    }
+
+    if (warpEvent->mapNum == 0x7F)
+    {
+        copy_saved_warp2_bank_and_enter_x_to_warp1(warpEvent->warpId);
+    }
+    else
+    {
+        const struct MapHeader *mapHeader;
+
+        warp1_set_2(warpEvent->mapGroup, warpEvent->mapNum, warpEvent->warpId);
+        sub_8084D5C(position->x, position->y);
+        mapHeader = Overworld_GetMapHeaderByGroupAndId(warpEvent->mapGroup, warpEvent->mapNum);
+        if (mapHeader->events->warps[warpEvent->warpId].mapNum == 0x7F)
+            saved_warp2_set(mapHeader->events->warps[warpEventId].warpId, gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, warpEventId);
+    }
+}
+
+static bool8 map_warp_consider_2_to_inside(struct MapPosition *position, u16 metatileBehavior, u8 direction)
+{
+    s8 warpEventId;
+
+    if (direction == DIR_NORTH)
+    {
+        if (MetatileBehavior_IsOpenSecretBaseDoor(metatileBehavior) == TRUE)
+        {
+            sub_80E9668(position, gMapHeader.events);
+            return TRUE;
+        }
+        if (MetatileBehavior_IsWarpDoor(metatileBehavior) == TRUE)
+        {
+            warpEventId = GetWarpEventAtMapPosition(&gMapHeader, position);
+            if (warpEventId != -1 && IsWarpMetatileBehavior(metatileBehavior) == TRUE)
+            {
+                StoreInitialPlayerAvatarState();
+                sub_809CEB0(&gMapHeader, warpEventId, position);
+                sub_80AF7D0();
+                return TRUE;
+            }
+        }
+    }
+    return FALSE;
+}
+
+static s8 GetWarpEventAtPosition(struct MapHeader *mapHeader, u16 x, u16 y, u8 elevation)
+{
+    s32 i;
+    struct WarpEvent *warpEvent = mapHeader->events->warps;
+    u8 warpCount = mapHeader->events->warpCount;
+
+    for (i = 0; i < warpCount; i++, warpEvent++)
+    {
+        if ((u16)warpEvent->x == x && (u16)warpEvent->y == y)
+        {
+            if (warpEvent->elevation == elevation || warpEvent->elevation == 0)
+                return i;
+        }
+    }
+    return -1;
+}
+
+static u8 *TryRunCoordEventScript(struct CoordEvent *coordEvent)
+{
+    if (coordEvent != NULL)
+    {
+        if (coordEvent->script == NULL)
+        {
+            DoCoordEventWeather(coordEvent->trigger);
+            return NULL;
+        }
+        if (coordEvent->trigger == 0)
+        {
+            ScriptContext2_RunNewScript(coordEvent->script);
+            return NULL;
+        }
+        if (VarGet(coordEvent->trigger) == (u8)coordEvent->index)
+            return coordEvent->script;
+    }
+    return NULL;
+}
+
+static u8 *GetCoordEventScriptAtPosition(struct MapHeader *mapHeader, u16 x, u16 y, u8 elevation)
+{
+    s32 i;
+    struct CoordEvent *coordEvents = mapHeader->events->coordEvents;
+    u8 coordEventCount = mapHeader->events->coordEventCount;
+
+    for (i = 0; i < coordEventCount; i++)
+    {
+        if ((u16)coordEvents[i].x == x && (u16)coordEvents[i].y == y)
+        {
+            if (coordEvents[i].elevation == elevation || coordEvents[i].elevation == 0)
+            {
+                u8 *script = TryRunCoordEventScript(&coordEvents[i]);
+                if (script != NULL)
+                    return script;
+            }
+        }
+    }
+    return NULL;
+}
+
+u8 *GetCoordEventScriptAtMapPosition(struct MapPosition *position)
+{
+    return GetCoordEventScriptAtPosition(&gMapHeader, position->x - 7, position->y - 7, position->height);
+}
+
+static struct BgEvent *GetBackgroundEventAtPosition(struct MapHeader *mapHeader, u16 x, u16 y, u8 elevation)
+{
+    u8 i;
+    struct BgEvent *bgEvents = mapHeader->events->bgEvents;
+    u8 bgEventCount = mapHeader->events->bgEventCount;
+
+    for (i = 0; i < bgEventCount; i++)
+    {
+        if ((u16)bgEvents[i].x == x && (u16)bgEvents[i].y == y)
+        {
+            if (bgEvents[i].elevation == elevation || bgEvents[i].elevation == 0)
+                return &bgEvents[i];
+        }
+    }
+    return NULL;
+}
+
+bool8 dive_warp(struct MapPosition *position, u16 metatileBehavior)
+{
+    if (gMapHeader.mapType == MAP_TYPE_UNDERWATER && !MetatileBehavior_IsUnableToEmerge(metatileBehavior))
+    {
+        if (SetDiveWarpEmerge(position->x - 7, position->y - 7))
+        {
+            StoreInitialPlayerAvatarState();
+            sp13E_warp_to_last_warp();
+            PlaySE(SE_W291);
+            return TRUE;
+        }
+    }
+    else if (MetatileBehavior_IsDiveable(metatileBehavior) == TRUE)
+    {
+        if (SetDiveWarpDive(position->x - 7, position->y - 7))
+        {
+            StoreInitialPlayerAvatarState();
+            sp13E_warp_to_last_warp();
+            PlaySE(SE_W291);
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+u8 TrySetDiveWarp(void)
+{
+    s16 x, y;
+    u8 metatileBehavior;
+
+    PlayerGetDestCoords(&x, &y);
+    metatileBehavior = MapGridGetMetatileBehaviorAt(x, y);
+    if (gMapHeader.mapType == MAP_TYPE_UNDERWATER && !MetatileBehavior_IsUnableToEmerge(metatileBehavior))
+    {
+        if (SetDiveWarpEmerge(x - 7, y - 7) == TRUE)
+            return 1;
+    }
+    else if (MetatileBehavior_IsDiveable(metatileBehavior) == TRUE)
+    {
+        if (SetDiveWarpDive(x - 7, y - 7) == TRUE)
+            return 2;
+    }
+    return 0;
+}
+
+const u8 *GetEventObjectScriptPointerPlayerFacing(void)
+{
+    u8 direction;
+    struct MapPosition position;
+
+    direction = GetPlayerMovementDirection();
+    GetInFrontOfPlayerPosition(&position);
+    return GetInteractedEventObjectScript(&position, MapGridGetMetatileBehaviorAt(position.x, position.y), direction);
+}
+
+int SetCableClubWarp(void)
+{
+    struct MapPosition position;
+
+    GetPlayerMovementDirection();  //unnecessary
+    GetPlayerPosition(&position);
+    MapGridGetMetatileBehaviorAt(position.x, position.y);  //unnecessary
+    sub_809CEB0(&gMapHeader, GetWarpEventAtMapPosition(&gMapHeader, &position), &position);
+    return 0;
+}
diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c
index f5ddbcca4..6b8548f1a 100644
--- a/src/field_player_avatar.c
+++ b/src/field_player_avatar.c
@@ -1,38 +1,64 @@
 #include "global.h"
+#include "main.h"
 #include "bike.h"
 #include "event_data.h"
 #include "event_object_movement.h"
+#include "field_camera.h"
 #include "field_player_avatar.h"
+#include "field_effect.h"
+#include "field_effect_helpers.h"
 #include "fieldmap.h"
 #include "global.fieldmap.h"
+#include "menu.h"
 #include "metatile_behavior.h"
 #include "overworld.h"
+#include "party_menu.h"
+#include "random.h"
 #include "rotating_gate.h"
+#include "script.h"
+#include "sound.h"
 #include "sprite.h"
+#include "strings.h"
 #include "task.h"
+#include "tv.h"
+#include "wild_encounter.h"
+#include "constants/abilities.h"
 #include "constants/event_objects.h"
 #include "constants/event_object_movement_constants.h"
 #include "constants/flags.h"
+#include "constants/maps.h"
+#include "constants/moves.h"
+#include "constants/songs.h"
+#include "constants/species.h"
 
-extern void task_add_bump_boulder(u8, u8);
+static EWRAM_DATA u8 gUnknown_0203734C = 0;
+EWRAM_DATA struct EventObject gEventObjects[EVENT_OBJECTS_COUNT] = {};
+EWRAM_DATA struct PlayerAvatar gPlayerAvatar = {};
+
+static void StartStrengthAnim(u8, u8);
 static bool8 ShouldJumpLedge(s16, s16, u8);
 static bool8 sub_808B1BC(s16, s16, u8);
 static u8 sub_808B164(struct EventObject *, s16, s16, u8, u8);
 static u8 sub_808B238(s16, s16, u8);
 static void check_acro_bike_metatile(s16, s16, u8, u8 *);
-extern void PlayerNotOnBikeCollide(u8);
-extern void PlayerNotOnBikeCollideWithFarawayIslandMew(u8);
-extern void PlayerRun(u8); 
+static void PlayerNotOnBikeCollide(u8);
+static void PlayCollisionSoundIfNotFacingWarp(u8 a);
+static void PlayerNotOnBikeCollideWithFarawayIslandMew(u8);
+static void PlayerRun(u8); 
 static void MovePlayerNotOnBike(u8, u16);
 static u8 CheckMovementInputNotOnBike(u8);
-extern void sub_808C5B0(void);
-extern void sub_808C4D8(void);
+static void DoPlayerMatSpin(void);
+static void DoPlayerMatJump(void);
 static u8 CheckForPlayerAvatarCollision(u8);
 static u8 EventObjectCB2_NoMovement2();
-extern void sub_808C280(struct EventObject *); 
+static void sub_808C280(struct EventObject *); 
 static bool8 TryInterruptEventObjectSpecialAnim(struct EventObject *, u8);
-void npc_clear_strange_bits(struct EventObject *);
-extern void DoPlayerAvatarTransition(void); 
+static void npc_clear_strange_bits(struct EventObject *);
+static void DoPlayerAvatarTransition(void); 
+static bool8 player_is_anim_in_certain_ranges(void);
+static bool8 sub_808B618(void);
+static bool8 PlayerIsAnimActive(void);
+static bool8 PlayerCheckIfAnimFinishedOrInactive(void);
 static bool8 TryDoMetatileBehaviorForcedMovement();
 static void MovePlayerAvatarUsingKeypadInput(u8, u16, u16);
 static void PlayerAllowForcedMovementIfMovingSameDirection();
@@ -41,43 +67,61 @@ static u8 GetForcedMovementByMetatileBehavior();
 static void PlayerNotOnBikeNotMoving(u8, u16);
 static void PlayerNotOnBikeTurningInPlace(u8, u16);
 static void PlayerNotOnBikeMoving(u8, u16);
-extern void sub_808C750(u8);
-
-extern void PlayerAvatarTransition_Normal(struct EventObject *a);
-extern void PlayerAvatarTransition_MachBike(struct EventObject *a);
-extern void PlayerAvatarTransition_AcroBike(struct EventObject *a);
-extern void PlayerAvatarTransition_Surfing(struct EventObject *a);
-extern void PlayerAvatarTransition_Underwater(struct EventObject *a);
-extern void PlayerAvatarTransition_ReturnToField(struct EventObject *a);
-extern void PlayerAvatarTransition_Dummy(struct EventObject *a);
-
-extern u8 sub_808C3A4(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject);
-extern u8 do_boulder_dust(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject);
-extern u8 sub_808C484(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject);
-
-extern u8 sub_808C544(struct Task *task, struct EventObject *eventObject);
-
-extern u8 sub_808C61C(struct Task *task, struct EventObject *eventObject);
-extern u8 sub_808C644(struct Task *task, struct EventObject *eventObject);
-extern u8 sub_808C6BC(struct Task *task, struct EventObject *eventObject);
-extern u8 sub_808C6FC(struct Task *task, struct EventObject *eventObject);
-
-extern u8 fish0(struct Task *task);
-extern u8 fish1(struct Task *task);
-extern u8 fish2(struct Task *task);
-extern u8 fish3(struct Task *task);
-extern u8 fish4(struct Task *task);
-extern u8 fish5(struct Task *task);
-extern u8 fish6(struct Task *task);
-extern u8 fish7(struct Task *task);
-extern u8 fish8(struct Task *task);
-extern u8 fish9(struct Task *task);
-extern u8 fishA_wait_for_a_pressed(struct Task *task);
-extern u8 fishB(struct Task *task);
-extern u8 fishC(struct Task *task);
-extern u8 fishD(struct Task *task);
-extern u8 fishE(struct Task *task);
-extern u8 fishF(struct Task *task);
+static void sub_808C750(u8);
+
+static bool8 ForcedMovement_None(void);
+static bool8 ForcedMovement_Slip(void);
+static bool8 ForcedMovement_WalkSouth(void);
+static bool8 ForcedMovement_WalkNorth(void);
+static bool8 ForcedMovement_WalkWest(void);
+static bool8 ForcedMovement_WalkEast(void);
+static bool8 ForcedMovement_PushedSouthByCurrent(void);
+static bool8 ForcedMovement_PushedNorthByCurrent(void);
+static bool8 ForcedMovement_PushedWestByCurrent(void);
+static bool8 ForcedMovement_PushedEastByCurrent(void);
+static bool8 ForcedMovement_SlideSouth(void);
+static bool8 ForcedMovement_SlideNorth(void);
+static bool8 ForcedMovement_SlideWest(void);
+static bool8 ForcedMovement_SlideEast(void);
+static bool8 ForcedMovement_0xBB(void);
+static bool8 ForcedMovement_0xBC(void);
+static bool8 ForcedMovement_MuddySlope(void);
+
+static void PlayerAvatarTransition_Normal(struct EventObject *a);
+static void PlayerAvatarTransition_MachBike(struct EventObject *a);
+static void PlayerAvatarTransition_AcroBike(struct EventObject *a);
+static void PlayerAvatarTransition_Surfing(struct EventObject *a);
+static void PlayerAvatarTransition_Underwater(struct EventObject *a);
+static void PlayerAvatarTransition_ReturnToField(struct EventObject *a);
+static void PlayerAvatarTransition_Dummy(struct EventObject *a);
+
+static u8 sub_808C3A4(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject);
+static u8 do_boulder_dust(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject);
+static u8 sub_808C484(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject);
+
+static u8 PlayerAvatar_DoSecretBaseMatJump(struct Task *task, struct EventObject *eventObject);
+
+static bool8 PlayerAvatar_SecretBaseMatSpinStep0(struct Task *task, struct EventObject *eventObject);
+static bool8 PlayerAvatar_SecretBaseMatSpinStep1(struct Task *task, struct EventObject *eventObject);
+static bool8 PlayerAvatar_SecretBaseMatSpinStep2(struct Task *task, struct EventObject *eventObject);
+static bool8 PlayerAvatar_SecretBaseMatSpinStep3(struct Task *task, struct EventObject *eventObject);
+
+static u8 Fishing1(struct Task *task);
+static u8 Fishing2(struct Task *task);
+static u8 Fishing3(struct Task *task);
+static u8 Fishing4(struct Task *task);
+static u8 Fishing5(struct Task *task);
+static u8 Fishing6(struct Task *task);
+static u8 Fishing7(struct Task *task);
+static u8 Fishing8(struct Task *task);
+static u8 Fishing9(struct Task *task);
+static u8 Fishing10(struct Task *task);
+static u8 Fishing11(struct Task *task);
+static u8 Fishing12(struct Task *task);
+static u8 Fishing13(struct Task *task);
+static u8 Fishing14(struct Task *task);
+static u8 Fishing15(struct Task *task);
+static u8 Fishing16(struct Task *task);
 
 static bool8 (*const sForcedMovementTestFuncs[])(u8) =
 {
@@ -142,7 +186,7 @@ static bool8 (*const gUnknown_0849749C[])(u8) =
 
 static const u8 gUnknown_084974B0[] = {9, 10, 11, 12, 13, 0, 0, 0};
 
-void (*const gUnknown_084974B8[])(struct EventObject *) =
+static void (*const gUnknown_084974B8[])(struct EventObject *) =
 {
     PlayerAvatarTransition_Normal,
     PlayerAvatarTransition_MachBike,
@@ -154,7 +198,7 @@ void (*const gUnknown_084974B8[])(struct EventObject *) =
     PlayerAvatarTransition_Dummy,
 };
 
-bool8 (*const sArrowWarpMetatileBehaviorChecks[])(u8) =
+static bool8 (*const sArrowWarpMetatileBehaviorChecks[])(u8) =
 {
     MetatileBehavior_IsSouthArrowWarp,
     MetatileBehavior_IsNorthArrowWarp,
@@ -162,7 +206,7 @@ bool8 (*const sArrowWarpMetatileBehaviorChecks[])(u8) =
     MetatileBehavior_IsEastArrowWarp,
 };
 
-const u8 sRivalAvatarGfxIds[][2] =
+static const u8 sRivalAvatarGfxIds[][2] =
 {
     {EVENT_OBJ_GFX_RIVAL_BRENDAN_NORMAL,     EVENT_OBJ_GFX_RIVAL_MAY_NORMAL},
     {EVENT_OBJ_GFX_RIVAL_BRENDAN_MACH_BIKE,  EVENT_OBJ_GFX_RIVAL_MAY_MACH_BIKE},
@@ -174,7 +218,7 @@ const u8 sRivalAvatarGfxIds[][2] =
     {EVENT_OBJ_GFX_BRENDAN_WATERING,         EVENT_OBJ_GFX_MAY_WATERING}
 };
 
-const u8 sPlayerAvatarGfxIds[][2] =
+static const u8 sPlayerAvatarGfxIds[][2] =
 {
     {EVENT_OBJ_GFX_BRENDAN_NORMAL,     EVENT_OBJ_GFX_MAY_NORMAL},
     {EVENT_OBJ_GFX_BRENDAN_MACH_BIKE,  EVENT_OBJ_GFX_MAY_MACH_BIKE},
@@ -186,11 +230,11 @@ const u8 sPlayerAvatarGfxIds[][2] =
     {EVENT_OBJ_GFX_BRENDAN_WATERING,   EVENT_OBJ_GFX_MAY_WATERING},
 };
 
-const u8 gUnknown_08497508[] = {EVENT_OBJ_GFX_RED, EVENT_OBJ_GFX_LEAF};
+static const u8 sFRLGAvatarGfxIds[] = {EVENT_OBJ_GFX_RED, EVENT_OBJ_GFX_LEAF};
 
-const u8 gUnknown_0849750A[] = {EVENT_OBJ_GFX_LINK_RS_BRENDAN, EVENT_OBJ_GFX_LINK_RS_MAY};
+static const u8 sRSAvatarGfxIds[] = {EVENT_OBJ_GFX_LINK_RS_BRENDAN, EVENT_OBJ_GFX_LINK_RS_MAY};
 
-const u8 gUnknown_0849750C[2][5][2] =
+static const u8 gUnknown_0849750C[2][5][2] =
 {
     //male
     {
@@ -210,7 +254,7 @@ const u8 gUnknown_0849750C[2][5][2] =
     }
 };
 
-bool8 (*const sArrowWarpMetatileBehaviorChecks2[])(u8) =  //Duplicate of sArrowWarpMetatileBehaviorChecks
+static bool8 (*const sArrowWarpMetatileBehaviorChecks2[])(u8) =  //Duplicate of sArrowWarpMetatileBehaviorChecks
 {
     MetatileBehavior_IsSouthArrowWarp,
     MetatileBehavior_IsNorthArrowWarp,
@@ -218,76 +262,35 @@ bool8 (*const sArrowWarpMetatileBehaviorChecks2[])(u8) =  //Duplicate of sArrowW
     MetatileBehavior_IsEastArrowWarp,
 };
 
-u8 (*const gUnknown_08497530[])(struct Task *, struct EventObject *, struct EventObject *) =
+static bool8 (*const gUnknown_08497530[])(struct Task *, struct EventObject *, struct EventObject *) =
 {
     sub_808C3A4,
     do_boulder_dust,
     sub_808C484,
 };
 
-u8 (*const gUnknown_0849753C[])(struct Task *, struct EventObject *) =
+static bool8 (*const sPlayerAvatarSecretBaseMatJump[])(struct Task *, struct EventObject *) =
 {
-    sub_808C544,
+    PlayerAvatar_DoSecretBaseMatJump,
 };
 
-u8 (*const gUnknown_08497540[])(struct Task *, struct EventObject *) =
+static bool8 (*const sPlayerAvatarSecretBaseMatSpin[])(struct Task *, struct EventObject *) =
 {
-    sub_808C61C,
-    sub_808C644,
-    sub_808C6BC,
-    sub_808C6FC,
-};
-
-const u8 gUnknown_08497550[] = {3, 4, 2, 1};
-
-const u8 gUnknown_08497554[] = {16, 16, 17, 18, 19};
-
-u8 (*const sFishingStateFuncs[])(struct Task *) =
-{
-    fish0,
-    fish1,
-    fish2,
-    fish3,
-    fish4,
-    fish5,
-    fish6,
-    fish7,
-    fish8,
-    fish9,
-    fishA_wait_for_a_pressed,
-    fishB,
-    fishC,
-    fishD,
-    fishE,
-    fishF,
+    PlayerAvatar_SecretBaseMatSpinStep0,
+    PlayerAvatar_SecretBaseMatSpinStep1,
+    PlayerAvatar_SecretBaseMatSpinStep2,
+    PlayerAvatar_SecretBaseMatSpinStep3,
 };
 
-const u16 gUnknown_0849759C[] = {1, 1, 1};
-
-const u16 gUnknown_084975A2[] = {1, 3, 6};
-
-const u8 gText_Dot[] = _("·");
-
-const u16 sReelTimeouts[] = {36, 33, 30};
-
-const u16 gUnknown_084975B0[] =
-{
-    0, 0,
-    0x28, 10,
-    0x46, 30,
-};
-
-const u8 gUnknown_084975BC[] = {0x01, 0x03, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00};
-
 // .text
 void MovementType_Player(struct Sprite *sprite)
 {
-	UpdateEventObjectCurrentMovement(&gEventObjects[sprite->data[0]], sprite, EventObjectCB2_NoMovement2);
+    UpdateEventObjectCurrentMovement(&gEventObjects[sprite->data[0]], sprite, EventObjectCB2_NoMovement2);
 }
 
 static u8 EventObjectCB2_NoMovement2(void)
 {
-	return 0;
+    return 0;
 }
 
 void player_step(u8 direction, u16 newKeys, u16 heldKeys)
@@ -352,7 +355,7 @@ static bool8 TryInterruptEventObjectSpecialAnim(struct EventObject *playerEventO
     return FALSE;
 }
 
-void npc_clear_strange_bits(struct EventObject *eventObj)
+static void npc_clear_strange_bits(struct EventObject *eventObj)
 {
     eventObj->inanimate = 0;
     eventObj->disableAnim = 0;
@@ -377,7 +380,7 @@ static void PlayerAllowForcedMovementIfMovingSameDirection(void)
 
 static bool8 TryDoMetatileBehaviorForcedMovement(void)
 {
-	return sForcedMovementFuncs[GetForcedMovementByMetatileBehavior()]();
+    return sForcedMovementFuncs[GetForcedMovementByMetatileBehavior()]();
 }
 
 static u8 GetForcedMovementByMetatileBehavior(void)
@@ -397,7 +400,7 @@ static u8 GetForcedMovementByMetatileBehavior(void)
     return 0;
 }
 
-bool8 ForcedMovement_None(void)
+static bool8 ForcedMovement_None(void)
 {
     if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_6)
     {
@@ -441,7 +444,7 @@ static u8 DoForcedMovement(u8 direction, void (*b)(u8))
     }
 }
 
-u8 DoForcedMovementInCurrentDirection(void (*a)(u8))
+static u8 DoForcedMovementInCurrentDirection(void (*a)(u8))
 {
     struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
 
@@ -449,49 +452,49 @@ u8 DoForcedMovementInCurrentDirection(void (*a)(u8))
     return DoForcedMovement(playerEventObj->movementDirection, a);
 }
 
-bool8 ForcedMovement_Slip(void)
+static bool8 ForcedMovement_Slip(void)
 {
     return DoForcedMovementInCurrentDirection(PlayerGoSpeed2);
 }
 
-bool8 ForcedMovement_WalkSouth(void)
+static bool8 ForcedMovement_WalkSouth(void)
 {
     return DoForcedMovement(DIR_SOUTH, PlayerGoSpeed1);
 }
 
-bool8 ForcedMovement_WalkNorth(void)
+static bool8 ForcedMovement_WalkNorth(void)
 {
     return DoForcedMovement(DIR_NORTH, PlayerGoSpeed1);
 }
 
-bool8 ForcedMovement_WalkWest(void)
+static bool8 ForcedMovement_WalkWest(void)
 {
     return DoForcedMovement(DIR_WEST, PlayerGoSpeed1);
 }
 
-bool8 ForcedMovement_WalkEast(void)
+static bool8 ForcedMovement_WalkEast(void)
 {
     return DoForcedMovement(DIR_EAST, PlayerGoSpeed1);
 }
 
-bool8 ForcedMovement_PushedSouthByCurrent(void)
+static bool8 ForcedMovement_PushedSouthByCurrent(void)
 {
-    return DoForcedMovement(DIR_SOUTH, PlayerGoSpeed3);
+    return DoForcedMovement(DIR_SOUTH, PlayerRideWaterCurrent);
 }
 
-bool8 ForcedMovement_PushedNorthByCurrent(void)
+static bool8 ForcedMovement_PushedNorthByCurrent(void)
 {
-    return DoForcedMovement(DIR_NORTH, PlayerGoSpeed3);
+    return DoForcedMovement(DIR_NORTH, PlayerRideWaterCurrent);
 }
 
-bool8 ForcedMovement_PushedWestByCurrent(void)
+static bool8 ForcedMovement_PushedWestByCurrent(void)
 {
-    return DoForcedMovement(DIR_WEST, PlayerGoSpeed3);
+    return DoForcedMovement(DIR_WEST, PlayerRideWaterCurrent);
 }
 
-bool8 ForcedMovement_PushedEastByCurrent(void)
+static bool8 ForcedMovement_PushedEastByCurrent(void)
 {
-    return DoForcedMovement(DIR_EAST, PlayerGoSpeed3);
+    return DoForcedMovement(DIR_EAST, PlayerRideWaterCurrent);
 }
 
 u8 ForcedMovement_Slide(u8 direction, void (*b)(u8))
@@ -503,39 +506,39 @@ u8 ForcedMovement_Slide(u8 direction, void (*b)(u8))
     return DoForcedMovement(direction, b);
 }
 
-bool8 ForcedMovement_SlideSouth(void)
+static bool8 ForcedMovement_SlideSouth(void)
 {
     return ForcedMovement_Slide(DIR_SOUTH, PlayerGoSpeed2);
 }
 
-bool8 ForcedMovement_SlideNorth(void)
+static bool8 ForcedMovement_SlideNorth(void)
 {
     return ForcedMovement_Slide(DIR_NORTH, PlayerGoSpeed2);
 }
 
-bool8 ForcedMovement_SlideWest(void)
+static bool8 ForcedMovement_SlideWest(void)
 {
     return ForcedMovement_Slide(DIR_WEST, PlayerGoSpeed2);
 }
 
-bool8 ForcedMovement_SlideEast(void)
+static bool8 ForcedMovement_SlideEast(void)
 {
     return ForcedMovement_Slide(DIR_EAST, PlayerGoSpeed2);
 }
 
-bool8 ForcedMovement_0xBB(void)
+static bool8 ForcedMovement_0xBB(void)
 {
-    sub_808C4D8();
+    DoPlayerMatJump();
     return TRUE;
 }
 
-bool8 ForcedMovement_0xBC(void)
+static bool8 ForcedMovement_0xBC(void)
 {
-    sub_808C5B0();
+    DoPlayerMatSpin();
     return TRUE;
 }
 
-bool8 ForcedMovement_MuddySlope(void)
+static bool8 ForcedMovement_MuddySlope(void)
 {
     struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
 
@@ -619,7 +622,7 @@ static void PlayerNotOnBikeMoving(u8 direction, u16 heldKeys)
 
     if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
     {
-	// speed 2 is fast, same speed as running
+    // speed 2 is fast, same speed as running
         PlayerGoSpeed2(direction);
         return;
     }
@@ -733,7 +736,7 @@ static u8 sub_808B238(s16 x, s16 y, u8 direction)
                 if (GetCollisionAtCoords(&gEventObjects[eventObjectId], x, y, direction) == 0
                  && MetatileBehavior_IsNonAnimDoor(MapGridGetMetatileBehaviorAt(x, y)) == 0)
                 {
-                    task_add_bump_boulder(eventObjectId, direction);
+                    StartStrengthAnim(eventObjectId, direction);
                     return 1;
                 }
             }
@@ -754,3 +757,1472 @@ static void check_acro_bike_metatile(s16 unused1, s16 unused2, u8 c, u8 *d)
         }
     }
 }
+
+bool8 IsPlayerCollidingWithFarawayIslandMew(u8 direction)
+{
+    u8 mewObjectId;
+    struct EventObject *object;
+    s16 playerX;
+    s16 playerY;
+    s16 mewPrevX;
+
+    object = &gEventObjects[gPlayerAvatar.eventObjectId];
+    playerX = object->currentCoords.x;
+    playerY = object->currentCoords.y;
+
+    MoveCoords(direction, &playerX, &playerY);
+    mewObjectId = GetEventObjectIdByLocalIdAndMap(1, 0x39, 0x1A);
+
+    if (mewObjectId == 16)
+    {
+        return FALSE;
+    }
+
+    object = &gEventObjects[mewObjectId];
+    mewPrevX = object->previousCoords.x;
+
+    if (mewPrevX == playerX)
+    {
+        if (object->previousCoords.y != playerY
+            || object->currentCoords.x != mewPrevX
+            || object->currentCoords.y != object->previousCoords.y)
+        {
+            if (object->previousCoords.x == playerX &&
+                object->previousCoords.y == playerY)
+                return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void SetPlayerAvatarTransitionFlags(u16 transitionFlags)
+{
+    gPlayerAvatar.unk1 |= transitionFlags;
+    DoPlayerAvatarTransition();
+}
+
+static void DoPlayerAvatarTransition(void)
+{
+    u8 i;
+    u32 flags = gPlayerAvatar.unk1;
+
+    if (flags != 0)
+    {
+        for (i = 0; i < 8; i++, flags >>= 1)
+        {
+#ifdef NONMATCHING
+            if (flags & 1)
+            {
+                gUnknown_084974B8[i](&gEventObjects[gPlayerAvatar.eventObjectId]);
+            }
+#else
+            if (flags & 1)
+            {
+                register void (*const *funcs)(struct EventObject *) asm("r0") = gUnknown_084974B8;
+                funcs[i](&gEventObjects[gPlayerAvatar.eventObjectId]);
+            }
+#endif
+        }
+        gPlayerAvatar.unk1 = 0;
+    }
+}
+
+static void PlayerAvatarTransition_Dummy(struct EventObject *eventObj)
+{
+
+}
+
+static void PlayerAvatarTransition_Normal(struct EventObject *eventObj)
+{
+    EventObjectSetGraphicsId(eventObj, GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_NORMAL));
+    EventObjectTurn(eventObj, eventObj->movementDirection);
+    SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_ON_FOOT);
+}
+
+static void PlayerAvatarTransition_MachBike(struct EventObject *eventObj)
+{
+    EventObjectSetGraphicsId(eventObj, GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_MACH_BIKE));
+    EventObjectTurn(eventObj, eventObj->movementDirection);
+    SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_MACH_BIKE);
+    BikeClearState(0, 0);
+}
+
+static void PlayerAvatarTransition_AcroBike(struct EventObject *eventObj)
+{
+    EventObjectSetGraphicsId(eventObj, GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_ACRO_BIKE));
+    EventObjectTurn(eventObj, eventObj->movementDirection);
+    SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_ACRO_BIKE);
+    BikeClearState(0, 0);
+    Bike_HandleBumpySlopeJump();
+}
+
+static void PlayerAvatarTransition_Surfing(struct EventObject *eventObj)
+{
+    u8 spriteId;
+
+    EventObjectSetGraphicsId(eventObj, GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_SURFING));
+    EventObjectTurn(eventObj, eventObj->movementDirection);
+    SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_SURFING);
+    gFieldEffectArguments[0] = eventObj->currentCoords.x;
+    gFieldEffectArguments[1] = eventObj->currentCoords.y;
+    gFieldEffectArguments[2] = gPlayerAvatar.eventObjectId;
+    spriteId = FieldEffectStart(FLDEFF_SURF_BLOB);
+    eventObj->fieldEffectSpriteId = spriteId;
+    sub_81555AC(spriteId, 1);
+}
+
+static void PlayerAvatarTransition_Underwater(struct EventObject *eventObj)
+{
+    EventObjectSetGraphicsId(eventObj, GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_UNDERWATER));
+    EventObjectTurn(eventObj, eventObj->movementDirection);
+    SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_UNDERWATER);
+    eventObj->fieldEffectSpriteId = sub_8155800(eventObj->spriteId);
+}
+
+static void PlayerAvatarTransition_ReturnToField(struct EventObject *eventObj)
+{
+    gPlayerAvatar.flags |= PLAYER_AVATAR_FLAG_5;
+}
+
+void sub_808B578(void)
+{
+    gPlayerAvatar.tileTransitionState = T_NOT_MOVING;
+    if (PlayerIsAnimActive())
+    {
+        if (!PlayerCheckIfAnimFinishedOrInactive())
+        {
+            if (!player_is_anim_in_certain_ranges())
+                gPlayerAvatar.tileTransitionState = T_TILE_TRANSITION;
+        }
+        else
+        {
+            if (!sub_808B618())
+                gPlayerAvatar.tileTransitionState = T_TILE_CENTER;
+        }
+    }
+}
+
+static bool8 player_is_anim_in_certain_ranges(void)
+{
+    u8 movementActionId = gEventObjects[gPlayerAvatar.eventObjectId].movementActionId;
+
+    if (movementActionId <= MOVEMENT_ACTION_FACE_RIGHT
+     || (movementActionId >= MOVEMENT_ACTION_DELAY_1 && movementActionId <= MOVEMENT_ACTION_DELAY_16)
+     || (movementActionId >= MOVEMENT_ACTION_WALK_IN_PLACE_SLOW_DOWN && movementActionId <= MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_RIGHT)
+     || (movementActionId >= MOVEMENT_ACTION_ACRO_WHEELIE_FACE_DOWN && movementActionId <= MOVEMENT_ACTION_ACRO_END_WHEELIE_FACE_RIGHT)
+     || (movementActionId >= MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_DOWN && movementActionId <= MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_RIGHT))
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static bool8 sub_808B618(void)
+{
+    if (player_is_anim_in_certain_ranges() && gPlayerAvatar.runningState != TURN_DIRECTION)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static bool8 PlayerIsAnimActive(void)
+{
+    return EventObjectIsMovementOverridden(&gEventObjects[gPlayerAvatar.eventObjectId]);
+}
+
+static bool8 PlayerCheckIfAnimFinishedOrInactive(void)
+{
+    return EventObjectCheckHeldMovementStatus(&gEventObjects[gPlayerAvatar.eventObjectId]);
+}
+
+static void PlayerSetCopyableMovement(u8 a)
+{
+    gEventObjects[gPlayerAvatar.eventObjectId].playerCopyableMovement = a;
+}
+
+u8 PlayerGetCopyableMovement(void)
+{
+    return gEventObjects[gPlayerAvatar.eventObjectId].playerCopyableMovement;
+}
+
+static void sub_808B6BC(u8 a)
+{
+    EventObjectForceSetHeldMovement(&gEventObjects[gPlayerAvatar.eventObjectId], a);
+}
+
+void PlayerSetAnimId(u8 movementActionId, u8 copyableMovement)
+{
+    if (!PlayerIsAnimActive())
+    {
+        PlayerSetCopyableMovement(copyableMovement);
+        EventObjectSetHeldMovement(&gEventObjects[gPlayerAvatar.eventObjectId], movementActionId);
+    }
+}
+
+// normal speed (1 speed)
+void PlayerGoSpeed1(u8 a)
+{
+    PlayerSetAnimId(GetWalkNormalMovementAction(a), 2);
+}
+
+// fast speed (2 speed)
+void PlayerGoSpeed2(u8 a)
+{
+    PlayerSetAnimId(GetWalkFastMovementAction(a), 2);
+}
+
+void PlayerRideWaterCurrent(u8 a)
+{
+    PlayerSetAnimId(GetRideWaterCurrentMovementAction(a), 2);
+}
+
+// fastest speed (4 speed)
+void PlayerGoSpeed4(u8 a)
+{
+    PlayerSetAnimId(GetWalkFastestMovementAction(a), 2);
+}
+
+void PlayerRun(u8 a)
+{
+    PlayerSetAnimId(GetPlayerRunMovementAction(a), 2);
+}
+
+void PlayerOnBikeCollide(u8 a)
+{
+    PlayCollisionSoundIfNotFacingWarp(a);
+    PlayerSetAnimId(GetWalkInPlaceNormalMovementAction(a), 2);
+}
+
+void PlayerOnBikeCollideWithFarawayIslandMew(u8 a)
+{
+    PlayerSetAnimId(GetWalkInPlaceNormalMovementAction(a), 2);
+}
+
+void PlayerNotOnBikeCollide(u8 a)
+{
+    PlayCollisionSoundIfNotFacingWarp(a);
+    PlayerSetAnimId(GetWalkInPlaceSlowMovementAction(a), 2);
+}
+
+void PlayerNotOnBikeCollideWithFarawayIslandMew(u8 a)
+{
+    PlayerSetAnimId(GetWalkInPlaceSlowMovementAction(a), 2);
+}
+
+void PlayerFaceDirection(u8 direction)
+{
+    PlayerSetAnimId(GetFaceDirectionMovementAction(direction), 1);
+}
+
+void PlayerTurnInPlace(u8 direction)
+{
+    PlayerSetAnimId(GetWalkInPlaceFastMovementAction(direction), 1);
+}
+
+void PlayerJumpLedge(u8 direction)
+{
+    PlaySE(SE_DANSA);
+    PlayerSetAnimId(GetJump2MovementAction(direction), 8);
+}
+
+void sub_808B864(void)
+{
+    if (gPlayerAvatar.tileTransitionState == T_TILE_CENTER || gPlayerAvatar.tileTransitionState == T_NOT_MOVING)
+    {
+        if (player_should_look_direction_be_enforced_upon_movement())
+            sub_808B6BC(GetFaceDirectionMovementAction(gEventObjects[gPlayerAvatar.eventObjectId].facingDirection));
+    }
+}
+
+// wheelie idle
+void PlayerIdleWheelie(u8 direction)
+{
+    PlayerSetAnimId(GetAcroWheelieFaceDirectionMovementAction(direction), 1);
+}
+
+// normal to wheelie
+void PlayerStartWheelie(u8 direction)
+{
+    PlayerSetAnimId(GetAcroPopWheelieFaceDirectionMovementAction(direction), 1);
+}
+
+// wheelie to normal
+void PlayerEndWheelie(u8 direction)
+{
+    PlayerSetAnimId(GetAcroEndWheelieFaceDirectionMovementAction(direction), 1);
+}
+
+// wheelie hopping standing
+void PlayerStandingHoppingWheelie(u8 a)
+{
+    PlaySE(SE_JITE_PYOKO);
+    PlayerSetAnimId(GetAcroWheelieHopFaceDirectionMovementAction(a), 1);
+}
+
+// wheelie hopping moving
+void PlayerMovingHoppingWheelie(u8 a)
+{
+    PlaySE(SE_JITE_PYOKO);
+    PlayerSetAnimId(GetAcroWheelieHopDirectionMovementAction(a), 2);
+}
+
+// wheelie hopping ledge
+void PlayerLedgeHoppingWheelie(u8 a)
+{
+    PlaySE(SE_JITE_PYOKO);
+    PlayerSetAnimId(GetAcroWheelieJumpDirectionMovementAction(a), 8);
+}
+
+// acro turn jump
+void PlayerAcroTurnJump(u8 direction)
+{
+    PlaySE(SE_JITE_PYOKO);
+    PlayerSetAnimId(GetJumpInPlaceTurnAroundMovementAction(direction), 1);
+}
+
+void sub_808B980(u8 direction)
+{
+    PlaySE(SE_WALL_HIT);
+    PlayerSetAnimId(GetAcroWheelieInPlaceDirectionMovementAction(direction), 2);
+}
+
+void sub_808B9A4(u8 direction)
+{
+    PlayerSetAnimId(GetAcroPopWheelieMoveDirectionMovementAction(direction), 2);
+}
+
+void sub_808B9BC(u8 direction)
+{
+    PlayerSetAnimId(GetAcroWheelieMoveDirectionMovementAction(direction), 2);
+}
+
+void sub_808B9D4(u8 direction)
+{
+    PlayerSetAnimId(GetAcroEndWheelieMoveDirectionMovementAction(direction), 2);
+}
+
+static void PlayCollisionSoundIfNotFacingWarp(u8 a)
+{
+    s16 x, y;
+    u8 metatileBehavior = gEventObjects[gPlayerAvatar.eventObjectId].currentMetatileBehavior;
+
+    if (!sArrowWarpMetatileBehaviorChecks[a - 1](metatileBehavior))
+    {
+        if (a == 2)
+        {
+            PlayerGetDestCoords(&x, &y);
+            MoveCoords(2, &x, &y);
+            if (MetatileBehavior_IsWarpDoor(MapGridGetMetatileBehaviorAt(x, y)))
+                return;
+        }
+        PlaySE(SE_WALL_HIT);
+    }
+}
+
+void GetXYCoordsOneStepInFrontOfPlayer(s16 *x, s16 *y)
+{
+    *x = gEventObjects[gPlayerAvatar.eventObjectId].currentCoords.x;
+    *y = gEventObjects[gPlayerAvatar.eventObjectId].currentCoords.y;
+    MoveCoords(GetPlayerFacingDirection(), x, y);
+}
+
+void PlayerGetDestCoords(s16 *x, s16 *y)
+{
+    *x = gEventObjects[gPlayerAvatar.eventObjectId].currentCoords.x;
+    *y = gEventObjects[gPlayerAvatar.eventObjectId].currentCoords.y;
+}
+
+u8 player_get_pos_including_state_based_drift(s16 *x, s16 *y)
+{
+    struct EventObject *object = &gEventObjects[gPlayerAvatar.eventObjectId];
+    
+    if (object->heldMovementActive && !object->heldMovementFinished && !gSprites[object->spriteId].data[2])
+    {
+        *x = object->currentCoords.x;
+        *y = object->currentCoords.y;
+
+        switch (object->movementActionId)
+        {
+            case MOVEMENT_ACTION_WALK_NORMAL_DOWN:
+            case MOVEMENT_ACTION_PLAYER_RUN_DOWN:
+                (*y)++;
+                return TRUE;
+            case MOVEMENT_ACTION_WALK_NORMAL_UP:
+            case MOVEMENT_ACTION_PLAYER_RUN_UP:
+                (*y)--;
+                return TRUE;
+            case MOVEMENT_ACTION_WALK_NORMAL_LEFT:
+            case MOVEMENT_ACTION_PLAYER_RUN_LEFT:
+                (*x)--;
+                return TRUE;
+            case MOVEMENT_ACTION_WALK_NORMAL_RIGHT:
+            case MOVEMENT_ACTION_PLAYER_RUN_RIGHT:
+                (*x)++;
+                return TRUE;
+        }
+    }
+
+    *x = -1;
+    *y = -1;
+    return FALSE;
+}
+
+u8 GetPlayerFacingDirection(void)
+{
+    return gEventObjects[gPlayerAvatar.eventObjectId].facingDirection;
+}
+
+u8 GetPlayerMovementDirection(void)
+{
+    return gEventObjects[gPlayerAvatar.eventObjectId].movementDirection;
+}
+
+u8 PlayerGetZCoord(void)
+{
+    return gEventObjects[gPlayerAvatar.eventObjectId].previousElevation;
+}
+
+void sub_808BC90(s16 a, s16 b)
+{
+    sub_808EB08(&gEventObjects[gPlayerAvatar.eventObjectId], a, b);
+}
+
+u8 TestPlayerAvatarFlags(u8 a)
+{
+    return gPlayerAvatar.flags & a;
+}
+
+u8 sub_808BCD0(void)
+{
+    return gPlayerAvatar.flags;
+}
+
+u8 GetPlayerAvatarObjectId(void)
+{
+    return gPlayerAvatar.spriteId;
+}
+
+void sub_808BCE8(void)
+{
+    ForcedMovement_None();
+}
+
+void sub_808BCF4(void)
+{
+    struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+    npc_clear_strange_bits(playerEventObj);
+    SetEventObjectDirection(playerEventObj, playerEventObj->facingDirection);
+    if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE))
+    {
+        Bike_HandleBumpySlopeJump();
+        Bike_UpdateBikeCounterSpeed(0);
+    }
+}
+
+u8 GetRivalAvatarGraphicsIdByStateIdAndGender(u8 state, u8 gender)
+{
+    return sRivalAvatarGfxIds[state][gender];
+}
+
+u8 GetPlayerAvatarGraphicsIdByStateIdAndGender(u8 state, u8 gender)
+{
+    return sPlayerAvatarGfxIds[state][gender];
+}
+
+u8 GetFRLGAvatarGraphicsIdByGender(u8 gender)
+{
+    return sFRLGAvatarGfxIds[gender];
+}
+
+u8 GetRSAvatarGraphicsIdByGender(u8 gender)
+{
+    return sRSAvatarGfxIds[gender];
+}
+
+u8 GetPlayerAvatarGraphicsIdByStateId(u8 state)
+{
+    return GetPlayerAvatarGraphicsIdByStateIdAndGender(state, gPlayerAvatar.gender);
+}
+
+u8 unref_GetRivalAvatarGenderByGraphicsId(u8 gfxId)
+{
+    switch (gfxId)
+    {
+    case EVENT_OBJ_GFX_RIVAL_MAY_NORMAL:
+    case EVENT_OBJ_GFX_RIVAL_MAY_MACH_BIKE:
+    case EVENT_OBJ_GFX_RIVAL_MAY_ACRO_BIKE:
+    case EVENT_OBJ_GFX_RIVAL_MAY_SURFING:
+    case EVENT_OBJ_GFX_RIVAL_MAY_FIELD_MOVE:
+    case EVENT_OBJ_GFX_MAY_UNDERWATER:
+    case EVENT_OBJ_GFX_MAY_FISHING:
+    case EVENT_OBJ_GFX_MAY_WATERING:
+        return FEMALE;
+    default:
+        return MALE;
+    }
+}
+
+u8 GetPlayerAvatarGenderByGraphicsId(u8 gfxId)
+{
+    switch (gfxId)
+    {
+    case EVENT_OBJ_GFX_MAY_NORMAL:
+    case EVENT_OBJ_GFX_MAY_MACH_BIKE:
+    case EVENT_OBJ_GFX_MAY_ACRO_BIKE:
+    case EVENT_OBJ_GFX_MAY_SURFING:
+    case EVENT_OBJ_GFX_MAY_FIELD_MOVE:
+    case EVENT_OBJ_GFX_MAY_UNDERWATER:
+    case EVENT_OBJ_GFX_MAY_FISHING:
+    case EVENT_OBJ_GFX_MAY_WATERING:
+        return FEMALE;
+    default:
+        return MALE;
+    }
+}
+
+bool8 PartyHasMonWithSurf(void)
+{
+    u8 i;
+
+    if (!TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING))
+    {
+        for (i = 0; i < 6; i++)
+        {
+            if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) == SPECIES_NONE)
+                break;
+            if (pokemon_has_move(&gPlayerParty[i], MOVE_SURF))
+                return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+bool8 IsPlayerSurfingNorth(void)
+{
+    if (GetPlayerMovementDirection() == DIR_NORTH && TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING))
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool8 IsPlayerFacingSurfableFishableWater(void)
+{
+    struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+    s16 x = playerEventObj->currentCoords.x;
+    s16 y = playerEventObj->currentCoords.y;
+
+    MoveCoords(playerEventObj->facingDirection, &x, &y);
+    if (GetCollisionAtCoords(playerEventObj, x, y, playerEventObj->facingDirection) == 3 && PlayerGetZCoord() == 3
+     && MetatileBehavior_IsSurfableFishableWater(MapGridGetMetatileBehaviorAt(x, y)))
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void ClearPlayerAvatarInfo(void)
+{
+    memset(&gPlayerAvatar, 0, sizeof(struct PlayerAvatar));
+}
+
+void SetPlayerAvatarStateMask(u8 flags)
+{
+    gPlayerAvatar.flags &= (PLAYER_AVATAR_FLAG_DASH | PLAYER_AVATAR_FLAG_6 | PLAYER_AVATAR_FLAG_5);
+    gPlayerAvatar.flags |= flags;
+}
+
+static u8 GetPlayerAvatarStateTransitionByGraphicsId(u8 a, u8 gender)
+{
+    u8 i;
+
+    for (i = 0; i < 5; i++)
+    {
+        if (gUnknown_0849750C[gender][i][0] == a)
+            return gUnknown_0849750C[gender][i][1];
+    }
+    return 1;
+}
+
+u8 GetPlayerAvatarGraphicsIdByCurrentState(void)
+{
+    u8 i;
+    u8 r5 = gPlayerAvatar.flags;
+
+    for (i = 0; i < 5; i++)
+    {
+        if (gUnknown_0849750C[gPlayerAvatar.gender][i][1] & r5)
+            return gUnknown_0849750C[gPlayerAvatar.gender][i][0];
+    }
+    return 0;
+}
+
+void SetPlayerAvatarExtraStateTransition(u8 a, u8 b)
+{
+    u8 unk = GetPlayerAvatarStateTransitionByGraphicsId(a, gPlayerAvatar.gender);
+
+    gPlayerAvatar.unk1 |= unk | b;
+    DoPlayerAvatarTransition();
+}
+
+void InitPlayerAvatar(s16 x, s16 y, u8 direction, u8 gender)
+{
+    struct EventObjectTemplate playerEventObjTemplate;
+    u8 eventObjectId;
+    struct EventObject *eventObject;
+
+    playerEventObjTemplate.localId = 0xFF;
+    playerEventObjTemplate.graphicsId = GetPlayerAvatarGraphicsIdByStateIdAndGender(PLAYER_AVATAR_STATE_NORMAL, gender);
+    playerEventObjTemplate.x = x - 7;
+    playerEventObjTemplate.y = y - 7;
+    playerEventObjTemplate.elevation = 0;
+    playerEventObjTemplate.movementType = MOVEMENT_TYPE_PLAYER;
+    playerEventObjTemplate.movementRangeX = 0;
+    playerEventObjTemplate.movementRangeY = 0;
+    playerEventObjTemplate.trainerType = 0;
+    playerEventObjTemplate.trainerRange_berryTreeId = 0;
+    playerEventObjTemplate.script = NULL;
+    playerEventObjTemplate.flagId = 0;
+    eventObjectId = SpawnSpecialEventObject(&playerEventObjTemplate);
+    eventObject = &gEventObjects[eventObjectId];
+    eventObject->isPlayer = 1;
+    eventObject->warpArrowSpriteId = CreateWarpArrowSprite();
+    EventObjectTurn(eventObject, direction);
+    ClearPlayerAvatarInfo();
+    gPlayerAvatar.runningState = NOT_MOVING;
+    gPlayerAvatar.tileTransitionState = T_NOT_MOVING;
+    gPlayerAvatar.eventObjectId = eventObjectId;
+    gPlayerAvatar.spriteId = eventObject->spriteId;
+    gPlayerAvatar.gender = gender;
+    SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_5 | PLAYER_AVATAR_FLAG_ON_FOOT);
+}
+
+void sub_808C0A8(u8 a)
+{
+    gEventObjects[gPlayerAvatar.eventObjectId].invisible = a;
+    if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING))
+        gSprites[gEventObjects[gPlayerAvatar.eventObjectId].fieldEffectSpriteId].invisible = a;
+}
+
+void sub_808C114(void)
+{
+    EventObjectSetGraphicsId(&gEventObjects[gPlayerAvatar.eventObjectId], GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_FIELD_MOVE));
+    StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], 0);
+}
+
+void sub_808C15C(u8 direction)
+{
+    EventObjectSetGraphicsId(&gEventObjects[gPlayerAvatar.eventObjectId], GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_FISHING));
+    StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFishingDirectionAnimNum(direction));
+}
+
+void sub_808C1B4(u8 direction)
+{
+    EventObjectSetGraphicsId(&gEventObjects[gPlayerAvatar.eventObjectId], GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_ACRO_BIKE));
+    StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetAcroWheelieDirectionAnimNum(direction));
+    SeekSpriteAnim(&gSprites[gPlayerAvatar.spriteId], 1);
+}
+
+void sub_808C228(u8 direction)
+{
+    EventObjectSetGraphicsId(&gEventObjects[gPlayerAvatar.eventObjectId], GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_WATERING));
+    StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFaceDirectionAnimNum(direction));
+}
+
+static void sub_808C280(struct EventObject *eventObject)
+{
+    s16 x;
+    s16 y;
+    u8 direction;
+    u8 metatileBehavior = eventObject->currentMetatileBehavior;
+
+    for (x = 0, direction = DIR_SOUTH; x < 4; x++, direction++)
+    {
+        if (sArrowWarpMetatileBehaviorChecks2[x](metatileBehavior) && direction == eventObject->movementDirection)
+        {
+            x = eventObject->currentCoords.x;
+            y = eventObject->currentCoords.y;
+            MoveCoords(direction, &x, &y);
+            ShowWarpArrowSprite(eventObject->warpArrowSpriteId, direction, x, y);
+            return;
+        }
+    }
+    SetSpriteInvisible(eventObject->warpArrowSpriteId);
+}
+
+/* Strength */
+
+static void Task_BumpBoulder(u8 taskId);
+
+static void StartStrengthAnim(u8 a, u8 b)
+{
+    u8 taskId = CreateTask(Task_BumpBoulder, 0xFF);
+
+    gTasks[taskId].data[1] = a;
+    gTasks[taskId].data[2] = b;
+    Task_BumpBoulder(taskId);
+}
+
+static void Task_BumpBoulder(u8 taskId)
+{
+    while (gUnknown_08497530[gTasks[taskId].data[0]](&gTasks[taskId],
+                                                     &gEventObjects[gPlayerAvatar.eventObjectId],
+                                                     &gEventObjects[gTasks[taskId].data[1]]))
+        ;
+}
+
+static bool8 sub_808C3A4(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject)
+{
+    ScriptContext2_Enable();
+    gPlayerAvatar.preventStep = TRUE;
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 do_boulder_dust(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject)
+{
+    if (EventObjectIsHeldMovementActive(playerObject))
+    {
+        EventObjectClearHeldMovementIfFinished(playerObject);
+    }
+
+    if (EventObjectIsHeldMovementActive(strengthObject))
+    {
+        EventObjectClearHeldMovementIfFinished(strengthObject);
+    }
+
+    if (!EventObjectIsMovementOverridden(playerObject)
+     && !EventObjectIsMovementOverridden(strengthObject))
+    {
+        EventObjectClearHeldMovementIfFinished(playerObject);
+        EventObjectClearHeldMovementIfFinished(strengthObject);
+        EventObjectSetHeldMovement(playerObject, GetWalkInPlaceNormalMovementAction((u8)task->data[2]));
+        EventObjectSetHeldMovement(strengthObject, GetWalkSlowMovementAction((u8)task->data[2]));
+        gFieldEffectArguments[0] = strengthObject->currentCoords.x;
+        gFieldEffectArguments[1] = strengthObject->currentCoords.y;
+        gFieldEffectArguments[2] = strengthObject->previousElevation;
+        gFieldEffectArguments[3] = gSprites[strengthObject->spriteId].oam.priority;
+        FieldEffectStart(FLDEFF_DUST);
+        PlaySE(SE_W070);
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 sub_808C484(struct Task *task, struct EventObject *playerObject, struct EventObject *strengthObject)
+{
+    if (EventObjectCheckHeldMovementStatus(playerObject)
+     && EventObjectCheckHeldMovementStatus(strengthObject))
+    {
+        EventObjectClearHeldMovementIfFinished(playerObject);
+        EventObjectClearHeldMovementIfFinished(strengthObject);
+        gPlayerAvatar.preventStep = FALSE;
+        ScriptContext2_Disable();
+        DestroyTask(FindTaskIdByFunc(Task_BumpBoulder));
+    }
+    return FALSE;
+}
+
+/* Some field effect */
+
+static void DoPlayerAvatarSecretBaseMatJump(u8 taskId);
+
+static void DoPlayerMatJump(void)
+{
+    DoPlayerAvatarSecretBaseMatJump(CreateTask(DoPlayerAvatarSecretBaseMatJump, 0xFF));
+}
+
+static void DoPlayerAvatarSecretBaseMatJump(u8 taskId)
+{
+    while (sPlayerAvatarSecretBaseMatJump[gTasks[taskId].data[0]](&gTasks[taskId], &gEventObjects[gPlayerAvatar.eventObjectId]))
+        ;
+}
+
+// because data[0] is used to call this, it can be inferred that there may have been multiple mat jump functions at one point, so the name for these groups of functions is appropriate in assuming the sole use of mat jump.
+static u8 PlayerAvatar_DoSecretBaseMatJump(struct Task *task, struct EventObject *eventObject)
+{
+    gPlayerAvatar.preventStep = TRUE;
+    if (EventObjectClearHeldMovementIfFinished(eventObject))
+    {
+        PlaySE(SE_DANSA);
+        EventObjectSetHeldMovement(eventObject, GetJumpInPlaceMovementAction(eventObject->facingDirection));
+        task->data[1]++;
+        if (task->data[1] > 1)
+        {
+            gPlayerAvatar.preventStep = FALSE;
+            gPlayerAvatar.unk1 |= 0x20;
+            DestroyTask(FindTaskIdByFunc(DoPlayerAvatarSecretBaseMatJump));
+        }
+    }
+    return FALSE;
+}
+
+/* Some field effect */
+
+static void PlayerAvatar_DoSecretBaseMatSpin(u8 taskId);
+
+static void DoPlayerMatSpin(void)
+{
+    u8 taskId = CreateTask(PlayerAvatar_DoSecretBaseMatSpin, 0xFF);
+
+    PlayerAvatar_DoSecretBaseMatSpin(taskId);
+}
+
+static void PlayerAvatar_DoSecretBaseMatSpin(u8 taskId)
+{
+    while (sPlayerAvatarSecretBaseMatSpin[gTasks[taskId].data[0]](&gTasks[taskId], &gEventObjects[gPlayerAvatar.eventObjectId]))
+        ;
+}
+
+static bool8 PlayerAvatar_SecretBaseMatSpinStep0(struct Task *task, struct EventObject *eventObject)
+{
+    task->data[0]++;
+    task->data[1] = eventObject->movementDirection;
+    gPlayerAvatar.preventStep = TRUE;
+    ScriptContext2_Enable();
+    PlaySE(SE_TK_WARPIN);
+    return TRUE;
+}
+
+static bool8 PlayerAvatar_SecretBaseMatSpinStep1(struct Task *task, struct EventObject *eventObject)
+{
+    u8 directions[] = {DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH};
+
+    if (EventObjectClearHeldMovementIfFinished(eventObject))
+    {
+        u8 direction;
+
+        EventObjectSetHeldMovement(eventObject, GetFaceDirectionMovementAction(direction = directions[eventObject->movementDirection - 1]));
+        if (direction == (u8)task->data[1])
+            task->data[2]++;
+        task->data[0]++;
+        if (task->data[2] > 3 && direction == GetOppositeDirection(task->data[1]))
+            task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 PlayerAvatar_SecretBaseMatSpinStep2(struct Task *task, struct EventObject *eventObject)
+{
+    const u8 actions[] = {
+        MOVEMENT_ACTION_DELAY_1,
+        MOVEMENT_ACTION_DELAY_1,
+        MOVEMENT_ACTION_DELAY_2,
+        MOVEMENT_ACTION_DELAY_4,
+        MOVEMENT_ACTION_DELAY_8,
+    };
+
+    if (EventObjectClearHeldMovementIfFinished(eventObject))
+    {
+        EventObjectSetHeldMovement(eventObject, actions[task->data[2]]);
+        task->data[0] = 1;
+    }
+    return FALSE;
+}
+
+static bool8 PlayerAvatar_SecretBaseMatSpinStep3(struct Task *task, struct EventObject *eventObject)
+{
+    if (EventObjectClearHeldMovementIfFinished(eventObject))
+    {
+        EventObjectSetHeldMovement(eventObject, GetWalkSlowMovementAction(GetOppositeDirection(task->data[1])));
+        ScriptContext2_Disable();
+        gPlayerAvatar.preventStep = FALSE;
+        DestroyTask(FindTaskIdByFunc(PlayerAvatar_DoSecretBaseMatSpin));
+    }
+    return FALSE;
+}
+
+/* Some Field effect */
+
+static void taskFF_0805D1D4(u8 taskId);
+static void sub_808C814(u8 taskId);
+
+static void sub_808C750(u8 a)
+{
+    u8 taskId;
+
+    ScriptContext2_Enable();
+    Overworld_ClearSavedMusic();
+    Overworld_ChangeMusicToDefault();
+    gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_SURFING;
+    gPlayerAvatar.flags |= PLAYER_AVATAR_FLAG_ON_FOOT;
+    gPlayerAvatar.preventStep = TRUE;
+    taskId = CreateTask(taskFF_0805D1D4, 0xFF);
+    gTasks[taskId].data[0] = a;
+    taskFF_0805D1D4(taskId);
+}
+
+static void taskFF_0805D1D4(u8 taskId)
+{
+    struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+    if (EventObjectIsMovementOverridden(playerEventObj))
+    {
+        if (!EventObjectClearHeldMovementIfFinished(playerEventObj))
+            return;
+    }
+    sub_81555AC(playerEventObj->fieldEffectSpriteId, 2);
+    EventObjectSetHeldMovement(playerEventObj, GetJumpSpecialMovementAction((u8)gTasks[taskId].data[0]));
+    gTasks[taskId].func = sub_808C814;
+}
+
+static void sub_808C814(u8 taskId)
+{
+    struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+    if (EventObjectClearHeldMovementIfFinished(playerEventObj))
+    {
+        EventObjectSetGraphicsId(playerEventObj, GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_NORMAL));
+        EventObjectSetHeldMovement(playerEventObj, GetFaceDirectionMovementAction(playerEventObj->facingDirection));
+        gPlayerAvatar.preventStep = FALSE;
+        ScriptContext2_Disable();
+        DestroySprite(&gSprites[playerEventObj->fieldEffectSpriteId]);
+        DestroyTask(taskId);
+    }
+}
+
+static bool8 (*const sFishingStateFuncs[])(struct Task *) =
+{
+    Fishing1,
+    Fishing2,
+    Fishing3,
+    Fishing4,
+    Fishing5,
+    Fishing6,
+    Fishing7,
+    Fishing8,
+    Fishing9,
+    Fishing10,
+    Fishing11,
+    Fishing12,
+    Fishing13,
+    Fishing14,
+    Fishing15,
+    Fishing16,
+};
+
+static void Task_Fishing(u8 taskId);
+static void sub_808CF78(void);
+
+#define tStep              data[0]
+#define tFrameCounter      data[1]
+#define tNumDots           data[2]
+#define tDotsRequired      data[3]
+#define tRoundsPlayed      data[12]
+#define tMinRoundsRequired data[13]
+#define tPlayerGfxId       data[14]
+#define tFishingRod        data[15]
+
+#define FISHING_START_ROUND 3
+#define FISHING_GOT_BITE 6
+#define FISHING_ON_HOOK 9
+#define FISHING_NO_BITE 11
+#define FISHING_GOT_AWAY 12
+#define FISHING_SHOW_RESULT 13
+
+void StartFishing(u8 rod)
+{
+    u8 taskId = CreateTask(Task_Fishing, 0xFF);
+
+    gTasks[taskId].tFishingRod = rod;
+    Task_Fishing(taskId);
+}
+
+static void Task_Fishing(u8 taskId)
+{
+    while (sFishingStateFuncs[gTasks[taskId].tStep](&gTasks[taskId]))
+        ;
+}
+
+static bool8 Fishing1(struct Task *task)
+{
+    ScriptContext2_Enable();
+    gPlayerAvatar.preventStep = TRUE;
+    task->tStep++;
+    return FALSE;
+}
+
+static bool8 Fishing2(struct Task *task)
+{
+    struct EventObject *playerEventObj;
+    const s16 arr1[] = {1, 1, 1};
+    const s16 arr2[] = {1, 3, 6};
+
+    task->tRoundsPlayed = 0;
+    task->tMinRoundsRequired = arr1[task->tFishingRod] + (Random() % arr2[task->tFishingRod]);
+    task->tPlayerGfxId = gEventObjects[gPlayerAvatar.eventObjectId].graphicsId;
+    playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+    EventObjectClearHeldMovementIfActive(playerEventObj);
+    playerEventObj->enableAnim = 1;
+    sub_808C15C(playerEventObj->facingDirection);
+    task->tStep++;
+    return FALSE;
+}
+
+static bool8 Fishing3(struct Task *task)
+{
+    sub_808CF78();
+    
+    // Wait one second
+    task->tFrameCounter++;
+    if (task->tFrameCounter >= 60)
+        task->tStep++;
+    return FALSE;
+}
+
+static bool8 Fishing4(struct Task *task)
+{
+    u32 randVal;
+
+    sub_819786C(0, TRUE);
+    task->tStep++;
+    task->tFrameCounter = 0;
+    task->tNumDots = 0;
+    randVal = Random();
+    randVal %= 10;
+    task->tDotsRequired = randVal + 1;
+    if (task->tRoundsPlayed == 0)
+        task->tDotsRequired = randVal + 4;
+    if (task->tDotsRequired >= 10)
+        task->tDotsRequired = 10;
+    return TRUE;
+}
+
+// Play a round of the dot game
+static bool8 Fishing5(struct Task *task)
+{
+    const u8 dot[] = _("·");
+
+    sub_808CF78();
+    task->tFrameCounter++;
+    if (gMain.newKeys & A_BUTTON)
+    {
+        task->tStep = FISHING_NO_BITE;
+        if (task->tRoundsPlayed != 0)
+            task->tStep = FISHING_GOT_AWAY;
+        return TRUE;
+    }
+    else
+    {
+        if (task->tFrameCounter >= 20)
+        {
+            task->tFrameCounter = 0;
+            if (task->tNumDots >= task->tDotsRequired)
+            {
+                task->tStep++;
+                if (task->tRoundsPlayed != 0)
+                    task->tStep++;
+                task->tRoundsPlayed++;
+            }
+            else
+            {
+                AddTextPrinterParameterized(0, 1, dot, task->tNumDots * 8, 1, 0, NULL);
+                task->tNumDots++;
+            }
+        }
+        return FALSE;
+    }
+}
+
+// Determine if fish bites
+static bool8 Fishing6(struct Task *task)
+{
+    bool8 bite;
+
+    sub_808CF78();
+    task->tStep++;
+    bite = FALSE;
+
+    if (!DoesCurrentMapHaveFishingMons())
+    {
+        task->tStep = FISHING_NO_BITE;
+    }
+    else
+    {
+        if (!GetMonData(&gPlayerParty[0], MON_DATA_SANITY_BIT3))
+        {
+            u8 ability = GetMonAbility(&gPlayerParty[0]);
+            if (ability == ABILITY_SUCTION_CUPS || ability  == ABILITY_STICKY_HOLD)
+            {
+                if (Random() % 100 > 14)
+                {
+                    bite = TRUE;
+                }
+            }
+        }
+
+        if (!bite)
+        {
+            if (Random() & 1)
+            {
+                task->tStep = FISHING_NO_BITE;
+            }
+            else
+            {
+                bite = TRUE;
+            }
+        }
+
+        if (bite == TRUE)
+        {
+            StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFishingBiteDirectionAnimNum(GetPlayerFacingDirection()));
+        }
+    }
+    return TRUE;
+}
+
+// Oh! A Bite!
+static bool8 Fishing7(struct Task *task)
+{
+    sub_808CF78();
+    AddTextPrinterParameterized(0, 1, gText_OhABite, 0, 17, 0, NULL);
+    task->tStep++;
+    task->tFrameCounter = 0;
+    return FALSE;
+}
+
+// We have a bite. Now, wait for the player to press A, or the timer to expire.
+static bool8 Fishing8(struct Task *task)
+{
+    const s16 reelTimeouts[3] = {36, 33, 30};
+
+    sub_808CF78();
+    task->tFrameCounter++;
+    if (task->tFrameCounter >= reelTimeouts[task->tFishingRod])
+        task->tStep = FISHING_GOT_AWAY;
+    else if (gMain.newKeys & A_BUTTON)
+        task->tStep++;
+    return FALSE;
+}
+
+// Determine if we're going to play the dot game again
+static bool8 Fishing9(struct Task *task)
+{
+    const s16 arr[][2] =
+    {
+        {0, 0},
+        {40, 10},
+        {70, 30}
+    };
+
+    sub_808CF78();
+    task->tStep++;
+    if (task->tRoundsPlayed < task->tMinRoundsRequired)
+    {
+        task->tStep = FISHING_START_ROUND;
+    }
+    else if (task->tRoundsPlayed < 2)
+    {
+        // probability of having to play another round
+        s16 probability = Random() % 100;
+
+        if (arr[task->tFishingRod][task->tRoundsPlayed] > probability)
+            task->tStep = FISHING_START_ROUND;
+    }
+    return FALSE;
+}
+
+static bool8 Fishing10(struct Task *task)
+{
+    sub_808CF78();
+    FillWindowPixelBuffer(0, 0x11);
+    AddTextPrinterParameterized2(0, 1, gText_PokemonOnHook, 1, 0, 2, 1, 3);
+    task->tStep++;
+    task->tFrameCounter = 0;
+    return FALSE;
+}
+
+static bool8 Fishing11(struct Task *task)
+{
+    if (task->tFrameCounter == 0)
+        sub_808CF78();
+
+    RunTextPrinters();
+
+    if (task->tFrameCounter == 0)
+    {
+        if (!IsTextPrinterActive(0))
+        {
+            struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+            EventObjectSetGraphicsId(playerEventObj, task->tPlayerGfxId);
+            EventObjectTurn(playerEventObj, playerEventObj->movementDirection);
+            if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
+                sub_8155604(gEventObjects[gPlayerAvatar.eventObjectId].fieldEffectSpriteId, 0, 0);
+            gSprites[gPlayerAvatar.spriteId].pos2.x = 0;
+            gSprites[gPlayerAvatar.spriteId].pos2.y = 0;
+            sub_8197434(0, TRUE);
+            task->tFrameCounter++;
+            return FALSE;
+        }
+    }
+
+    if (task->tFrameCounter != 0)
+    {
+        gPlayerAvatar.preventStep = FALSE;
+        ScriptContext2_Disable();
+        FishingWildEncounter(task->tFishingRod);
+        sub_80ED950(1);
+        DestroyTask(FindTaskIdByFunc(Task_Fishing));
+    }
+    return FALSE;
+}
+
+// Not even a nibble
+static bool8 Fishing12(struct Task *task)
+{
+    sub_808CF78();
+    StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFishingNoCatchDirectionAnimNum(GetPlayerFacingDirection()));
+    FillWindowPixelBuffer(0, 0x11);
+    AddTextPrinterParameterized2(0, 1, gText_NotEvenANibble, 1, 0, 2, 1, 3);
+    task->tStep = FISHING_SHOW_RESULT;
+    return TRUE;
+}
+
+// It got away
+static bool8 Fishing13(struct Task *task)
+{
+    sub_808CF78();
+    StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFishingNoCatchDirectionAnimNum(GetPlayerFacingDirection()));
+    FillWindowPixelBuffer(0, 0x11);
+    AddTextPrinterParameterized2(0, 1, gText_ItGotAway, 1, 0, 2, 1, 3);
+    task->tStep++;
+    return TRUE;
+}
+
+// Wait one second
+static bool8 Fishing14(struct Task *task)
+{
+    sub_808CF78();
+    task->tStep++;
+    return FALSE;
+}
+
+static bool8 Fishing15(struct Task *task)
+{
+    sub_808CF78();
+    if (gSprites[gPlayerAvatar.spriteId].animEnded)
+    {
+        struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+        EventObjectSetGraphicsId(playerEventObj, task->tPlayerGfxId);
+        EventObjectTurn(playerEventObj, playerEventObj->movementDirection);
+        if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
+            sub_8155604(gEventObjects[gPlayerAvatar.eventObjectId].fieldEffectSpriteId, 0, 0);
+        gSprites[gPlayerAvatar.spriteId].pos2.x = 0;
+        gSprites[gPlayerAvatar.spriteId].pos2.y = 0;
+        task->tStep++;
+    }
+    return FALSE;
+}
+
+static bool8 Fishing16(struct Task *task)
+{
+    RunTextPrinters();
+    if (!IsTextPrinterActive(0))
+    {
+        gPlayerAvatar.preventStep = FALSE;
+        ScriptContext2_Disable();
+        UnfreezeEventObjects();
+        sub_8197434(0, TRUE);
+        sub_80ED950(0);
+        DestroyTask(FindTaskIdByFunc(Task_Fishing));
+    }
+    return FALSE;
+}
+
+#undef tStep
+#undef tFrameCounter
+#undef tFishingRod
+
+static void sub_808CF78(void)
+{
+    struct Sprite *playerSprite = &gSprites[gPlayerAvatar.spriteId];
+    u8 animCmdIndex;
+    u8 animType;
+
+    AnimateSprite(playerSprite);
+    playerSprite->pos2.x = 0;
+    playerSprite->pos2.y = 0;
+    animCmdIndex = playerSprite->animCmdIndex;
+    if (playerSprite->anims[playerSprite->animNum][animCmdIndex].type == -1)
+    {
+        animCmdIndex--;
+    }
+    else
+    {
+        playerSprite->animDelayCounter++;
+        if (playerSprite->anims[playerSprite->animNum][animCmdIndex].type == -1)
+            animCmdIndex--;
+    }
+    animType = playerSprite->anims[playerSprite->animNum][animCmdIndex].type;
+    if (animType == 1 || animType == 2 || animType == 3)
+    {
+        playerSprite->pos2.x = 8;
+        if (GetPlayerFacingDirection() == 3)
+            playerSprite->pos2.x = -8;
+    }
+    if (animType == 5)
+        playerSprite->pos2.y = -8;
+    if (animType == 10 || animType == 11)
+        playerSprite->pos2.y = 8;
+    if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
+        sub_8155604(gEventObjects[gPlayerAvatar.eventObjectId].fieldEffectSpriteId, 1, playerSprite->pos2.y);
+}
+
+void sub_808D074(u8 a0)
+{
+    gUnknown_0203734C = a0;
+}
+
+static u8 sub_808D080(void)
+{
+    if (gUnknown_0203734C == 0)
+    {
+        return 1;
+    }
+    return gUnknown_0203734C;
+}
+
+static u8 sub_808D38C(struct EventObject *object, s16 *a1);
+
+static void sub_808D094(u8 taskId)
+{
+    struct EventObject *object = &gEventObjects[gPlayerAvatar.eventObjectId];
+    struct Sprite *sprite = &gSprites[object->spriteId];
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+        case 0:
+            if (!EventObjectClearHeldMovementIfFinished(object))
+            {
+                return;
+            }
+
+            sub_808D074(object->facingDirection);
+            data[1] = 0;
+            data[2] = 1;
+            data[3] = (u16)(sprite->pos1.y + sprite->pos2.y) * 16;
+            sprite->pos2.y = 0;
+            CameraObjectReset2();
+            object->fixedPriority = TRUE;
+            sprite->oam.priority = 0;
+            sprite->subpriority = 0;
+            sprite->subspriteMode = 0;
+            data[0]++;
+        case 1:
+            sub_808D38C(object, &data[1]);
+            data[3] -= data[2];
+            data[2] += 3;
+            sprite->pos1.y = data[3] >> 4;
+            if (sprite->pos1.y + (s16)gTotalCameraPixelOffsetY < -32)
+            {
+                data[0]++;
+            }
+            break;
+        case 2:
+            DestroyTask(taskId);
+            break;
+    }
+}
+
+static void sub_808D1FC(u8 taskId);
+
+void sub_808D194(void)
+{
+    sub_808D1FC(CreateTask(sub_808D1FC, 0));
+}
+
+bool8 sub_808D1B4(void)
+{
+    return FuncIsActiveTask(sub_808D1FC);
+}
+
+void sub_808D1C8(void)
+{
+    sub_808D094(CreateTask(sub_808D094, 0));
+}
+
+bool8 sub_808D1E8(void)
+{
+    return FuncIsActiveTask(sub_808D094);
+}
+
+static const u8 gUnknown_084975BC[] = {DIR_SOUTH, DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH};
+
+static void sub_808D1FC(u8 taskId)
+{
+    struct EventObject *object = &gEventObjects[gPlayerAvatar.eventObjectId];
+    struct Sprite *sprite = &gSprites[object->spriteId];
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+        case 0:
+            data[5] = sub_808D080();
+            EventObjectForceSetHeldMovement(object, GetFaceDirectionMovementAction(gUnknown_084975BC[data[5]]));
+            data[1] = 0;
+            data[2] = 116;
+            data[4] = sprite->pos1.y;
+            data[6] = sprite->oam.priority;
+            data[7] = sprite->subpriority;
+            data[3] = -((u16)sprite->pos2.y + 32) * 16;
+            sprite->pos2.y = 0;
+            CameraObjectReset2();
+            object->fixedPriority = TRUE;
+            sprite->oam.priority = 1;
+            sprite->subpriority = 0;
+            sprite->subspriteMode = 0;
+            data[0]++;
+        case 1:
+            sub_808D38C(object, &data[1]);
+            data[3] += data[2];
+            data[2] -= 3;
+            if (data[2] < 4)
+            {
+                data[2] = 4;
+            }
+            sprite->pos1.y = data[3] >> 4;
+            if (sprite->pos1.y >= data[4])
+            {
+                sprite->pos1.y = data[4];
+                data[8] = 0;
+                data[0]++;
+            }
+            break;
+        case 2:
+            sub_808D38C(object, &data[1]);
+            data[8]++;
+            if (data[8] > 8)
+            {
+                data[0]++;
+            }
+            break;
+        case 3:
+            if (data[5] == sub_808D38C(object, &data[1]))
+            {
+                object->fixedPriority = 0;
+                sprite->oam.priority = data[6];
+                sprite->subpriority = data[7];
+                CameraObjectReset1();
+                DestroyTask(taskId);
+            }
+            break;
+    }
+}
+
+static u8 sub_808D38C(struct EventObject *object, s16 *a1)
+{
+    if (*a1 < 8 && ++(*a1) < 8)
+    {
+        return object->facingDirection;
+    }
+
+    if (!EventObjectCheckHeldMovementStatus(object))
+    {
+        return object->facingDirection;
+    }
+
+    EventObjectForceSetHeldMovement(object, GetFaceDirectionMovementAction(gUnknown_084975BC[object->facingDirection]));
+    *a1 = 0;
+    return gUnknown_084975BC[object->facingDirection];
+}
diff --git a/src/field_poison.c b/src/field_poison.c
index a3b70323e..a5a76e00a 100644
--- a/src/field_poison.c
+++ b/src/field_poison.c
@@ -112,7 +112,7 @@ void ExecuteWhiteOut(void)
     ScriptContext1_Stop();
 }
 
-u32 DoPoisonFieldEffect(void)
+s32 DoPoisonFieldEffect(void)
 {
     int i;
     u32 hp;
diff --git a/src/field_specials.c b/src/field_specials.c
index c9feeabda..beaa11e99 100644
--- a/src/field_specials.c
+++ b/src/field_specials.c
@@ -1328,7 +1328,7 @@ u16 GetSlotMachineId(void)
 bool8 FoundAbandonedShipRoom1Key(void)
 {
     u16 *specVar = &gSpecialVar_0x8004;
-    u16 flag = FLAG_HIDDEN_ITEM_1F;
+    u16 flag = FLAG_HIDDEN_ITEM_ABANDONED_SHIP_RM_1_KEY;
     *specVar = flag;
     if (!FlagGet(flag))
     {
@@ -1340,7 +1340,7 @@ bool8 FoundAbandonedShipRoom1Key(void)
 bool8 FoundAbandonedShipRoom2Key(void)
 {
     u16 *specVar = &gSpecialVar_0x8004;
-    u16 flag = FLAG_HIDDEN_ITEM_20;
+    u16 flag = FLAG_HIDDEN_ITEM_ABANDONED_SHIP_RM_2_KEY;
     *specVar = flag;
     if (!FlagGet(flag))
     {
@@ -1352,7 +1352,7 @@ bool8 FoundAbandonedShipRoom2Key(void)
 bool8 FoundAbandonedShipRoom4Key(void)
 {
     u16 *specVar = &gSpecialVar_0x8004;
-    u16 flag = FLAG_HIDDEN_ITEM_21;
+    u16 flag = FLAG_HIDDEN_ITEM_ABANDONED_SHIP_RM_4_KEY;
     *specVar = flag;
     if (!FlagGet(flag))
     {
@@ -1364,7 +1364,7 @@ bool8 FoundAbandonedShipRoom4Key(void)
 bool8 FoundAbandonedShipRoom6Key(void)
 {
     u16 *specVar = &gSpecialVar_0x8004;
-    u16 flag = FLAG_HIDDEN_ITEM_22;
+    u16 flag = FLAG_HIDDEN_ITEM_ABANDONED_SHIP_RM_6_KEY;
     *specVar = flag;
     if (!FlagGet(flag))
     {
@@ -1508,7 +1508,7 @@ static void sub_8139620(u8 taskId)
 
 bool8 FoundBlackGlasses(void)
 {
-    return FlagGet(FLAG_HIDDEN_ITEM_BLACK_GLASSES);
+    return FlagGet(FLAG_HIDDEN_ITEM_ROUTE_116_BLACK_GLASSES);
 }
 
 void SetRoute119Weather(void)
@@ -3668,7 +3668,7 @@ bool32 sub_813B374(void)
     }
 }
 
-bool32 sub_813B3B0(void)
+bool8 sub_813B3B0(void)
 {
     static const u8 gUnknown_085B3410[] = { 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, 0x1f, 0x21, 0x21, 0x14, 0x14, 0x28, 0x28, 0x2a, 0x2a, 0x2c, 0x2c };
 
@@ -4081,7 +4081,7 @@ void sub_813BA60(void)
         FlagClear(FLAG_HIDE_FANCLUB_BOY);
         FlagClear(FLAG_HIDE_FANCLUB_LITTLE_BOY);
         FlagClear(FLAG_HIDE_FANCLUB_LADY);
-        FlagClear(FLAG_0x2DA);
+        FlagClear(FLAG_HIDE_LILYCOVE_FAN_CLUB_INTERVIEWER);
         VarSet(VAR_LILYCOVE_FAN_CLUB_STATE, 1);
     }
 }
diff --git a/src/fldeff_escalator.c b/src/fldeff_escalator.c
new file mode 100644
index 000000000..b906225da
--- /dev/null
+++ b/src/fldeff_escalator.c
@@ -0,0 +1,132 @@
+#include "global.h"
+#include "task.h"
+#include "fieldmap.h"
+#include "field_camera.h"
+#include "field_player_avatar.h"
+
+static EWRAM_DATA u8 sEscalatorAnim_TaskId = 0;
+
+void sub_80E12E8(u8 taskId, const s16 *list, u16 c)
+{
+    s16 r5 = gTasks[taskId].data[4] - 1;
+    s16 r3 = gTasks[taskId].data[5] - 1;
+    s16 r4 = gTasks[taskId].data[1];
+    s16 y;
+    s16 x;
+    
+    if (gTasks[taskId].data[2] == 0)
+    {
+        for (y = 0; y < 3; y++)
+        {
+            for (x = 0; x < 3; x++)
+            {
+                s16 metatileId = MapGridGetMetatileIdAt(r5 + x, r3 + y);
+                
+                if (list[r4] == metatileId)
+                {
+                    if (r4 != 2)
+                        MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[r4 + 1]);
+                    else
+                        MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[0]);
+                }
+            }
+        }
+    }
+    else
+    {
+        for (y = 0; y < 3; y++)
+        {
+            for (x = 0; x < 3; x++)
+            {
+                s16 metatileId = MapGridGetMetatileIdAt(r5 + x, r3 + y);
+                
+                if (list[2 - r4] == metatileId)
+                {
+                    if (r4 != 2)
+                        MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[1 - r4]);
+                    else
+                        MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[2]);
+                }
+            }
+        }
+    }
+}
+
+static const u16 gUnknown_08589ABA[] = {0x284, 0x282, 0x280};
+static const u16 gUnknown_08589AC0[] = {0x285, 0x283, 0x281};
+static const u16 gUnknown_08589AC6[] = {0x28C, 0x28A, 0x288};
+static const u16 gUnknown_08589ACC[] = {0x28D, 0x28B, 0x289};
+static const u16 gUnknown_08589AD2[] = {0x2A0, 0x2A2, 0x2A4};
+static const u16 gUnknown_08589AD8[] = {0x2A1, 0x2A3, 0x2A5};
+static const u16 gUnknown_08589ADE[] = {0x2A8, 0x2AA, 0x2AC};
+
+void sub_80E1444(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    data[3] = 1;
+
+    switch (data[0])
+    {
+        case 0:
+            sub_80E12E8(taskId, gUnknown_08589ABA, 0);
+            break;
+        case 1:
+            sub_80E12E8(taskId, gUnknown_08589AC0, 0);
+            break;
+        case 2:
+            sub_80E12E8(taskId, gUnknown_08589AC6, 0xC00);
+            break;
+        case 3:
+            sub_80E12E8(taskId, gUnknown_08589ACC, 0);
+            break;
+        case 4:
+            sub_80E12E8(taskId, gUnknown_08589AD2, 0xC00);
+            break;
+        case 5:
+            sub_80E12E8(taskId, gUnknown_08589AD8, 0);
+            break;
+        case 6:
+            sub_80E12E8(taskId, gUnknown_08589ADE, 0);
+            break;
+    }
+
+    data[0] = (data[0] + 1) & 7;
+    if (!data[0])
+    {
+        DrawWholeMapView();
+        data[1] = (data[1] + 1) % 3;
+        data[3] = 0;
+    }
+}
+
+u8 sub_80E150C(u16 var)
+{
+    u8 taskId = CreateTask(sub_80E1444, 0);
+    s16 *data = gTasks[taskId].data;
+
+    PlayerGetDestCoords(&data[4], &data[5]);
+    data[0] = 0;
+    data[1] = 0;
+    data[2] = var;
+    sub_80E1444(taskId);
+    return taskId;
+}
+
+void sub_80E1558(u8 var)
+{
+    sEscalatorAnim_TaskId = sub_80E150C(var);
+}
+
+void sub_80E1570(void)
+{
+    DestroyTask(sEscalatorAnim_TaskId);
+}
+
+bool8 sub_80E1584(void)
+{
+    if (gTasks[sEscalatorAnim_TaskId].data[3] == 0 && gTasks[sEscalatorAnim_TaskId].data[1] == 2)
+        return FALSE;
+    else
+        return TRUE;
+}
diff --git a/src/match_call.c b/src/match_call.c
index 2879881bf..a15700070 100644
--- a/src/match_call.c
+++ b/src/match_call.c
@@ -375,7 +375,7 @@ static const match_call_text_data_t sMayTextScripts[] = {
     { gText_May_Pokenav_2B3AB3, 0xFFFF,              0xFFFF },
     { gText_May_Pokenav_2B3B3F, FLAG_0x4F1,          0xFFFF },
     { gText_May_Pokenav_2B3C13, FLAG_0x095,          0xFFFF },
-    { gText_May_Pokenav_2B3CF3, FLAG_0x324,          0xFFFF },
+    { gText_May_Pokenav_2B3CF3, FLAG_HIDE_MAUVILLE_CITY_WALLY,          0xFFFF },
     { gText_May_Pokenav_2B3D4B, FLAG_0x06A,          0xFFFF },
     { gText_May_Pokenav_2B3DD1, FLAG_0x4F3,          0xFFFF },
     { gText_May_Pokenav_2B3E69, FLAG_0x4F4,          0xFFFF },
@@ -396,7 +396,7 @@ static const match_call_text_data_t sBrendanTextScripts[] = {
     { gText_Brendan_Pokenav_2B43EF, 0xFFFF,              0xFFFF },
     { gText_Brendan_Pokenav_2B4486, FLAG_0x4F1,          0xFFFF },
     { gText_Brendan_Pokenav_2B4560, FLAG_0x095,          0xFFFF },
-    { gText_Brendan_Pokenav_2B463F, FLAG_0x324,          0xFFFF },
+    { gText_Brendan_Pokenav_2B463F, FLAG_HIDE_MAUVILLE_CITY_WALLY,          0xFFFF },
     { gText_Brendan_Pokenav_2B46B7, FLAG_0x06A,          0xFFFF },
     { gText_Brendan_Pokenav_2B4761, FLAG_0x4F3,          0xFFFF },
     { gText_Brendan_Pokenav_2B47F4, FLAG_0x4F4,          0xFFFF },
@@ -425,9 +425,9 @@ static const match_call_text_data_t sWallyTextScripts[] = {
 };
 
 const struct MatchCallSubstruct2 sWallyAdditionalData[] = {
-    { FLAG_0x324, 0x05 },
+    { FLAG_HIDE_MAUVILLE_CITY_WALLY, 0x05 },
     { FLAG_0x06F, 0xD5 },
-    { FLAG_0x35A, 0x46 },
+    { FLAG_HIDE_VICTORY_ROAD_ENTRANCE_WALLY, 0x46 },
     { 0xFFFF,     0xD5 }
 };
 
diff --git a/src/metatile_behavior.c b/src/metatile_behavior.c
index af6a0115d..2bae89ecf 100644
--- a/src/metatile_behavior.c
+++ b/src/metatile_behavior.c
@@ -679,7 +679,7 @@ bool8 MetatileBehavior_IsSecretBasePC(u8 metatileBehavior)
         return FALSE;
 }
 
-bool8 MetatileBehavior_IsSecretBaseRegisterPC(u8 metatileBehavior)
+bool8 MetatileBehavior_IsRecordMixingSecretBasePC(u8 metatileBehavior)
 {
     if (metatileBehavior == MB_SECRET_BASE_REGISTER_PC)
         return TRUE;
@@ -815,7 +815,7 @@ bool8 MetatileBehavior_IsSecretBaseSandOrnament(u8 metatileBehavior)
         return FALSE;
 }
 
-bool8 MetatileBehavior_IsSecretBaseTvOrShield(u8 metatileBehavior)
+bool8 MetatileBehavior_IsSecretBaseShieldOrToyTV(u8 metatileBehavior)
 {
     if (metatileBehavior == MB_SECRET_BASE_TV_SHIELD)
         return TRUE;
@@ -1164,7 +1164,7 @@ bool8 MetatileBehavior_IsRegionMap(u8 metatileBehavior)
         return FALSE;
 }
 
-bool8 MetatileBehavior_IsClosedSootopolisGymDoor(u8 metatileBehavior)
+bool8 MetatileBehavior_IsClosedSootopolisDoor(u8 metatileBehavior)
 {
     if (metatileBehavior == MB_CLOSED_SOOTOPOLIS_DOOR)
         return TRUE;
@@ -1365,7 +1365,7 @@ bool8 MetatileBehavior_IsCuttableGrass(u8 metatileBehavior)
         return FALSE;
 }
 
-bool8 MetatileBehavior_IsRunningShoesInstruction(u8 metatileBehavior)
+bool8 MetatileBehavior_IsRunningShoesManual(u8 metatileBehavior)
 {
     if (metatileBehavior == MB_RUNNING_SHOES_INSTRUCTION)
         return TRUE;
diff --git a/src/overworld.c b/src/overworld.c
index ef0220867..00a3a020f 100644
--- a/src/overworld.c
+++ b/src/overworld.c
@@ -107,7 +107,7 @@ extern void sub_80A0A2C(void);
 extern void not_trainer_hill_battle_pyramid(void);
 extern void apply_map_tileset2_palette(const struct MapLayout *);
 extern void copy_map_tileset2_to_vram_2(const struct MapLayout *);
-extern void prev_quest_postbuffer_cursor_backup_reset(void);
+extern void RestartWildEncounterImmunitySteps(void);
 extern void ShowMapNamePopup(void);
 extern bool32 InTrainerHill(void);
 extern bool32 sub_808651C(void);
@@ -164,10 +164,10 @@ extern bool32 sub_8009F3C(void);
 extern void sub_8010198(void);
 extern u32 sub_800B4DC(void);
 extern bool32 sub_80B39D4(u8);
-extern const u8* sub_809C2C8(struct MapPosition *a1, u8, u8);
-extern u8 *sub_809D0F4(void*);
-extern u8 sub_808BD6C(u8);
-extern u8 sub_808BD7C(u8);
+extern const u8* GetInteractedLinkPlayerScript(struct MapPosition *a1, u8, u8);
+extern u8 *GetCoordEventScriptAtMapPosition(void*);
+extern u8 GetFRLGAvatarGraphicsIdByGender(u8);
+extern u8 GetRSAvatarGraphicsIdByGender(u8);
 extern void UpdateEventObjectSpriteVisibility(struct Sprite*, u8);
 
 // this file's functions
@@ -827,7 +827,7 @@ void mliX_load_map(u8 mapGroup, u8 mapNum)
     TrySetMapSaveWarpStatus();
     ClearTempFieldEventData();
     ResetCyclingRoadChallengeData();
-    prev_quest_postbuffer_cursor_backup_reset();
+    RestartWildEncounterImmunitySteps();
     TryUpdateRandomTrainerRematches(mapGroup, mapNum);
     DoTimeBasedEvents();
     SetSav1WeatherFromCurrMapHeader();
@@ -876,7 +876,7 @@ static void mli0_load_map(u32 a1)
     TrySetMapSaveWarpStatus();
     ClearTempFieldEventData();
     ResetCyclingRoadChallengeData();
-    prev_quest_postbuffer_cursor_backup_reset();
+    RestartWildEncounterImmunitySteps();
     TryUpdateRandomTrainerRematches(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum);
     if (a1 != 1)
         DoTimeBasedEvents();
@@ -2706,7 +2706,7 @@ static u8 *sub_8087370(struct UnkStruct_8054FF8 *a1)
 {
     if (a1->c != 2)
         return 0;
-    return sub_809D0F4(&a1->sub);
+    return GetCoordEventScriptAtMapPosition(&a1->sub);
 }
 
 static bool32 sub_8087388(struct UnkStruct_8054FF8 *a1)
@@ -2747,7 +2747,7 @@ static const u8 *sub_80873B4(struct UnkStruct_8054FF8 *a1)
             return EventScript_TradeRoom_ReadTrainerCard2;
     }
 
-    return sub_809C2C8(&unkStruct, a1->field_C, a1->d);
+    return GetInteractedLinkPlayerScript(&unkStruct, a1->field_C, a1->d);
 }
 
 static u16 sub_8087480(const u8 *script)
@@ -3137,11 +3137,11 @@ static void CreateLinkPlayerSprite(u8 linkPlayerId, u8 gameVersion)
         {
         case VERSION_FIRE_RED:
         case VERSION_LEAF_GREEN:
-            eventObj->spriteId = AddPseudoEventObject(sub_808BD6C(eventObj->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0);
+            eventObj->spriteId = AddPseudoEventObject(GetFRLGAvatarGraphicsIdByGender(eventObj->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0);
             break;
         case VERSION_RUBY:
         case VERSION_SAPPHIRE:
-            eventObj->spriteId = AddPseudoEventObject(sub_808BD7C(eventObj->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0);
+            eventObj->spriteId = AddPseudoEventObject(GetRSAvatarGraphicsIdByGender(eventObj->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0);
             break;
         case VERSION_EMERALD:
             eventObj->spriteId = AddPseudoEventObject(GetRivalAvatarGraphicsIdByStateIdAndGender(0, eventObj->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0);
diff --git a/src/pokemon.c b/src/pokemon.c
index 40f7e94b2..7227d28cb 100644
--- a/src/pokemon.c
+++ b/src/pokemon.c
@@ -3251,7 +3251,7 @@ u8 GetLevelFromMonExp(struct Pokemon *mon)
     u32 exp = GetMonData(mon, MON_DATA_EXP, NULL);
     s32 level = 1;
 
-    while (level <= MAX_MON_LEVEL && gExperienceTables[gBaseStats[species].growthRate][level] <= exp)
+    while (level <= MAX_LEVEL && gExperienceTables[gBaseStats[species].growthRate][level] <= exp)
         level++;
 
     return level - 1;
@@ -3263,7 +3263,7 @@ u8 GetLevelFromBoxMonExp(struct BoxPokemon *boxMon)
     u32 exp = GetBoxMonData(boxMon, MON_DATA_EXP, NULL);
     s32 level = 1;
 
-    while (level <= MAX_MON_LEVEL && gExperienceTables[gBaseStats[species].growthRate][level] <= exp)
+    while (level <= MAX_LEVEL && gExperienceTables[gBaseStats[species].growthRate][level] <= exp)
         level++;
 
     return level - 1;
@@ -5145,7 +5145,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
                 retVal = FALSE;
             }
             if ((itemEffect[cmdIndex] & 0x40)  // raise level
-             && GetMonData(mon, MON_DATA_LEVEL, NULL) != MAX_MON_LEVEL)
+             && GetMonData(mon, MON_DATA_LEVEL, NULL) != MAX_LEVEL)
             {
                 dataUnsigned = gExperienceTables[gBaseStats[GetMonData(mon, MON_DATA_SPECIES, NULL)].growthRate][GetMonData(mon, MON_DATA_LEVEL, NULL) + 1];
                 SetMonData(mon, MON_DATA_EXP, &dataUnsigned);
@@ -6430,12 +6430,12 @@ bool8 TryIncrementMonLevel(struct Pokemon *mon)
     u16 species = GetMonData(mon, MON_DATA_SPECIES, 0);
     u8 nextLevel = GetMonData(mon, MON_DATA_LEVEL, 0) + 1;
     u32 expPoints = GetMonData(mon, MON_DATA_EXP, 0);
-    if (expPoints > gExperienceTables[gBaseStats[species].growthRate][MAX_MON_LEVEL])
+    if (expPoints > gExperienceTables[gBaseStats[species].growthRate][MAX_LEVEL])
     {
-        expPoints = gExperienceTables[gBaseStats[species].growthRate][MAX_MON_LEVEL];
+        expPoints = gExperienceTables[gBaseStats[species].growthRate][MAX_LEVEL];
         SetMonData(mon, MON_DATA_EXP, &expPoints);
     }
-    if (nextLevel > MAX_MON_LEVEL || expPoints < gExperienceTables[gBaseStats[species].growthRate][nextLevel])
+    if (nextLevel > MAX_LEVEL || expPoints < gExperienceTables[gBaseStats[species].growthRate][nextLevel])
     {
         return FALSE;
     }
diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c
index df596749e..db2a07909 100644
--- a/src/pokemon_summary_screen.c
+++ b/src/pokemon_summary_screen.c
@@ -2533,7 +2533,7 @@ static void DrawExperienceProgressBar(struct Pokemon *unused)
     u16 *r9;
     u8 i;
 
-    if (summary->level < MAX_MON_LEVEL)
+    if (summary->level < MAX_LEVEL)
     {
         u32 expBetweenLevels = gExperienceTables[gBaseStats[summary->species].growthRate][summary->level + 1] - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level];
         u32 expSinceLastLevel = summary->exp - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level];
@@ -3349,7 +3349,7 @@ static void PrintExpPointsNextLevel(void)
     offset = GetStringRightAlignXOffset(1, gStringVar1, 42) + 2;
     SummaryScreen_PrintTextOnWindow(windowId, gStringVar1, offset, 1, 0, 0);
 
-    if (sum->level < MAX_MON_LEVEL)
+    if (sum->level < MAX_LEVEL)
         expToNextLevel = gExperienceTables[gBaseStats[sum->species].growthRate][sum->level + 1] - sum->exp;
     else
         expToNextLevel = 0;
diff --git a/src/rom_8011DC0.c b/src/rom_8011DC0.c
index dc94cb9d5..bf16a20fc 100644
--- a/src/rom_8011DC0.c
+++ b/src/rom_8011DC0.c
@@ -1646,7 +1646,7 @@ void sub_8014304(s8 mapGroup, s8 mapNum, s32 x, s32 y, u16 arg4)
     VarSet(VAR_0x4087, arg4);
     gFieldLinkPlayerCount = GetLinkPlayerCount();
     gUnknown_03005DB4 = GetMultiplayerId();
-    sub_809D2BC();
+    SetCableClubWarp();
     Overworld_SetWarpDestination(mapGroup, mapNum, -1, x, y);
     WarpIntoMap();
 }
diff --git a/src/scrcmd.c b/src/scrcmd.c
index acaf78576..fa3e21996 100644
--- a/src/scrcmd.c
+++ b/src/scrcmd.c
@@ -52,7 +52,7 @@
 typedef u16 (*SpecialFunc)(void);
 typedef void (*NativeFunc)(void);
 
-extern u32 gUnknown_020375C0;
+extern const u8 *gUnknown_020375C0;
 
 static EWRAM_DATA u32 gUnknown_020375C4 = 0;
 static EWRAM_DATA u16 sPauseCounter = 0;
@@ -284,7 +284,7 @@ bool8 ScrCmd_callstd_if(struct ScriptContext *ctx)
 
 bool8 ScrCmd_gotoram(struct ScriptContext *ctx)
 {
-    ScriptJump(ctx, (const u8 *)gUnknown_020375C0);
+    ScriptJump(ctx, gUnknown_020375C0);
     return FALSE;
 }
 
@@ -2223,7 +2223,7 @@ bool8 ScrCmd_cmdCF(struct ScriptContext *ctx)
 
     if (v1)
     {
-        ((u8*)gUnknown_020375C0) = ctx->scriptPtr;
+        gUnknown_020375C0 = ctx->scriptPtr;
         ScriptJump(ctx, v1);
     }
     return FALSE;
diff --git a/src/script.c b/src/script.c
index 8c868128b..c61ae7183 100644
--- a/src/script.c
+++ b/src/script.c
@@ -5,7 +5,7 @@
 
 #define RAM_SCRIPT_MAGIC 51
 
-extern u8* gUnknown_020375C0;
+extern const u8* gUnknown_020375C0;
 
 extern bool32 sub_801B27C(void);
 
@@ -344,7 +344,7 @@ void ClearRamScript(void)
     CpuFill32(0, &gSaveBlock1Ptr->ramScript, sizeof(struct RamScript));
 }
 
-bool8 InitRamScript(u8 *script, u16 scriptSize, u8 mapGroup, u8 mapNum, u8 objectId)
+bool8 InitRamScript(const u8 *script, u16 scriptSize, u8 mapGroup, u8 mapNum, u8 objectId)
 {
     struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data;
 
@@ -362,7 +362,7 @@ bool8 InitRamScript(u8 *script, u16 scriptSize, u8 mapGroup, u8 mapNum, u8 objec
     return TRUE;
 }
 
-u8 *GetRamScript(u8 objectId, u8 *script)
+const u8 *GetRamScript(u8 objectId, const u8 *script)
 {
     struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data;
     gUnknown_020375C0 = NULL;
diff --git a/src/secret_base.c b/src/secret_base.c
index 441bdef04..a684f3982 100644
--- a/src/secret_base.c
+++ b/src/secret_base.c
@@ -596,13 +596,13 @@ void sub_80E95D4(void)
     VarSet(VAR_OBJ_GFX_ID_F, gUnknown_0858D060[sub_80EA20C(VarGet(VAR_0x4054))]);
 }
 
-void sub_80E9608(struct Coords16 *coords, struct MapEvents *events)
+void sub_80E9608(const struct MapPosition *position, const struct MapEvents *events)
 {
     s16 bgEventIdx;
 
     for (bgEventIdx = 0; bgEventIdx < events->bgEventCount; bgEventIdx ++)
     {
-        if (events->bgEvents[bgEventIdx].kind == BG_EVENT_SECRET_BASE && coords->x == events->bgEvents[bgEventIdx].x + 7 && coords->y == events->bgEvents[bgEventIdx].y + 7)
+        if (events->bgEvents[bgEventIdx].kind == BG_EVENT_SECRET_BASE && position->x == events->bgEvents[bgEventIdx].x + 7 && position->y == events->bgEvents[bgEventIdx].y + 7)
         {
             sCurSecretBaseId = events->bgEvents[bgEventIdx].bgUnion.secretBaseId;
             break;
@@ -610,9 +610,9 @@ void sub_80E9608(struct Coords16 *coords, struct MapEvents *events)
     }
 }
 
-void sub_80E9668(struct Coords16 *coords, struct MapEvents *events)
+void sub_80E9668(const struct MapPosition *position, const struct MapEvents *events)
 {
-    sub_80E9608(coords, events);
+    sub_80E9608(position, events);
     sub_80E8B6C();
     ScriptContext1_SetupScript(EventScript_275BB7);
 }
diff --git a/src/shop.c b/src/shop.c
index 26151171a..510c9f4f7 100755
--- a/src/shop.c
+++ b/src/shop.c
@@ -1,15 +1,20 @@
 #include "global.h"
 #include "bg.h"
+#include "data2.h"
 #include "decompress.h"
 #include "decoration.h"
+#include "decoration_inventory.h"
+#include "event_object_movement.h"
 #include "field_player_avatar.h"
 #include "field_screen.h"
 #include "field_weather.h"
 #include "fieldmap.h"
 #include "gpu_regs.h"
+#include "graphics.h"
 #include "international_string_util.h"
 #include "item.h"
 #include "item_icon.h"
+#include "item_menu.h"
 #include "list_menu.h"
 #include "main.h"
 #include "malloc.h"
@@ -18,6 +23,7 @@
 #include "money.h"
 #include "overworld.h"
 #include "palette.h"
+#include "party_menu.h"
 #include "scanline_effect.h"
 #include "script.h"
 #include "shop.h"
@@ -27,54 +33,243 @@
 #include "strings.h"
 #include "text_window.h"
 #include "tv.h"
+#include "constants/items.h"
+#include "constants/metatile_behaviors.h"
 #include "constants/rgb.h"
 #include "constants/songs.h"
 
-extern struct ShopData *gShopDataPtr;
-extern struct ListMenuItem *gUnknown_02039F74;
-extern u8 (*gUnknown_02039F78)[16];
-extern struct MartInfo gMartInfo;
-
-extern const struct WindowTemplate gUnknown_08589A38[2];
-extern const struct MenuAction gUnknown_08589A10[3];
-extern const struct MenuAction gUnknown_08589A28[2];
-extern const struct ListMenuTemplate gUnknown_08589A48;
-extern const struct BgTemplate gUnknown_08589A60[4];
-extern const u8 gBuyMenuFrame_Gfx[];
-extern const u8 gBuyMenuFrame_Tilemap[];
-extern const u16 gMenuMoneyPal[];
-extern const struct WindowTemplate gUnknown_08589A70[];
-extern u8 gUnknown_08589AB0[][3];
+EWRAM_DATA struct MartInfo gMartInfo = {0};
+EWRAM_DATA struct ShopData *gShopDataPtr = NULL;
+EWRAM_DATA struct ListMenuItem *gUnknown_02039F74 = NULL;
+EWRAM_DATA u8 (*gUnknown_02039F78)[16] = {0};
+EWRAM_DATA u8 gMartPurchaseHistoryId = 0;
+EWRAM_DATA struct ItemSlot gMartPurchaseHistory[3] = {0};
 
 static void Task_ShopMenu(u8 taskId);
-void HandleShopMenuQuit(u8 taskId);
-void CB2_InitBuyMenu(void);
+static void Task_HandleShopMenuQuit(u8 taskId);
+static void CB2_InitBuyMenu(void);
 static void Task_GoToBuyOrSellMenu(u8 taskId);
-void CB2_GoToSellMenu(void);
-void MapPostLoadHook_ExitBuyOrSellMenu(void);
-void Task_ExitSellMenu(u8 taskId);
-void ReturnToShopMenuAfterExitingSellMenu(u8 taskId);
-void BuyMenuDrawGraphics(void);
-void BuyMenuAddScrollIndicatorArrows(void);
-void Task_BuyMenu(u8 taskId);
-void BuyMenuBuildListMenuTemplate(void);
-void BuyMenuInitBgs(void);
-void BuyMenuInitWindows(void);
-void BuyMenuDecompressBgGraphics(void);
-void BuyMenuSetListEntry(struct ListMenuItem*, u16, u8*);
-void BuyMenuAddItemIcon(u16, u8);
-void BuyMenuRemoveItemIcon(u16, u8);
-void BuyMenuPrint(u8 windowId, const u8 *text, u8 x, u8 y, s8 speed, u8 colorSet);
-void BuyMenuDrawMapGraphics(void);
-void BuyMenuCopyMenuBgToBg1TilemapBuffer(void);
-void BuyMenuCollectEventObjectData(void);
-void BuyMenuDrawEventObjects(void);
-void BuyMenuDrawMapBg(void);
-bool8 BuyMenuCheckForOverlapWithMenuBg(u16, u16);
-void BuyMenuDrawMapMetatile(s16, s16, u16*, u8);
-
-
-/*static*/ u8 CreateShopMenu(u8 martType)
+static void MapPostLoadHook_ReturnToShopMenu(void);
+static void Task_ReturnToShopMenu(u8 taskId);
+static void ShowShopMenuAfterExitingBuyOrSellMenu(u8 taskId);
+static void BuyMenuDrawGraphics(void);
+static void BuyMenuAddScrollIndicatorArrows(void);
+static void Task_BuyMenu(u8 taskId);
+static void BuyMenuBuildListMenuTemplate(void);
+static void BuyMenuInitBgs(void);
+static void BuyMenuInitWindows(void);
+static void BuyMenuDecompressBgGraphics(void);
+static void BuyMenuSetListEntry(struct ListMenuItem*, u16, u8*);
+static void BuyMenuAddItemIcon(u16, u8);
+static void BuyMenuRemoveItemIcon(u16, u8);
+static void BuyMenuPrint(u8 windowId, const u8 *text, u8 x, u8 y, s8 speed, u8 colorSet);
+static void BuyMenuDrawMapGraphics(void);
+static void BuyMenuCopyMenuBgToBg1TilemapBuffer(void);
+static void BuyMenuCollectEventObjectData(void);
+static void BuyMenuDrawEventObjects(void);
+static void BuyMenuDrawMapBg(void);
+static bool8 BuyMenuCheckForOverlapWithMenuBg(int, int);
+static void BuyMenuDrawMapMetatile(s16, s16, const u16*, u8);
+static void BuyMenuDrawMapMetatileLayer(u16 *dest, s16 offset1, s16 offset2, const u16 *src);
+static bool8 BuyMenuCheckIfEventObjectOverlapsMenuBg(s16 *);
+static void ExitBuyMenu(u8 taskId);
+static void Task_ExitBuyMenu(u8 taskId);
+static void BuyMenuTryMakePurchase(u8 taskId);
+static void BuyMenuReturnToItemList(u8 taskId);
+static void Task_BuyHowManyDialogueInit(u8 taskId);
+static void BuyMenuConfirmPurchase(u8 taskId);
+static void BuyMenuPrintItemQuantityAndPrice(u8 taskId);
+static void Task_BuyHowManyDialogueHandleInput(u8 taskId);
+static void BuyMenuSubtractMoney(u8 taskId);
+static void RecordItemPurchase(u8 taskId);
+static void Task_ReturnToItemListAfterItemPurchase(u8 taskId);
+static void Task_ReturnToItemListAfterDecorationPurchase(u8 taskId);
+static void Task_HandleShopMenuBuy(u8 taskId);
+static void Task_HandleShopMenuSell(u8 taskId);
+static void BuyMenuPrintItemDescriptionAndShowItemIcon(int item, bool8 onInit, struct ListMenu *list);
+static void BuyMenuPrintPriceInList(u8 windowId, int item, u8 y);
+
+static const struct YesNoFuncTable sShopPurchaseYesNoFuncs =
+{
+    BuyMenuTryMakePurchase,
+    BuyMenuReturnToItemList
+};
+
+static const struct MenuAction sShopMenuActions_BuySellQuit[] = 
+{
+    { gText_ShopBuy, {.void_u8=Task_HandleShopMenuBuy} },
+    { gText_ShopSell, {.void_u8=Task_HandleShopMenuSell} },
+    { gText_ShopQuit, {.void_u8=Task_HandleShopMenuQuit} }
+};
+
+static const struct MenuAction sShopMenuActions_BuyQuit[] = 
+{
+    { gText_ShopBuy, {.void_u8=Task_HandleShopMenuBuy} },
+    { gText_ShopQuit, {.void_u8=Task_HandleShopMenuQuit} }
+};
+
+static const struct WindowTemplate sShopMenuWindowTemplates[] =
+{
+    {
+        .priority = 0,
+        .tilemapLeft = 2,
+        .tilemapTop = 1,
+        .width = 9,
+        .height = 6,
+        .paletteNum = 15,
+        .baseBlock = 0x0008,
+    },
+    {
+        .priority = 0,
+        .tilemapLeft = 2,
+        .tilemapTop = 1,
+        .width = 9,
+        .height = 4,
+        .paletteNum = 15,
+        .baseBlock = 0x0008,
+    }
+};
+
+static const struct ListMenuTemplate sShopBuyMenuListTemplate =
+{
+    .items = NULL,
+    .moveCursorFunc = BuyMenuPrintItemDescriptionAndShowItemIcon,
+    .itemPrintFunc = BuyMenuPrintPriceInList,
+    .totalItems = 0,
+    .maxShowed = 0,
+    .windowId = 1,
+    .header_X = 0,
+    .item_X = 8,
+    .cursor_X = 0,
+    .upText_Y = 1,
+    .cursorPal = 2,
+    .fillValue = 0,
+    .cursorShadowPal = 3,
+    .lettersSpacing = 0,
+    .itemVerticalPadding = 0,
+    .scrollMultiple = LIST_NO_MULTIPLE_SCROLL,
+    .fontId = 7,
+    .cursorKind = 0
+};
+
+static const struct BgTemplate sShopBuyMenuBgTemplates[] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0
+    },
+    {
+        .bg = 1,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0
+    },
+    {
+        .bg = 2,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 29,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0
+    },
+    {
+        .bg = 3,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 28,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0
+    }
+};
+
+static const struct WindowTemplate sShopBuyMenuWindowTemplates[] =
+{
+    {
+        .priority = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 1,
+        .width = 10,
+        .height = 2,
+        .paletteNum = 15,
+        .baseBlock = 0x001E,
+    },
+    {
+        .priority = 0,
+        .tilemapLeft = 14,
+        .tilemapTop = 2,
+        .width = 15,
+        .height = 16,
+        .paletteNum = 15,
+        .baseBlock = 0x0032,
+    },
+    {
+        .priority = 0,
+        .tilemapLeft = 0,
+        .tilemapTop = 13,
+        .width = 14,
+        .height = 6,
+        .paletteNum = 15,
+        .baseBlock = 0x0122,
+    },
+    {
+        .priority = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 11,
+        .width = 12,
+        .height = 2,
+        .paletteNum = 15,
+        .baseBlock = 0x0176,
+    },
+    {
+        .priority = 0,
+        .tilemapLeft = 18,
+        .tilemapTop = 11,
+        .width = 10,
+        .height = 2,
+        .paletteNum = 15,
+        .baseBlock = 0x018E,
+    },
+    {
+        .priority = 0,
+        .tilemapLeft = 2,
+        .tilemapTop = 15,
+        .width = 27,
+        .height = 4,
+        .paletteNum = 15,
+        .baseBlock = 0x01A2,
+    },
+    DUMMY_WIN_TEMPLATE
+};
+
+static const struct WindowTemplate sShopBuyMenuYesNoWindowTemplates = 
+{
+    .priority = 0,
+    .tilemapLeft = 21,
+    .tilemapTop = 9,
+    .width = 5,
+    .height = 4,
+    .paletteNum = 15,
+    .baseBlock = 0x020E,
+};
+
+static const u8 sShopBuyMenuTextColors[][3] =
+{
+    {1, 2, 3},
+    {0, 2, 3},
+    {0, 3, 2}
+};
+
+static u8 CreateShopMenu(u8 martType)
 {
     int numMenuItems;
 
@@ -84,20 +279,20 @@ void BuyMenuDrawMapMetatile(s16, s16, u16*, u8);
     if (martType == MART_TYPE_0)
     {
         struct WindowTemplate winTemplate;
-        winTemplate = gUnknown_08589A38[0];
-        winTemplate.width = GetMaxWidthInMenuTable(gUnknown_08589A10, ARRAY_COUNT(gUnknown_08589A10));
+        winTemplate = sShopMenuWindowTemplates[0];
+        winTemplate.width = GetMaxWidthInMenuTable(sShopMenuActions_BuySellQuit, ARRAY_COUNT(sShopMenuActions_BuySellQuit));
         gMartInfo.windowId = AddWindow(&winTemplate);
-        gMartInfo.menuActions = gUnknown_08589A10;
-        numMenuItems = ARRAY_COUNT(gUnknown_08589A10);
+        gMartInfo.menuActions = sShopMenuActions_BuySellQuit;
+        numMenuItems = ARRAY_COUNT(sShopMenuActions_BuySellQuit);
     }
     else
     {
         struct WindowTemplate winTemplate;
-        winTemplate = gUnknown_08589A38[1];
-        winTemplate.width = GetMaxWidthInMenuTable(gUnknown_08589A28, ARRAY_COUNT(gUnknown_08589A28));
+        winTemplate = sShopMenuWindowTemplates[1];
+        winTemplate.width = GetMaxWidthInMenuTable(sShopMenuActions_BuyQuit, ARRAY_COUNT(sShopMenuActions_BuyQuit));
         gMartInfo.windowId = AddWindow(&winTemplate);
-        gMartInfo.menuActions = gUnknown_08589A28;
-        numMenuItems = ARRAY_COUNT(gUnknown_08589A28);
+        gMartInfo.menuActions = sShopMenuActions_BuyQuit;
+        numMenuItems = ARRAY_COUNT(sShopMenuActions_BuyQuit);
     }
 
     SetStandardWindowBorderStyle(gMartInfo.windowId, 0);
@@ -109,12 +304,12 @@ void BuyMenuDrawMapMetatile(s16, s16, u16*, u8);
     return CreateTask(Task_ShopMenu, 8);
 }
 
-/*static*/ void SetShopMenuCallback(void (* callback)(void))
+static void SetShopMenuCallback(void (* callback)(void))
 {
     gMartInfo.callback = callback;
 }
 
-/*static*/ void SetShopItemsForSale(const u16 *items)
+static void SetShopItemsForSale(const u16 *items)
 {
     u16 i = 0;
 
@@ -133,11 +328,11 @@ static void Task_ShopMenu(u8 taskId)
     s8 inputCode = Menu_ProcessInputNoWrapAround();
     switch (inputCode)
     {
-    case -2:
+    case LIST_B_PRESSED:
         break;
-    case -1:
+    case LIST_NOTHING_CHOSEN:
         PlaySE(SE_SELECT);
-        HandleShopMenuQuit(taskId);
+        Task_HandleShopMenuQuit(taskId);
         break;
     default:
         gMartInfo.menuActions[inputCode].func.void_u8(taskId);
@@ -145,31 +340,31 @@ static void Task_ShopMenu(u8 taskId)
     }
 }
 
-void HandleShopMenuBuy(u8 taskId)
+static void Task_HandleShopMenuBuy(u8 taskId)
 {
-    s16 *taskData = gTasks[taskId].data;
-    taskData[8] = (u32)CB2_InitBuyMenu >> 16;
-    taskData[9] = (u32)CB2_InitBuyMenu;
+    s16 *data = gTasks[taskId].data;
+    data[8] = (u32)CB2_InitBuyMenu >> 16;
+    data[9] = (u32)CB2_InitBuyMenu;
     gTasks[taskId].func = Task_GoToBuyOrSellMenu;
     FadeScreen(1, 0);
 }
 
-void HandleShopMenuSell(u8 taskId)
+static void Task_HandleShopMenuSell(u8 taskId)
 {
-    s16 *taskData = gTasks[taskId].data;
-    taskData[8] = (u32)CB2_GoToSellMenu >> 16;
-    taskData[9] = (u32)CB2_GoToSellMenu;
+    s16 *data = gTasks[taskId].data;
+    data[8] = (u32)CB2_GoToSellMenu >> 16;
+    data[9] = (u32)CB2_GoToSellMenu;
     gTasks[taskId].func = Task_GoToBuyOrSellMenu;
     FadeScreen(1, 0);
 }
 
 void CB2_ExitSellMenu(void)
 {
-    gFieldCallback = MapPostLoadHook_ExitBuyOrSellMenu;
+    gFieldCallback = MapPostLoadHook_ReturnToShopMenu;
     SetMainCallback2(CB2_ReturnToField);
 }
 
-/*static*/ void HandleShopMenuQuit(u8 taskId)
+static void Task_HandleShopMenuQuit(u8 taskId)
 {
     sub_8198070(gMartInfo.windowId, 2);
     RemoveWindow(gMartInfo.windowId);
@@ -183,38 +378,38 @@ void CB2_ExitSellMenu(void)
 
 static void Task_GoToBuyOrSellMenu(u8 taskId)
 {
-    s16 *taskData = gTasks[taskId].data;
+    s16 *data = gTasks[taskId].data;
     if (!gPaletteFade.active)
     {
         DestroyTask(taskId);
-        SetMainCallback2((void *)((u16)taskData[8] << 16 | (u16)taskData[9]));
+        SetMainCallback2((void *)((u16)data[8] << 16 | (u16)data[9]));
     }
 }
 
-void MapPostLoadHook_ExitBuyOrSellMenu(void)
+static void MapPostLoadHook_ReturnToShopMenu(void)
 {
     pal_fill_black();
-    CreateTask(Task_ExitSellMenu, 8);
+    CreateTask(Task_ReturnToShopMenu, 8);
 }
 
-void Task_ExitSellMenu(u8 taskId)
+static void Task_ReturnToShopMenu(u8 taskId)
 {
     if (IsWeatherNotFadingIn() == TRUE)
     {
         if (gMartInfo.martType == MART_TYPE_2)
-            DisplayItemMessageOnField(taskId, gText_CanIHelpWithAnythingElse, ReturnToShopMenuAfterExitingSellMenu);
+            DisplayItemMessageOnField(taskId, gText_CanIHelpWithAnythingElse, ShowShopMenuAfterExitingBuyOrSellMenu);
         else
-            DisplayItemMessageOnField(taskId, gText_AnythingElseICanHelp, ReturnToShopMenuAfterExitingSellMenu);
+            DisplayItemMessageOnField(taskId, gText_AnythingElseICanHelp, ShowShopMenuAfterExitingBuyOrSellMenu);
     }
 }
 
-void ReturnToShopMenuAfterExitingSellMenu(u8 taskId)
+static void ShowShopMenuAfterExitingBuyOrSellMenu(u8 taskId)
 {
     CreateShopMenu(gMartInfo.martType);
     DestroyTask(taskId);
 }
 
-void CB2_BuyMenu(void)
+static void CB2_BuyMenu(void)
 {
     RunTasks();
     AnimateSprites();
@@ -223,14 +418,18 @@ void CB2_BuyMenu(void)
     UpdatePaletteFade();
 }
 
-void VBlankCB_BuyMenu(void)
+static void VBlankCB_BuyMenu(void)
 {
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
 }
 
-void CB2_InitBuyMenu(void)
+#define tItemCount data[1]
+#define tItemId data[5]
+#define tListTaskId data[7]
+
+static void CB2_InitBuyMenu(void)
 {
     u8 taskId;
 
@@ -248,8 +447,8 @@ void CB2_InitBuyMenu(void)
         clear_scheduled_bg_copies_to_vram();
         gShopDataPtr = AllocZeroed(sizeof(struct ShopData));
         gShopDataPtr->scrollIndicatorsTaskId = 0xFF;
-        gShopDataPtr->unk200D[0] = -1;
-        gShopDataPtr->unk200D[1] = -1;
+        gShopDataPtr->itemSpriteIds[0] = -1;
+        gShopDataPtr->itemSpriteIds[1] = -1;
         BuyMenuBuildListMenuTemplate();
         BuyMenuInitBgs();
         FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
@@ -268,7 +467,7 @@ void CB2_InitBuyMenu(void)
         BuyMenuDrawGraphics();
         BuyMenuAddScrollIndicatorArrows();
         taskId = CreateTask(Task_BuyMenu, 8);
-        gTasks[taskId].data[7] = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
+        gTasks[taskId].tListTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
         BlendPalettes(0xFFFFFFFF, 0x10, RGB_BLACK);
         BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, RGB_BLACK);
         SetVBlankCallback(VBlankCB_BuyMenu);
@@ -277,7 +476,7 @@ void CB2_InitBuyMenu(void)
     }
 }
 
-void BuyMenuFreeMemory(void)
+static void BuyMenuFreeMemory(void)
 {
     Free(gShopDataPtr);
     Free(gUnknown_02039F74);
@@ -285,7 +484,7 @@ void BuyMenuFreeMemory(void)
     FreeAllWindowBuffers();
 }
 
-void BuyMenuBuildListMenuTemplate(void)
+static void BuyMenuBuildListMenuTemplate(void)
 {
     u16 i;
     u16 itemCount;
@@ -299,7 +498,7 @@ void BuyMenuBuildListMenuTemplate(void)
     gUnknown_02039F74[i].name = gUnknown_02039F78[i];
     gUnknown_02039F74[i].id = -2;
 
-    gMultiuseListMenuTemplate = gUnknown_08589A48;
+    gMultiuseListMenuTemplate = sShopBuyMenuListTemplate;
     gMultiuseListMenuTemplate.items = gUnknown_02039F74;
     gMultiuseListMenuTemplate.totalItems = gMartInfo.itemCount + 1;
     if (gMultiuseListMenuTemplate.totalItems > 8)
@@ -307,10 +506,10 @@ void BuyMenuBuildListMenuTemplate(void)
     else
         gMultiuseListMenuTemplate.maxShowed = gMultiuseListMenuTemplate.totalItems;
 
-    gShopDataPtr->unk2004 = gMultiuseListMenuTemplate.maxShowed;
+    gShopDataPtr->itemsShowed = gMultiuseListMenuTemplate.maxShowed;
 }
 
-void BuyMenuSetListEntry(struct ListMenuItem *menuItem, u16 item, u8 *name)
+static void BuyMenuSetListEntry(struct ListMenuItem *menuItem, u16 item, u8 *name)
 {
     if (gMartInfo.martType == MART_TYPE_0)
         CopyItemName(item, name);
@@ -321,19 +520,19 @@ void BuyMenuSetListEntry(struct ListMenuItem *menuItem, u16 item, u8 *name)
     menuItem->id = item;
 }
 
-void BuyMenuPrintItemDescriptionAndShowItemIcon(int item, bool8 onInit, struct ListMenu *list)
+static void BuyMenuPrintItemDescriptionAndShowItemIcon(int item, bool8 onInit, struct ListMenu *list)
 {
     const u8 *description;
     if (onInit != TRUE)
         PlaySE(SE_SELECT);
 
     if (item != -2)
-        BuyMenuAddItemIcon(item, gShopDataPtr->unk200C);
+        BuyMenuAddItemIcon(item, gShopDataPtr->iconSlot);
     else
-        BuyMenuAddItemIcon(-1, gShopDataPtr->unk200C);
+        BuyMenuAddItemIcon(-1, gShopDataPtr->iconSlot);
 
-    BuyMenuRemoveItemIcon(item, gShopDataPtr->unk200C ^ 1);
-    gShopDataPtr->unk200C ^= 1;
+    BuyMenuRemoveItemIcon(item, gShopDataPtr->iconSlot ^ 1);
+    gShopDataPtr->iconSlot ^= 1;
     if (item != -2)
     {
         if (gMartInfo.martType == MART_TYPE_0)
@@ -350,7 +549,7 @@ void BuyMenuPrintItemDescriptionAndShowItemIcon(int item, bool8 onInit, struct L
     BuyMenuPrint(2, description, 3, 1, 0, 0);
 }
 
-void BuyMenuPrintPriceInList(u8 windowId, int item, u8 y)
+static void BuyMenuPrintPriceInList(u8 windowId, int item, u8 y)
 {
     u8 x;
 
@@ -375,11 +574,11 @@ void BuyMenuPrintPriceInList(u8 windowId, int item, u8 y)
 
         StringExpandPlaceholders(gStringVar4, gText_PokedollarVar1);
         x = GetStringRightAlignXOffset(7, gStringVar4, 0x78);
-        AddTextPrinterParameterized4(windowId, 7, x, y, 0, 0, gUnknown_08589AB0[1], -1, gStringVar4);
+        AddTextPrinterParameterized4(windowId, 7, x, y, 0, 0, sShopBuyMenuTextColors[1], -1, gStringVar4);
     }
 }
 
-void BuyMenuAddScrollIndicatorArrows(void)
+static void BuyMenuAddScrollIndicatorArrows(void)
 {
     if (gShopDataPtr->scrollIndicatorsTaskId == 0xFF && gMartInfo.itemCount + 1 > 8)
     {
@@ -389,13 +588,13 @@ void BuyMenuAddScrollIndicatorArrows(void)
             0xC,
             0x94,
             gMartInfo.itemCount - 7,
-            0x834,
-            0x834,
-            &gShopDataPtr->unk2008);
+            2100,
+            2100,
+            &gShopDataPtr->scrollOffset);
     }
 }
 
-void BuyMenuRemoveScrollIndicatorArrows(void)
+static void BuyMenuRemoveScrollIndicatorArrows(void)
 {
     if (gShopDataPtr->scrollIndicatorsTaskId != 0xFF)
     {
@@ -404,22 +603,22 @@ void BuyMenuRemoveScrollIndicatorArrows(void)
     }
 }
 
-void BuyMenuPrintCursor(u8 scrollIndicatorsTaskId, u8 colorSet)
+static void BuyMenuPrintCursor(u8 scrollIndicatorsTaskId, u8 colorSet)
 {
     u8 y = ListMenuGetYCoordForPrintingArrowCursor(scrollIndicatorsTaskId);
     BuyMenuPrint(1, gText_SelectorArrow2, 0, y, 0, colorSet);
 }
 
-void BuyMenuAddItemIcon(u16 item, u8 iconSlot)
+static void BuyMenuAddItemIcon(u16 item, u8 iconSlot)
 {
     u8 spriteId;
-    u8 *spriteIdPtr = &gShopDataPtr->unk200D[iconSlot];
+    u8 *spriteIdPtr = &gShopDataPtr->itemSpriteIds[iconSlot];
     if (*spriteIdPtr != 0xFF)
         return;
 
     if (gMartInfo.martType == MART_TYPE_0 || item == 0xFFFF)
     {
-        spriteId = AddItemIconSprite(iconSlot + 0x83E, iconSlot + 0x83E, item);
+        spriteId = AddItemIconSprite(iconSlot + 2110, iconSlot + 2110, item);
         if (spriteId != MAX_SPRITES)
         {
             *spriteIdPtr = spriteId;
@@ -429,28 +628,28 @@ void BuyMenuAddItemIcon(u16 item, u8 iconSlot)
     }
     else
     {
-        spriteId = AddDecorationIconObject(item, 20, 84, 1, iconSlot + 0x83E, iconSlot + 0x83E);
+        spriteId = AddDecorationIconObject(item, 20, 84, 1, iconSlot + 2110, iconSlot + 2110);
         if (spriteId != MAX_SPRITES)
             *spriteIdPtr = spriteId;
     }
 }
 
-void BuyMenuRemoveItemIcon(u16 item, u8 iconSlot)
+static void BuyMenuRemoveItemIcon(u16 item, u8 iconSlot)
 {
-    u8 *spriteIdPtr = &gShopDataPtr->unk200D[iconSlot];
+    u8 *spriteIdPtr = &gShopDataPtr->itemSpriteIds[iconSlot];
     if (*spriteIdPtr == 0xFF)
         return;
 
-    FreeSpriteTilesByTag(iconSlot + 0x83E);
-    FreeSpritePaletteByTag(iconSlot + 0x83E);
+    FreeSpriteTilesByTag(iconSlot + 2110);
+    FreeSpritePaletteByTag(iconSlot + 2110);
     DestroySprite(&gSprites[*spriteIdPtr]);
     *spriteIdPtr = 0xFF;
 }
 
-void BuyMenuInitBgs(void)
+static void BuyMenuInitBgs(void)
 {
     ResetBgsAndClearDma3BusyFlags(0);
-    InitBgsFromTemplates(0, gUnknown_08589A60, ARRAY_COUNT(gUnknown_08589A60));
+    InitBgsFromTemplates(0, sShopBuyMenuBgTemplates, ARRAY_COUNT(sShopBuyMenuBgTemplates));
     SetBgTilemapBuffer(1, gShopDataPtr->tilemapBuffers[1]);
     SetBgTilemapBuffer(2, gShopDataPtr->tilemapBuffers[3]);
     SetBgTilemapBuffer(3, gShopDataPtr->tilemapBuffers[2]);
@@ -470,16 +669,16 @@ void BuyMenuInitBgs(void)
     ShowBg(3);
 }
 
-void BuyMenuDecompressBgGraphics(void)
+static void BuyMenuDecompressBgGraphics(void)
 {
     decompress_and_copy_tile_data_to_vram(1, gBuyMenuFrame_Gfx, 0x3A0, 0x3E3, 0);
     LZDecompressWram(gBuyMenuFrame_Tilemap, gShopDataPtr->tilemapBuffers[0]);
     LoadCompressedPalette(gMenuMoneyPal, 0xC0, 0x20);
 }
 
-void BuyMenuInitWindows(void)
+static void BuyMenuInitWindows(void)
 {
-    InitWindows(gUnknown_08589A70);
+    InitWindows(sShopBuyMenuWindowTemplates);
     DeactivateAllTextPrinters();
     LoadUserWindowBorderGfx(0, 1, 0xD0);
     LoadMessageBoxGfx(0, 0xA, 0xE0);
@@ -488,18 +687,18 @@ void BuyMenuInitWindows(void)
     PutWindowTilemap(2);
 }
 
-void BuyMenuPrint(u8 windowId, const u8 *text, u8 x, u8 y, s8 speed, u8 colorSet)
+static void BuyMenuPrint(u8 windowId, const u8 *text, u8 x, u8 y, s8 speed, u8 colorSet)
 {
-    AddTextPrinterParameterized4(windowId, 1, x, y, 0, 0, gUnknown_08589AB0[colorSet], speed, text);
+    AddTextPrinterParameterized4(windowId, 1, x, y, 0, 0, sShopBuyMenuTextColors[colorSet], speed, text);
 }
 
-void BuyMenuDisplayMessage(u8 taskId, const u8 *text, TaskFunc callback)
+static void BuyMenuDisplayMessage(u8 taskId, const u8 *text, TaskFunc callback)
 {
     DisplayMessageAndContinueTask(taskId, 5, 10, 14, 1, GetPlayerTextSpeed(), text, callback);
     schedule_bg_copy_tilemap_to_vram(0);
 }
 
-void BuyMenuDrawGraphics(void)
+static void BuyMenuDrawGraphics(void)
 {
     BuyMenuDrawMapGraphics();
     BuyMenuCopyMenuBgToBg1TilemapBuffer();
@@ -511,24 +710,22 @@ void BuyMenuDrawGraphics(void)
     schedule_bg_copy_tilemap_to_vram(3);
 }
 
-void BuyMenuDrawMapGraphics(void)
+static void BuyMenuDrawMapGraphics(void)
 {
     BuyMenuCollectEventObjectData();
     BuyMenuDrawEventObjects();
     BuyMenuDrawMapBg();
 }
 
-#ifdef NONMATCHING
-// functionally equivalent, but couldn't get the loop variables using the 
-// stack correctly. Might be related to the tileset metatiles type.
-void BuyMenuDrawMapBg(void)
+static void BuyMenuDrawMapBg(void)
 {
     s16 i;
     s16 j;
     s16 x;
     s16 y;
     const struct MapLayout *mapLayout;
-    u16 metatile, metatileLayerType;
+    u16 metatile;
+    u8 metatileLayerType;
 
     mapLayout = gMapHeader.mapLayout;
     GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
@@ -545,135 +742,491 @@ void BuyMenuDrawMapBg(void)
             else
                 metatileLayerType = 1;
 
-            if (metatile < 0x200)
+            if (metatile < NUM_METATILES_IN_PRIMARY)
             {
                 BuyMenuDrawMapMetatile(i, j, (u16*)mapLayout->primaryTileset->metatiles + metatile * 8, metatileLayerType);
             }
             else
             {
-                BuyMenuDrawMapMetatile(i, j, (u16*)mapLayout->secondaryTileset->metatiles + ((metatile - 0x200) * 8), metatileLayerType);
+                BuyMenuDrawMapMetatile(i, j, (u16*)mapLayout->secondaryTileset->metatiles + ((metatile - NUM_METATILES_IN_PRIMARY) * 8), metatileLayerType);
+            }
+        }
+    }
+}
+
+static void BuyMenuDrawMapMetatile(s16 x, s16 y, const u16 *src, u8 metatileLayerType)
+{
+    u16 offset1 = x * 2;
+    u16 offset2 = y * 64;
+
+    switch (metatileLayerType)
+    {
+    case 0:
+        BuyMenuDrawMapMetatileLayer(gShopDataPtr->tilemapBuffers[3], offset1, offset2, src);
+        BuyMenuDrawMapMetatileLayer(gShopDataPtr->tilemapBuffers[1], offset1, offset2, src + 4);
+        break;
+    case 1:
+        BuyMenuDrawMapMetatileLayer(gShopDataPtr->tilemapBuffers[2], offset1, offset2, src);
+        BuyMenuDrawMapMetatileLayer(gShopDataPtr->tilemapBuffers[3], offset1, offset2, src + 4);
+        break;
+    case 2:
+        BuyMenuDrawMapMetatileLayer(gShopDataPtr->tilemapBuffers[2], offset1, offset2, src);
+        BuyMenuDrawMapMetatileLayer(gShopDataPtr->tilemapBuffers[1], offset1, offset2, src + 4);
+        break;
+    }
+}
+
+static void BuyMenuDrawMapMetatileLayer(u16 *dest, s16 offset1, s16 offset2, const u16 *src)
+{
+    // This function draws a whole 2x2 metatile.
+    dest[offset1 + offset2] = src[0]; // top left
+    dest[offset1 + offset2 + 1] = src[1]; // top right
+    dest[offset1 + offset2 + 32] = src[2]; // bottom left
+    dest[offset1 + offset2 + 33] = src[3]; // bottom right
+}
+
+static void BuyMenuCollectEventObjectData(void)
+{
+    s16 facingX;
+    s16 facingY;
+    u8 y;
+    u8 x;
+    u8 r8 = 0;
+
+    GetXYCoordsOneStepInFrontOfPlayer(&facingX, &facingY);
+    for (y = 0; y < 16; y++)
+        gShopDataPtr->viewportObjects[y][EVENT_OBJ_ID] = 16;
+    for (y = 0; y < 5; y++)
+    {
+        for (x = 0; x < 7; x++)
+        {
+            u8 eventObjId = GetEventObjectIdByXY(facingX - 4 + x, facingY - 2 + y);
+
+            if (eventObjId != 16)
+            {
+                gShopDataPtr->viewportObjects[r8][EVENT_OBJ_ID] = eventObjId;
+                gShopDataPtr->viewportObjects[r8][X_COORD] = x;
+                gShopDataPtr->viewportObjects[r8][Y_COORD] = y;
+                gShopDataPtr->viewportObjects[r8][LAYER_TYPE] = MapGridGetMetatileLayerTypeAt(facingX - 4 + x, facingY - 2 + y);
+                
+                switch (gEventObjects[eventObjId].facingDirection)
+                {
+                    case DIR_SOUTH:
+                        gShopDataPtr->viewportObjects[r8][ANIM_NUM] = 0;
+                        break;
+                    case DIR_NORTH:
+                        gShopDataPtr->viewportObjects[r8][ANIM_NUM] = 1;
+                        break;
+                    case DIR_WEST:
+                        gShopDataPtr->viewportObjects[r8][ANIM_NUM] = 2;
+                        break;
+                    case DIR_EAST:
+                    default:
+                        gShopDataPtr->viewportObjects[r8][ANIM_NUM] = 3;
+                        break;
+                }
+                r8++;
+            }
+        }
+    }
+}
+
+static void BuyMenuDrawEventObjects(void)
+{
+    u8 i;
+    u8 spriteId;
+    const struct EventObjectGraphicsInfo *graphicsInfo;
+
+    for (i = 0; i < 16; i++) // max objects?
+    {
+        if (gShopDataPtr->viewportObjects[i][EVENT_OBJ_ID] == 16)
+            continue;
+
+        graphicsInfo = GetEventObjectGraphicsInfo(gEventObjects[gShopDataPtr->viewportObjects[i][EVENT_OBJ_ID]].graphicsId);
+
+        spriteId = AddPseudoEventObject(
+            gEventObjects[gShopDataPtr->viewportObjects[i][EVENT_OBJ_ID]].graphicsId,
+            SpriteCallbackDummy,
+            (u16)gShopDataPtr->viewportObjects[i][X_COORD] * 16 + 8,
+            (u16)gShopDataPtr->viewportObjects[i][Y_COORD] * 16 + 48 - graphicsInfo->height / 2,
+            2);
+        
+        if (BuyMenuCheckIfEventObjectOverlapsMenuBg(gShopDataPtr->viewportObjects[i]) == TRUE)
+        {
+            gSprites[spriteId].subspriteTableNum = 4;
+            gSprites[spriteId].subspriteMode = 1;
+        }
+
+        StartSpriteAnim(&gSprites[spriteId], gShopDataPtr->viewportObjects[i][ANIM_NUM]);
+    }
+}
+
+static bool8 BuyMenuCheckIfEventObjectOverlapsMenuBg(s16 *object)
+{
+    if (!BuyMenuCheckForOverlapWithMenuBg(object[X_COORD], object[Y_COORD] + 2) && object[LAYER_TYPE] != MB_SECRET_BASE_WALL)
+    {
+        return TRUE;
+    }
+    else 
+    {
+        return FALSE;
+    }
+}
+
+static void BuyMenuCopyMenuBgToBg1TilemapBuffer(void)
+{
+    s16 i;
+    u16 *dest = gShopDataPtr->tilemapBuffers[1];
+    const u16 *src = gShopDataPtr->tilemapBuffers[0];
+
+    for (i = 0; i < 1024; i++)
+    {
+        if (src[i] != 0)
+        {
+            dest[i] = src[i] + 0xC3E3;
+        }
+    }
+}
+
+static bool8 BuyMenuCheckForOverlapWithMenuBg(int x, int y)
+{
+    const u16 *metatile = gShopDataPtr->tilemapBuffers[0];
+    int offset1 = x * 2;
+    int offset2 = y * 64;
+
+    if (metatile[offset2 + offset1] == 0 &&
+        metatile[offset2 + offset1 + 32] == 0 &&
+        metatile[offset2 + offset1 + 1] == 0 &&
+        metatile[offset2 + offset1 + 33] == 0)
+    {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static void Task_BuyMenu(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    if (!gPaletteFade.active)
+    {
+        s32 itemId = ListMenuHandleInputGetItemId(tListTaskId);
+        ListMenuGetScrollAndRow(tListTaskId, &gShopDataPtr->scrollOffset, &gShopDataPtr->selectedRow);
+
+        switch (itemId)
+        {
+        case LIST_NOTHING_CHOSEN:
+            break;
+        case LIST_B_PRESSED:
+            PlaySE(SE_SELECT);
+            ExitBuyMenu(taskId);
+            break;
+        default:
+            PlaySE(SE_SELECT);
+            tItemId = itemId;
+            ClearWindowTilemap(2);
+            BuyMenuRemoveScrollIndicatorArrows();
+            BuyMenuPrintCursor(tListTaskId, 2);
+
+            if (gMartInfo.martType == MART_TYPE_0)
+            {
+                gShopDataPtr->totalCost = (ItemId_GetPrice(itemId) >> GetPriceReduction(1));
+            }
+            else
+            {
+                gShopDataPtr->totalCost = gDecorations[itemId].price;
+            }
+
+            if (!IsEnoughMoney(&gSaveBlock1Ptr->money, gShopDataPtr->totalCost))
+            {
+                BuyMenuDisplayMessage(taskId, gText_YouDontHaveMoney, BuyMenuReturnToItemList);
+            }
+            else
+            {
+                if (gMartInfo.martType == MART_TYPE_0)
+                {
+                    CopyItemName(itemId, gStringVar1);
+                    if (ItemId_GetPocket(itemId) == POCKET_TM_HM)
+                    {
+                        StringCopy(gStringVar2, gMoveNames[ItemIdToBattleMoveId(itemId)]);
+                        BuyMenuDisplayMessage(taskId, gText_Var1CertainlyHowMany2, Task_BuyHowManyDialogueInit);
+                    }
+                    else
+                    {
+                        BuyMenuDisplayMessage(taskId, gText_Var1CertainlyHowMany, Task_BuyHowManyDialogueInit);
+                    }
+                }
+                else
+                {
+                    StringCopy(gStringVar1, gDecorations[itemId].name);
+                    ConvertIntToDecimalStringN(gStringVar2, gShopDataPtr->totalCost, STR_CONV_MODE_LEFT_ALIGN, 6);
+
+                    if (gMartInfo.martType == MART_TYPE_1)
+                        StringExpandPlaceholders(gStringVar4, gText_Var1IsItThatllBeVar2);
+                    else
+                        StringExpandPlaceholders(gStringVar4, gText_YouWantedVar1ThatllBeVar2);
+                    BuyMenuDisplayMessage(taskId, gStringVar4, BuyMenuConfirmPurchase);
+                }
+            }
+            break;
+        }
+    }
+}
+
+static void Task_BuyHowManyDialogueInit(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    u16 quantityInBag = CountTotalItemQuantityInBag(tItemId);
+    u16 maxQuantity;
+
+    SetWindowBorderStyle(3, FALSE, 1, 13);
+    ConvertIntToDecimalStringN(gStringVar1, quantityInBag, STR_CONV_MODE_RIGHT_ALIGN, 4);
+    StringExpandPlaceholders(gStringVar4, gText_InBagVar1);
+    BuyMenuPrint(3, gStringVar4, 0, 1, 0, 0);
+    tItemCount = 1;
+    SetWindowBorderStyle(4, FALSE, 1, 13);
+    BuyMenuPrintItemQuantityAndPrice(taskId);
+    schedule_bg_copy_tilemap_to_vram(0);
+
+    maxQuantity = GetMoney(&gSaveBlock1Ptr->money) / gShopDataPtr->totalCost;
+
+    if (maxQuantity > 99)
+    {
+        gShopDataPtr->maxQuantity = 99;
+    }
+    else
+    {
+        gShopDataPtr->maxQuantity = maxQuantity;
+    }
+    
+    gTasks[taskId].func = Task_BuyHowManyDialogueHandleInput;
+}
+
+static void Task_BuyHowManyDialogueHandleInput(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    if (AdjustQuantityAccordingToDPadInput(&tItemCount, gShopDataPtr->maxQuantity) == TRUE)
+    {
+        gShopDataPtr->totalCost = (ItemId_GetPrice(tItemId) >> GetPriceReduction(1)) * tItemCount;
+        BuyMenuPrintItemQuantityAndPrice(taskId);
+    }
+    else
+    {
+        if (gMain.newKeys & A_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            sub_8198070(4, 0);
+            sub_8198070(3, 0);
+            ClearWindowTilemap(4);
+            ClearWindowTilemap(3);
+            PutWindowTilemap(1);
+            CopyItemName(tItemId, gStringVar1);
+            ConvertIntToDecimalStringN(gStringVar2, tItemCount, STR_CONV_MODE_LEFT_ALIGN, 2);
+            ConvertIntToDecimalStringN(gStringVar3, gShopDataPtr->totalCost, STR_CONV_MODE_LEFT_ALIGN, 6);
+            BuyMenuDisplayMessage(taskId, gText_Var1AndYouWantedVar2, BuyMenuConfirmPurchase);
+        }
+        else if (gMain.newKeys & B_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            sub_8198070(4, 0);
+            sub_8198070(3, 0);
+            ClearWindowTilemap(4);
+            ClearWindowTilemap(3);
+            BuyMenuReturnToItemList(taskId);
+        }
+    }
+}
+
+static void BuyMenuConfirmPurchase(u8 taskId)
+{
+    CreateYesNoMenuWithCallbacks(taskId, &sShopBuyMenuYesNoWindowTemplates, 1, 0, 0, 1, 13, &sShopPurchaseYesNoFuncs);
+}
+
+static void BuyMenuTryMakePurchase(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    PutWindowTilemap(1);
+
+    if (gMartInfo.martType == MART_TYPE_0)
+    {
+        if (AddBagItem(tItemId, tItemCount) == TRUE)
+        {
+            BuyMenuDisplayMessage(taskId, gText_HereYouGoThankYou, BuyMenuSubtractMoney);
+            RecordItemPurchase(taskId);
+        }
+        else
+        {
+            BuyMenuDisplayMessage(taskId, gText_NoMoreRoomForThis, BuyMenuReturnToItemList);
+        }
+    }
+    else
+    {
+        if (DecorationAdd(tItemId))
+        {
+            if (gMartInfo.martType == MART_TYPE_1)
+            {
+                BuyMenuDisplayMessage(taskId, gText_ThankYouIllSendItHome, BuyMenuSubtractMoney);
+            }
+            else
+            {
+                BuyMenuDisplayMessage(taskId, gText_ThanksIllSendItHome, BuyMenuSubtractMoney);
             }
         }
+        else
+        {
+            BuyMenuDisplayMessage(taskId, gText_SpaceForVar1Full, BuyMenuReturnToItemList);
+        }
+    }
+}
+
+static void BuyMenuSubtractMoney(u8 taskId)
+{
+    IncrementGameStat(GAME_STAT_SHOPPED);
+    RemoveMoney(&gSaveBlock1Ptr->money, gShopDataPtr->totalCost);
+    PlaySE(SE_REGI);
+    PrintMoneyAmountInMoneyBox(0, GetMoney(&gSaveBlock1Ptr->money), 0);
+
+    if (gMartInfo.martType == MART_TYPE_0)
+    {
+        gTasks[taskId].func = Task_ReturnToItemListAfterItemPurchase;
+    }
+    else
+    {
+        gTasks[taskId].func = Task_ReturnToItemListAfterDecorationPurchase;
     }
 }
-#else
-NAKED
-void BuyMenuDrawMapBg(void)
-{
-    asm_unified("\n\
-    push {r4-r7,lr}\n\
-    mov r7, r10\n\
-    mov r6, r9\n\
-    mov r5, r8\n\
-    push {r5-r7}\n\
-    sub sp, 0x4\n\
-    ldr r0, =gMapHeader\n\
-    ldr r0, [r0]\n\
-    mov r9, r0\n\
-    mov r4, sp\n\
-    adds r4, 0x2\n\
-    mov r0, sp\n\
-    adds r1, r4, 0\n\
-    bl GetXYCoordsOneStepInFrontOfPlayer\n\
-    mov r1, sp\n\
-    mov r0, sp\n\
-    ldrh r0, [r0]\n\
-    subs r0, 0x4\n\
-    strh r0, [r1]\n\
-    ldrh r0, [r4]\n\
-    subs r0, 0x4\n\
-    strh r0, [r4]\n\
-    movs r1, 0\n\
-    mov r10, r4\n\
-_080E05B6:\n\
-    movs r4, 0\n\
-    lsls r7, r1, 16\n\
-    asrs r0, r7, 16\n\
-    mov r8, r0\n\
-_080E05BE:\n\
-    mov r0, sp\n\
-    movs r1, 0\n\
-    ldrsh r0, [r0, r1]\n\
-    lsls r4, 16\n\
-    asrs r5, r4, 16\n\
-    adds r0, r5\n\
-    mov r2, r10\n\
-    movs r3, 0\n\
-    ldrsh r1, [r2, r3]\n\
-    add r1, r8\n\
-    bl MapGridGetMetatileIdAt\n\
-    lsls r0, 16\n\
-    lsrs r6, r0, 16\n\
-    adds r0, r5, 0\n\
-    mov r1, r8\n\
-    bl BuyMenuCheckForOverlapWithMenuBg\n\
-    lsls r0, 24\n\
-    lsrs r0, 24\n\
-    cmp r0, 0x1\n\
-    bne _080E0608\n\
-    mov r0, sp\n\
-    movs r1, 0\n\
-    ldrsh r0, [r0, r1]\n\
-    adds r0, r5\n\
-    mov r2, r10\n\
-    movs r3, 0\n\
-    ldrsh r1, [r2, r3]\n\
-    add r1, r8\n\
-    bl MapGridGetMetatileLayerTypeAt\n\
-    lsls r0, 24\n\
-    lsrs r5, r0, 24\n\
-    b _080E060A\n\
-    .pool\n\
-_080E0608:\n\
-    movs r5, 0x1\n\
-_080E060A:\n\
-    ldr r0, =0x000001ff\n\
-    cmp r6, r0\n\
-    bhi _080E062C\n\
-    asrs r0, r4, 16\n\
-    mov r2, r9\n\
-    ldr r1, [r2, 0x10]\n\
-    lsls r3, r6, 4\n\
-    ldr r2, [r1, 0xC]\n\
-    adds r2, r3\n\
-    asrs r1, r7, 16\n\
-    adds r3, r5, 0\n\
-    bl BuyMenuDrawMapMetatile\n\
-    b _080E0644\n\
-    .pool\n\
-_080E062C:\n\
-    asrs r0, r4, 16\n\
-    mov r3, r9\n\
-    ldr r2, [r3, 0x14]\n\
-    ldr r3, =0xfffffe00\n\
-    adds r1, r6, r3\n\
-    lsls r1, 4\n\
-    ldr r2, [r2, 0xC]\n\
-    adds r2, r1\n\
-    asrs r1, r7, 16\n\
-    adds r3, r5, 0\n\
-    bl BuyMenuDrawMapMetatile\n\
-_080E0644:\n\
-    movs r1, 0x80\n\
-    lsls r1, 9\n\
-    adds r0, r4, r1\n\
-    lsrs r4, r0, 16\n\
-    asrs r0, 16\n\
-    cmp r0, 0xE\n\
-    ble _080E05BE\n\
-    adds r0, r7, r1\n\
-    lsrs r1, r0, 16\n\
-    asrs r0, 16\n\
-    cmp r0, 0x9\n\
-    ble _080E05B6\n\
-    add sp, 0x4\n\
-    pop {r3-r5}\n\
-    mov r8, r3\n\
-    mov r9, r4\n\
-    mov r10, r5\n\
-    pop {r4-r7}\n\
-    pop {r0}\n\
-    bx r0\n\
-    .pool");
-}
-#endif // NONMATCHING
+
+static void Task_ReturnToItemListAfterItemPurchase(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+    {
+        PlaySE(SE_SELECT);
+        if (tItemId == ITEM_POKE_BALL && tItemCount > 9 && AddBagItem(ITEM_PREMIER_BALL, 1) == TRUE)
+        {
+            BuyMenuDisplayMessage(taskId, gText_ThrowInPremierBall, BuyMenuReturnToItemList);
+        }
+        else
+        {
+            BuyMenuReturnToItemList(taskId);
+        }
+    }
+}
+
+static void Task_ReturnToItemListAfterDecorationPurchase(u8 taskId)
+{
+    if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+    {
+        PlaySE(SE_SELECT);
+        BuyMenuReturnToItemList(taskId);
+    }
+}
+
+static void BuyMenuReturnToItemList(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    sub_8197DF8(5, 0);
+    BuyMenuPrintCursor(tListTaskId, 1);
+    PutWindowTilemap(1);
+    PutWindowTilemap(2);
+    schedule_bg_copy_tilemap_to_vram(0);
+    BuyMenuAddScrollIndicatorArrows();
+    gTasks[taskId].func = Task_BuyMenu;
+}
+
+static void BuyMenuPrintItemQuantityAndPrice(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    FillWindowPixelBuffer(4, 0x11);
+    PrintMoneyAmount(4, 38, 1, gShopDataPtr->totalCost, TEXT_SPEED_FF);
+    ConvertIntToDecimalStringN(gStringVar1, tItemCount, 2, 2);
+    StringExpandPlaceholders(gStringVar4, gText_xVar1);
+    BuyMenuPrint(4, gStringVar4, 0, 1, 0, 0);
+}
+
+static void ExitBuyMenu(u8 taskId)
+{
+    gFieldCallback = MapPostLoadHook_ReturnToShopMenu;
+    BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
+    gTasks[taskId].func = Task_ExitBuyMenu;
+}
+
+static void Task_ExitBuyMenu(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        RemoveMoneyLabelObject();
+        BuyMenuFreeMemory();
+        SetMainCallback2(CB2_ReturnToField);
+        DestroyTask(taskId);
+    }
+}
+
+static void ClearItemPurchases(void)
+{
+    gMartPurchaseHistoryId = 0;
+    memset(gMartPurchaseHistory, 0, sizeof(gMartPurchaseHistory));
+}
+
+static void RecordItemPurchase(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    u16 i;
+
+    for (i = 0; i < 3; i++)
+    {
+        if (gMartPurchaseHistory[i].itemId == tItemId && gMartPurchaseHistory[i].quantity != 0)
+        {
+            if (gMartPurchaseHistory[i].quantity + tItemCount > 255)
+            {
+                gMartPurchaseHistory[i].quantity = 255;
+            }
+            else
+            {
+                gMartPurchaseHistory[i].quantity += tItemCount;
+            }
+            return;
+        }
+    }
+
+    if (gMartPurchaseHistoryId < 3)
+    {
+        gMartPurchaseHistory[gMartPurchaseHistoryId].itemId = tItemId;
+        gMartPurchaseHistory[gMartPurchaseHistoryId].quantity = tItemCount;
+        gMartPurchaseHistoryId++;
+    }
+}
+
+#undef tItemCount
+#undef tItemId
+#undef tListTaskId
+
+void CreatePokemartMenu(const u16 *itemsForSale)
+{
+    CreateShopMenu(MART_TYPE_0);
+    SetShopItemsForSale(itemsForSale);
+    ClearItemPurchases();
+    SetShopMenuCallback(EnableBothScriptContexts);
+}
+
+void CreateDecorationShop1Menu(const u16 *itemsForSale)
+{
+    CreateShopMenu(MART_TYPE_1);
+    SetShopItemsForSale(itemsForSale);
+    SetShopMenuCallback(EnableBothScriptContexts);
+}
+
+void CreateDecorationShop2Menu(const u16 *itemsForSale)
+{
+    CreateShopMenu(MART_TYPE_2);
+    SetShopItemsForSale(itemsForSale);
+    SetShopMenuCallback(EnableBothScriptContexts);
+}
diff --git a/src/slot_machine.c b/src/slot_machine.c
index ef52b7171..f92ebd168 100644
--- a/src/slot_machine.c
+++ b/src/slot_machine.c
@@ -25,8 +25,6 @@
 #include "bg.h"
 #include "window.h"
 
-extern u8 gOamLimit;
-
 // Text
 extern const u8 gText_YouDontHaveThreeCoins[];
 extern const u8 gText_QuitTheGame[];
diff --git a/src/sprite.c b/src/sprite.c
index c133dc73e..4087dd8c4 100644
--- a/src/sprite.c
+++ b/src/sprite.c
@@ -15,15 +15,15 @@
 
 #define ALLOC_SPRITE_TILE(n)                             \
 {                                                        \
-    gSpriteTileAllocBitmap[(n) / 8] |= (1 << ((n) % 8)); \
+    sSpriteTileAllocBitmap[(n) / 8] |= (1 << ((n) % 8)); \
 }
 
 #define FREE_SPRITE_TILE(n)                               \
 {                                                         \
-    gSpriteTileAllocBitmap[(n) / 8] &= ~(1 << ((n) % 8)); \
+    sSpriteTileAllocBitmap[(n) / 8] &= ~(1 << ((n) % 8)); \
 }
 
-#define SPRITE_TILE_IS_ALLOCATED(n) ((gSpriteTileAllocBitmap[(n) / 8] >> ((n) % 8)) & 1)
+#define SPRITE_TILE_IS_ALLOCATED(n) ((sSpriteTileAllocBitmap[(n) / 8] >> ((n) % 8)) & 1)
 
 
 struct SpriteCopyRequest
@@ -295,18 +295,18 @@ u32 gOamMatrixAllocBitmap;
 u8 gReservedSpritePaletteCount;
 
 EWRAM_DATA struct Sprite gSprites[MAX_SPRITES + 1] = {0};
-EWRAM_DATA u16 gSpritePriorities[MAX_SPRITES] = {0};
-EWRAM_DATA u8 gSpriteOrder[MAX_SPRITES] = {0};
-EWRAM_DATA bool8 gShouldProcessSpriteCopyRequests = 0;
-EWRAM_DATA u8 gSpriteCopyRequestCount = 0;
-EWRAM_DATA struct SpriteCopyRequest gSpriteCopyRequests[MAX_SPRITES] = {0};
+EWRAM_DATA static u16 sSpritePriorities[MAX_SPRITES] = {0};
+EWRAM_DATA static u8 sSpriteOrder[MAX_SPRITES] = {0};
+EWRAM_DATA static bool8 sShouldProcessSpriteCopyRequests = 0;
+EWRAM_DATA static u8 sSpriteCopyRequestCount = 0;
+EWRAM_DATA static struct SpriteCopyRequest sSpriteCopyRequests[MAX_SPRITES] = {0};
 EWRAM_DATA u8 gOamLimit = 0;
 EWRAM_DATA u16 gReservedSpriteTileCount = 0;
-EWRAM_DATA u8 gSpriteTileAllocBitmap[128] = {0};
+EWRAM_DATA static u8 sSpriteTileAllocBitmap[128] = {0};
 EWRAM_DATA s16 gSpriteCoordOffsetX = 0;
 EWRAM_DATA s16 gSpriteCoordOffsetY = 0;
 EWRAM_DATA struct OamMatrix gOamMatrices[OAM_MATRIX_COUNT] = {0};
-EWRAM_DATA bool8 gAffineAnimsDisabled = 0;
+EWRAM_DATA bool8 gAffineAnimsDisabled = FALSE;
 
 void ResetSpriteData(void)
 {
@@ -350,7 +350,7 @@ void BuildOamBuffer(void)
     AddSpritesToOamBuffer();
     CopyMatricesToOamBuffer();
     gMain.oamLoadDisabled = temp;
-    gShouldProcessSpriteCopyRequests = TRUE;
+    sShouldProcessSpriteCopyRequests = TRUE;
 }
 
 void UpdateOamCoords(void)
@@ -382,7 +382,7 @@ void BuildSpritePriorities(void)
     {
         struct Sprite *sprite = &gSprites[i];
         u16 priority = sprite->subpriority | (sprite->oam.priority << 8);
-        gSpritePriorities[i] = priority;
+        sSpritePriorities[i] = priority;
     }
 }
 
@@ -392,10 +392,10 @@ void SortSprites(void)
     for (i = 1; i < MAX_SPRITES; i++)
     {
         u8 j = i;
-        struct Sprite *sprite1 = &gSprites[gSpriteOrder[i - 1]];
-        struct Sprite *sprite2 = &gSprites[gSpriteOrder[i]];
-        u16 sprite1Priority = gSpritePriorities[gSpriteOrder[i - 1]];
-        u16 sprite2Priority = gSpritePriorities[gSpriteOrder[i]];
+        struct Sprite *sprite1 = &gSprites[sSpriteOrder[i - 1]];
+        struct Sprite *sprite2 = &gSprites[sSpriteOrder[i]];
+        u16 sprite1Priority = sSpritePriorities[sSpriteOrder[i - 1]];
+        u16 sprite2Priority = sSpritePriorities[sSpriteOrder[i]];
         s16 sprite1Y = sprite1->oam.y;
         s16 sprite2Y = sprite2->oam.y;
 
@@ -431,20 +431,20 @@ void SortSprites(void)
             && ((sprite1Priority > sprite2Priority)
              || (sprite1Priority == sprite2Priority && sprite1Y < sprite2Y)))
         {
-            u8 temp = gSpriteOrder[j];
-            gSpriteOrder[j] = gSpriteOrder[j - 1];
-            gSpriteOrder[j - 1] = temp;
+            u8 temp = sSpriteOrder[j];
+            sSpriteOrder[j] = sSpriteOrder[j - 1];
+            sSpriteOrder[j - 1] = temp;
 
             // UB: If j equals 1, then j-- makes j equal 0.
-            // Then, gSpriteOrder[-1] gets accessed below.
+            // Then, sSpriteOrder[-1] gets accessed below.
             // Although this doesn't result in a bug in the ROM,
             // the behavior is undefined.
             j--;
 
-            sprite1 = &gSprites[gSpriteOrder[j - 1]];
-            sprite2 = &gSprites[gSpriteOrder[j]];
-            sprite1Priority = gSpritePriorities[gSpriteOrder[j - 1]];
-            sprite2Priority = gSpritePriorities[gSpriteOrder[j]];
+            sprite1 = &gSprites[sSpriteOrder[j - 1]];
+            sprite2 = &gSprites[sSpriteOrder[j]];
+            sprite1Priority = sSpritePriorities[sSpriteOrder[j - 1]];
+            sprite2Priority = sSpritePriorities[sSpriteOrder[j]];
             sprite1Y = sprite1->oam.y;
             sprite2Y = sprite2->oam.y;
 
@@ -499,7 +499,7 @@ void AddSpritesToOamBuffer(void)
 
     while (i < MAX_SPRITES)
     {
-        struct Sprite *sprite = &gSprites[gSpriteOrder[i]];
+        struct Sprite *sprite = &gSprites[sSpriteOrder[i]];
         if (sprite->inUse && !sprite->invisible && AddSpriteToOamBuffer(sprite, &oamIndex))
             return;
         i++;
@@ -664,14 +664,14 @@ void ClearSpriteCopyRequests(void)
 {
     u8 i;
 
-    gShouldProcessSpriteCopyRequests = FALSE;
-    gSpriteCopyRequestCount = 0;
+    sShouldProcessSpriteCopyRequests = FALSE;
+    sSpriteCopyRequestCount = 0;
 
     for (i = 0; i < MAX_SPRITE_COPY_REQUESTS; i++)
     {
-        gSpriteCopyRequests[i].src = 0;
-        gSpriteCopyRequests[i].dest = 0;
-        gSpriteCopyRequests[i].size = 0;
+        sSpriteCopyRequests[i].src = 0;
+        sSpriteCopyRequests[i].dest = 0;
+        sSpriteCopyRequests[i].size = 0;
     }
 }
 
@@ -779,17 +779,17 @@ u8 SpriteTileAllocBitmapOp(u16 bit, u8 op)
     if (op == 0)
     {
         val = ~(1 << val);
-        gSpriteTileAllocBitmap[index] &= val;
+        sSpriteTileAllocBitmap[index] &= val;
     }
     else if (op == 1)
     {
         val = (1 << val);
-        gSpriteTileAllocBitmap[index] |= val;
+        sSpriteTileAllocBitmap[index] |= val;
     }
     else
     {
         retVal = 1 << shift;
-        retVal &= gSpriteTileAllocBitmap[index];
+        retVal &= sSpriteTileAllocBitmap[index];
     }
 
     return retVal;
@@ -801,40 +801,40 @@ void SpriteCallbackDummy(struct Sprite *sprite)
 
 void ProcessSpriteCopyRequests(void)
 {
-    if (gShouldProcessSpriteCopyRequests)
+    if (sShouldProcessSpriteCopyRequests)
     {
         u8 i = 0;
 
-        while (gSpriteCopyRequestCount > 0)
+        while (sSpriteCopyRequestCount > 0)
         {
-            CpuCopy16(gSpriteCopyRequests[i].src, gSpriteCopyRequests[i].dest, gSpriteCopyRequests[i].size);
-            gSpriteCopyRequestCount--;
+            CpuCopy16(sSpriteCopyRequests[i].src, sSpriteCopyRequests[i].dest, sSpriteCopyRequests[i].size);
+            sSpriteCopyRequestCount--;
             i++;
         }
 
-        gShouldProcessSpriteCopyRequests = FALSE;
+        sShouldProcessSpriteCopyRequests = FALSE;
     }
 }
 
 void RequestSpriteFrameImageCopy(u16 index, u16 tileNum, const struct SpriteFrameImage *images)
 {
-    if (gSpriteCopyRequestCount < MAX_SPRITE_COPY_REQUESTS)
+    if (sSpriteCopyRequestCount < MAX_SPRITE_COPY_REQUESTS)
     {
-        gSpriteCopyRequests[gSpriteCopyRequestCount].src = images[index].data;
-        gSpriteCopyRequests[gSpriteCopyRequestCount].dest = (u8 *)OBJ_VRAM0 + TILE_SIZE_4BPP * tileNum;
-        gSpriteCopyRequests[gSpriteCopyRequestCount].size = images[index].size;
-        gSpriteCopyRequestCount++;
+        sSpriteCopyRequests[sSpriteCopyRequestCount].src = images[index].data;
+        sSpriteCopyRequests[sSpriteCopyRequestCount].dest = (u8 *)OBJ_VRAM0 + TILE_SIZE_4BPP * tileNum;
+        sSpriteCopyRequests[sSpriteCopyRequestCount].size = images[index].size;
+        sSpriteCopyRequestCount++;
     }
 }
 
 void RequestSpriteCopy(const u8 *src, u8 *dest, u16 size)
 {
-    if (gSpriteCopyRequestCount < MAX_SPRITE_COPY_REQUESTS)
+    if (sSpriteCopyRequestCount < MAX_SPRITE_COPY_REQUESTS)
     {
-        gSpriteCopyRequests[gSpriteCopyRequestCount].src = src;
-        gSpriteCopyRequests[gSpriteCopyRequestCount].dest = dest;
-        gSpriteCopyRequests[gSpriteCopyRequestCount].size = size;
-        gSpriteCopyRequestCount++;
+        sSpriteCopyRequests[sSpriteCopyRequestCount].src = src;
+        sSpriteCopyRequests[sSpriteCopyRequestCount].dest = dest;
+        sSpriteCopyRequests[sSpriteCopyRequestCount].size = size;
+        sSpriteCopyRequestCount++;
     }
 }
 
@@ -869,7 +869,7 @@ void ResetAllSprites(void)
     for (i = 0; i < MAX_SPRITES; i++)
     {
         ResetSprite(&gSprites[i]);
-        gSpriteOrder[i] = i;
+        sSpriteOrder[i] = i;
     }
 
     ResetSprite(&gSprites[i]);
@@ -1414,7 +1414,7 @@ void ResetAffineAnimData(void)
 {
     u8 i;
 
-    gAffineAnimsDisabled = 0;
+    gAffineAnimsDisabled = FALSE;
     gOamMatrixAllocBitmap = 0;
 
     ResetOamMatrices();
diff --git a/src/strings.c b/src/strings.c
index cdbbb4468..15c247744 100644
--- a/src/strings.c
+++ b/src/strings.c
@@ -349,9 +349,9 @@ const u8 gText_Var1ThrownAway[] = _("The {STR_VAR_1}\nwas thrown away.");
 const u8 gText_Var1AteTheVar2[] = _("{STR_VAR_1} ate the\n{STR_VAR_2}.{PAUSE_UNTIL_PRESS}");
 const u8 gText_Var1HappilyAteVar2[] = _("{STR_VAR_1} happily ate the\n{STR_VAR_2}.{PAUSE_UNTIL_PRESS}");
 const u8 gText_Var1DisdainfullyAteVar2[] = _("{STR_VAR_1} disdainfully ate the\n{STR_VAR_2}.{PAUSE_UNTIL_PRESS}");
-const u8 gUnknown_085E93C7[] = _("BUY");
-const u8 gUnknown_085E93CB[] = _("SELL");
-const u8 gUnknown_085E93D0[] = _("QUIT");
+const u8 gText_ShopBuy[] = _("BUY");
+const u8 gText_ShopSell[] = _("SELL");
+const u8 gText_ShopQuit[] = _("QUIT");
 const u8 gText_InBagVar1[] = _("IN BAG: {STR_VAR_1}");
 const u8 gText_QuitShopping[] = _("Quit shopping.");
 const u8 gText_Var1CertainlyHowMany[] = _("{STR_VAR_1}? Certainly.\nHow many would you like?");
diff --git a/src/text.c b/src/text.c
index ec0d26ab1..84964ffbf 100644
--- a/src/text.c
+++ b/src/text.c
@@ -9,11 +9,11 @@
 #include "window.h"
 #include "text.h"
 #include "blit.h"
+#include "dynamic_placeholder_text_util.h"
 
 extern u8 GetKeypadIconWidth(u8 keypadIconId);
 extern u16 Font6Func(struct TextPrinter *textPrinter);
 extern u32 GetGlyphWidthFont6(u16 glyphId, bool32 isJapanese);
-extern u8* DynamicPlaceholderTextUtil_GetPlaceholderPtr(u8 a1);
 extern int sub_8197964();
 
 EWRAM_DATA struct TextPrinter gTempTextPrinter = {0};
@@ -24,8 +24,6 @@ static u16 gLastTextBgColor;
 static u16 gLastTextFgColor;
 static u16 gLastTextShadowColor;
 
-extern struct MusicPlayerInfo gMPlayInfo_BGM;
-
 const struct FontInfo *gFonts;
 u8 gUnknown_03002F84;
 u8 gUnknown_03002F90[0x20];
@@ -3170,7 +3168,7 @@ u32 (*GetFontWidthFunc(u8 glyphId))(u16, bool32)
             return gGlyphWidthFuncs[i].func;
     }
 
-    return 0;
+    return NULL;
 }
 
 u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing)
@@ -3181,7 +3179,7 @@ u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing)
     s32 result;
     int localLetterSpacing;
     u32 lineWidth;
-    u8 *bufferPointer;
+    const u8 *bufferPointer;
     int glyphWidth;
     u32 width;
 
diff --git a/src/tv.c b/src/tv.c
index af1102c2d..fb309f6e3 100644
--- a/src/tv.c
+++ b/src/tv.c
@@ -1580,7 +1580,7 @@ void SaveRecordedItemPurchasesForTVShow(void)
         if (sCurTVShowSlot != -1 && HasMixableShowAlreadyBeenSpawnedWithPlayerID(TVSHOW_SMART_SHOPPER, FALSE) != TRUE)
         {
             TV_SortPurchasesByQuantity();
-            if (gUnknown_02039F80[0].quantity >= 20)
+            if (gMartPurchaseHistory[0].quantity >= 20)
             {
                 show = &gSaveBlock1Ptr->tvShows[sCurTVShowSlot];
                 show->smartshopperShow.kind = TVSHOW_SMART_SHOPPER;
@@ -1588,8 +1588,8 @@ void SaveRecordedItemPurchasesForTVShow(void)
                 show->smartshopperShow.shopLocation = gMapHeader.regionMapSectionId;
                 for (i = 0; i < 3; i ++)
                 {
-                    show->smartshopperShow.itemIds[i] = gUnknown_02039F80[i].itemId;
-                    show->smartshopperShow.itemAmounts[i] = gUnknown_02039F80[i].quantity;
+                    show->smartshopperShow.itemIds[i] = gMartPurchaseHistory[i].itemId;
+                    show->smartshopperShow.itemAmounts[i] = gMartPurchaseHistory[i].quantity;
                 }
                 show->smartshopperShow.priceReduced = GetPriceReduction(1);
                 StringCopy(show->smartshopperShow.playerName, gSaveBlock2Ptr->playerName);
@@ -2992,14 +2992,14 @@ void TV_SortPurchasesByQuantity(void)
     {
         for (j = i + 1; j < 3; j ++)
         {
-            if (gUnknown_02039F80[i].quantity < gUnknown_02039F80[j].quantity)
-            {
-                tmpId = gUnknown_02039F80[i].itemId;
-                tmpQn = gUnknown_02039F80[i].quantity;
-                gUnknown_02039F80[i].itemId = gUnknown_02039F80[j].itemId;
-                gUnknown_02039F80[i].quantity = gUnknown_02039F80[j].quantity;
-                gUnknown_02039F80[j].itemId = tmpId;
-                gUnknown_02039F80[j].quantity = tmpQn;
+            if (gMartPurchaseHistory[i].quantity < gMartPurchaseHistory[j].quantity)
+            {
+                tmpId = gMartPurchaseHistory[i].itemId;
+                tmpQn = gMartPurchaseHistory[i].quantity;
+                gMartPurchaseHistory[i].itemId = gMartPurchaseHistory[j].itemId;
+                gMartPurchaseHistory[i].quantity = gMartPurchaseHistory[j].quantity;
+                gMartPurchaseHistory[j].itemId = tmpId;
+                gMartPurchaseHistory[j].quantity = tmpQn;
             }
         }
     }
diff --git a/src/window.c b/src/window.c
index 9a52a5a20..e93577e3a 100644
--- a/src/window.c
+++ b/src/window.c
@@ -20,7 +20,7 @@ EWRAM_DATA static u16 sWindowSize = 0;
 static u8 GetNumActiveWindowsOnBg(u8 bgId);
 static u8 GetNumActiveWindowsOnBg8Bit(u8 bgId);
 
-static const struct WindowTemplate sDummyWindowTemplate = {0xFF, 0, 0, 0, 0, 0, 0};
+static const struct WindowTemplate sDummyWindowTemplate = DUMMY_WIN_TEMPLATE;
 
 static void nullsub_8(void)
 {