Merge pull request #702 from PikalaxALT/pokenav_unk_2

Pokenav unk 2

6 files changed, 1091 insertions, 88 deletions

diff --git a/src/field_control_avatar.c b/src/field_control_avatar.c
index 455c38deb..8a41087f5 100644
--- a/src/field_control_avatar.c
+++ b/src/field_control_avatar.c
@@ -304,7 +304,7 @@ static const u8 *GetInteractedEventObjectScript(struct MapPosition *position, u8
     gSpecialVar_Facing = direction;
 
     if (InTrainerHill() == TRUE)
-        script = sub_81D62AC();
+        script = GetTrainerHillTrainerScript();
     else
         script = GetEventObjectScriptPointerByEventObjectId(eventObjectId);
 
diff --git a/src/pokenav.c b/src/pokenav.c
index 132e4123b..b4b185c84 100644
--- a/src/pokenav.c
+++ b/src/pokenav.c
@@ -37,21 +37,22 @@ struct UnknownPokenavCallbackStruct
     void (*unk18)(void);
 };
 
+// TODO: Move these to pokenav.h
 extern bool32 sub_81C9924(void);
 extern u32 sub_81C99C0(void);
-extern void sub_81C9990(int);
+extern void sub_81C9990(s32);
 extern bool32 sub_81C9940(void);
 extern u32 sub_81CCFD8(void);
 extern u32 sub_81CD070(void);
 extern bool32 sub_81CDDD4(void);
-extern void sub_81CDE2C(int);
+extern void sub_81CDE2C(s32);
 extern u32 sub_81CDE64(void);
 extern void sub_81CD1C0(void);
 extern void sub_81CECA0(void);
 extern u32 sub_81CEF3C(void);
 extern u32 sub_81CEFDC(void);
 extern bool32 sub_81CF330(void);
-extern void sub_81CF3A0(int);
+extern void sub_81CF3A0(s32);
 extern u32 sub_81CF3D0(void);
 extern void sub_81CEFF0(void);
 extern void sub_81CF3F8(void);
diff --git a/src/pokenav_unk_1.c b/src/pokenav_unk_1.c
index 96ecf9c8b..336cf49f2 100644
--- a/src/pokenav_unk_1.c
+++ b/src/pokenav_unk_1.c
@@ -459,7 +459,7 @@ int sub_81C98B4(void)
     return state->descriptionId;
 }
 
-int sub_81C98C4(void)
+u16 sub_81C98C4(void)
 {
     struct Pokenav1Struct *state = GetSubstructPtr(1);
     return state->helpBarIndex;
diff --git a/src/pokenav_unk_2.c b/src/pokenav_unk_2.c
index 60aa5ea5e..1c40e146f 100644
--- a/src/pokenav_unk_2.c
+++ b/src/pokenav_unk_2.c
@@ -1,66 +1,126 @@
 #include "global.h"
+#include "alloc.h"
+#include "decompress.h"
 #include "bg.h"
-#include "gym_leader_rematch.h"
+#include "palette.h"
+#include "trig.h"
+#include "gpu_regs.h"
+#include "menu.h"
+#include "window.h"
 #include "pokenav.h"
-#include "sprite.h"
+#include "graphics.h"
+#include "sound.h"
+#include "gym_leader_rematch.h"
 #include "window.h"
 #include "strings.h"
 #include "scanline_effect.h"
+#include "constants/songs.h"
+#include "constants/rgb.h"
 
-extern const u32 gPokenavOptions_Gfx[];
-extern const u16 gPokenavOptions_Pal[];
+// Top Menu
 
-const u16 gUnknown_0861FC78[] = INCBIN_U16("graphics/pokenav/bg.gbapal");
-const u32 gUnknown_0861FC98[] = INCBIN_U32("graphics/pokenav/bg.4bpp.lz");
-const u32 gUnknown_0861FCAC[] = INCBIN_U32("graphics/pokenav/bg.bin.lz");
-const u16 gUnknown_0861FD4C[] = INCBIN_U16("graphics/pokenav/outline.gbapal");
-const u32 gUnknown_0861FD6C[] = INCBIN_U32("graphics/pokenav/outline.4bpp.lz");
-const u32 gUnknown_0861FFF4[] = INCBIN_U32("graphics/pokenav/outline_map.bin.lz");
-const u16 gUnknown_08620104[] = INCBIN_U16("graphics/pokenav/blue_light.gbapal");    
-const u32 gUnknown_08620124[] = INCBIN_U32("graphics/pokenav/blue_light.4bpp.lz");
-
-const struct BgTemplate gUnknown_08620194[3] = 
+struct Pokenav2Struct
 {
+    bool32 (*callback)(void);
+    u32 loopedTaskId;
+    u16 optionDescriptionWindowId;
+    u8 bg3ScrollTaskId;
+    u8 cursorPos;
+    bool8 otherIconsInMotion;
+    u8 field_00d;
+    bool32 iconVisible[6];
+    struct Sprite * field_028;
+    struct Sprite * iconSprites[6][4];
+    u16 bg1TilemapBuffer[0x400];
+};
+
+static struct Pokenav2Struct * sub_81C9958(void);
+static bool32 sub_81C99FC(void);
+static u32 sub_81C9A10(s32 state);
+static u32 sub_81C9C6C(s32 state);
+static u32 sub_81C9CA8(s32 state);
+static u32 sub_81C9D44(s32 state);
+static u32 sub_81C9DD8(s32 state);
+static u32 sub_81C9E58(s32 state);
+static u32 sub_81C9EC8(s32 state);
+static u32 sub_81C9EF8(s32 state);
+static u32 sub_81C9F28(s32 state);
+static void sub_81C9FC4(void);
+static void sub_81C9FEC(void);
+static void sub_81CA02C(void);
+static void sub_81CA094(void);
+static void sub_81CA0C8(void);
+static void sub_81CA0EC(const u16 *const * a0, s32 a1, s32 a2);
+static void sub_81CA20C(void);
+static void sub_81CA278(void);
+static void sub_81CA35C(struct Sprite ** sprites, s32 a1, s32 a2, s32 a3);
+static void sub_81CA3B4(struct Sprite ** sprites);
+static void sub_81CA2DC(void);
+static bool32 sub_81CA324(void);
+static void sub_81CA448(struct Sprite ** sprites, bool32 a1);
+static void sub_81CA474(struct Sprite * sprite);
+static void sub_81CA4AC(struct Sprite * sprite);
+static void sub_81CA580(u8 taskId);
+static void sub_81CA640(void);
+static void sub_81CA6AC(struct Sprite * sprite);
+static void sub_81CA698(void);
+static void sub_81CA6E0(void);
+static void sub_81CA714(void);
+static void sub_81CA770(void);
+static bool32 sub_81CA7C4(void);
+static void sub_81CA7D4(void);
+static void sub_81CA7F4(void);
+static void sub_81CA808(u8 taskId);
+static void sub_81CA818(void);
+static void sub_81CA850(void);
+static void sub_81CA864(void);
+static bool32 sub_81CA89C(void);
+static void sub_81CA8B0(u8 taskId);
+static void sub_81CA92C(void);
+static void sub_81CA994(void);
+static void sub_81CA9C8(void);
+static void sub_81CA9D8(void);
+static void sub_81CA9EC(u8 taskId);
+static void sub_81CAA3C(void);
+
+static const u16 gUnknown_0861FC78[] = INCBIN_U16("graphics/pokenav/bg.gbapal");
+static const u32 gUnknown_0861FC98[] = INCBIN_U32("graphics/pokenav/bg.4bpp.lz");
+static const u32 gUnknown_0861FCAC[] = INCBIN_U32("graphics/pokenav/bg.bin.lz");
+static const u16 gUnknown_0861FD4C[] = INCBIN_U16("graphics/pokenav/outline.gbapal");
+static const u32 gUnknown_0861FD6C[] = INCBIN_U32("graphics/pokenav/outline.4bpp.lz");
+static const u32 gUnknown_0861FFF4[] = INCBIN_U32("graphics/pokenav/outline_map.bin.lz");
+static const u16 gUnknown_08620104[] = INCBIN_U16("graphics/pokenav/blue_light.gbapal");
+static const u32 gUnknown_08620124[] = INCBIN_U32("graphics/pokenav/blue_light.4bpp.lz");
+
+static const struct BgTemplate gUnknown_08620194[] = {
     {
         .bg = 1,
         .charBaseIndex = 1,
-        .mapBaseIndex = 0x0F,
+        .mapBaseIndex = 15,
         .screenSize = 0,
         .paletteMode = 0,
         .priority = 1,
-        .baseTile = 0
-    },
-    {
+        .baseTile = 0x000
+    }, {
         .bg = 2,
         .charBaseIndex = 2,
-        .mapBaseIndex = 0x17,
+        .mapBaseIndex = 23,
         .screenSize = 0,
         .paletteMode = 0,
         .priority = 2,
-        .baseTile = 0
-    },
-    {
+        .baseTile = 0x000
+    }, {
         .bg = 3,
         .charBaseIndex = 3,
-        .mapBaseIndex = 0x1F,
+        .mapBaseIndex = 31,
         .screenSize = 0,
         .paletteMode = 0,
         .priority = 3,
-        .baseTile = 0
+        .baseTile = 0x000
     }
 };
 
-u32 sub_81C9C6C(s32);
-u32 sub_81C9CA8(s32);
-u32 sub_81C9D44(s32);
-u32 sub_81C9DD8(s32);
-u32 sub_81C9E58(s32);
-u32 sub_81C9EC8(s32);
-u32 sub_81C9EF8(s32);
-u32 sub_81C9F28(s32);
-
-u32 (*const gUnknown_086201A0[])(s32) = 
-{
+static const LoopedTask gUnknown_086201A0[] = {
     NULL,
     sub_81C9C6C,
     sub_81C9CA8,
@@ -72,7 +132,7 @@ u32 (*const gUnknown_086201A0[])(s32) =
     sub_81C9F28
 };
 
-const struct CompressedSpriteSheet gUnknown_086201C4[] =
+static const struct CompressedSpriteSheet gUnknown_086201C4[] =
 {
     {
         .data = gPokenavOptions_Gfx,
@@ -86,8 +146,8 @@ const struct CompressedSpriteSheet gUnknown_086201C4[] =
     }
 };
 
- const struct SpritePalette gUnknown_086201D4[] = 
- {
+static const struct SpritePalette gUnknown_086201D4[] =
+{
     {gPokenavOptions_Pal + 0x00, 4},
     {gPokenavOptions_Pal + 0x10, 5},
     {gPokenavOptions_Pal + 0x20, 6},
@@ -97,19 +157,19 @@ const struct CompressedSpriteSheet gUnknown_086201C4[] =
     {}
 };
 
-const u16 gUnknown_0862020C[] = {0, 0};
-const u16 gUnknown_08620210[] = {0x20, 1};    
-const u16 gUnknown_08620214[] = {0x40, 4};    
-const u16 gUnknown_08620218[] = {0x60, 2};
-const u16 gUnknown_0862021C[] = {0x80, 3};    
-const u16 gUnknown_08620220[] = {0xA0, 1};
-const u16 gUnknown_08620224[] = {0xC0, 1};
-const u16 gUnknown_08620228[] = {0xE0, 4};
-const u16 gUnknown_0862022C[] = {0x100, 1};
-const u16 gUnknown_08620230[] = {0x120, 2};
-const u16 gUnknown_08620234[] = {0x140, 0};
-const u16 gUnknown_08620238[] = {0x160, 0};
-const u16 gUnknown_0862023C[] = {0x180, 3};
+static const u16 gUnknown_0862020C[] = {0, 0};
+static const u16 gUnknown_08620210[] = {0x20, 1};
+static const u16 gUnknown_08620214[] = {0x40, 4};
+static const u16 gUnknown_08620218[] = {0x60, 2};
+static const u16 gUnknown_0862021C[] = {0x80, 3};
+static const u16 gUnknown_08620220[] = {0xA0, 1};
+static const u16 gUnknown_08620224[] = {0xC0, 1};
+static const u16 gUnknown_08620228[] = {0xE0, 4};
+static const u16 gUnknown_0862022C[] = {0x100, 1};
+static const u16 gUnknown_08620230[] = {0x120, 2};
+static const u16 gUnknown_08620234[] = {0x140, 0};
+static const u16 gUnknown_08620238[] = {0x160, 0};
+static const u16 gUnknown_0862023C[] = {0x180, 3};
 
 struct UnkStruct_08620240
 {
@@ -118,36 +178,36 @@ struct UnkStruct_08620240
     const u16 *unk4[6];
 };
 
-const struct UnkStruct_08620240 gUnknown_08620240[5] = 
+static const struct UnkStruct_08620240 gUnknown_08620240[5] =
 {
     {
         0x2A,
-        0x14,
-        {gUnknown_0862020C, gUnknown_08620210, gUnknown_0862021C, NULL, NULL, NULL}
+            0x14,
+            {gUnknown_0862020C, gUnknown_08620210, gUnknown_0862021C}
     },
     {
         0x2A,
-        0x14,
-        {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_0862021C, NULL, NULL}
+            0x14,
+            {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_0862021C}
     },
     {
         0x2A,
-        0x14,
-        {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_08620218, gUnknown_0862021C, NULL}
+            0x14,
+            {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_08620218, gUnknown_0862021C}
     },
     {
         0x38,
-        0x14,
-        {gUnknown_08620220, gUnknown_08620224, gUnknown_0862023C, NULL, NULL, NULL}
+            0x14,
+            {gUnknown_08620220, gUnknown_08620224, gUnknown_0862023C}
     },
     {
         0x28,
-        0x10,
-        {gUnknown_08620228, gUnknown_0862022C, gUnknown_08620230, gUnknown_08620234, gUnknown_08620238, gUnknown_0862023C}
+            0x10,
+            {gUnknown_08620228, gUnknown_0862022C, gUnknown_08620230, gUnknown_08620234, gUnknown_08620238, gUnknown_0862023C}
     },
 };
 
-const struct WindowTemplate gUnknown_086202CC = 
+static const struct WindowTemplate gUnknown_086202CC =
 {
     .bg = 1,
     .tilemapLeft = 3,
@@ -158,7 +218,7 @@ const struct WindowTemplate gUnknown_086202CC =
     .baseBlock = 8
 };
 
-const u8 *const gUnknown_086202D4[] = 
+static const u8 *const gUnknown_086202D4[] =
 {
     gUnknown_085EBCC5,
     gUnknown_085EBCE8,
@@ -176,11 +236,11 @@ const u8 *const gUnknown_086202D4[] =
     gUnknown_085EBE41
 };
 
-const u8 gUnknown_0862030C[] = {6, 8, 7};
+static const u8 gUnknown_0862030C[] = {6, 8, 7};
 
-const u8 gUnknown_0862030F[] = {6, 8, 7, 0, 0};
+static const u8 gUnknown_0862030F[] = {6, 8, 7, 0, 0};
 
-const struct OamData gUnknown_08620314 = 
+static const struct OamData gUnknown_08620314 =
 {
     .y = 0,
     .affineMode = 0,
@@ -194,26 +254,26 @@ const struct OamData gUnknown_08620314 =
     .paletteNum = 0,
 };
 
-const union AffineAnimCmd gUnknown_0862031C[] =
+static const union AffineAnimCmd gUnknown_0862031C[] =
 {
     AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
     AFFINEANIMCMD_END,
 };
 
-const union AffineAnimCmd gUnknown_0862032C[] =
+static const union AffineAnimCmd gUnknown_0862032C[] =
 {
     AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
     AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0x12),
     AFFINEANIMCMD_END,
 };
 
-const union AffineAnimCmd *const gUnknown_08620344[] =
+static const union AffineAnimCmd *const gUnknown_08620344[] =
 {
     gUnknown_0862031C,
-    gUnknown_0862032C
+        gUnknown_0862032C
 };
 
-const struct SpriteTemplate gUnknown_0862034C =
+static const struct SpriteTemplate gUnknown_0862034C =
 {
     .tileTag = 3,
     .paletteTag = 4,
@@ -224,7 +284,7 @@ const struct SpriteTemplate gUnknown_0862034C =
     .callback = SpriteCallbackDummy,
 };
 
-const struct OamData gUnknown_08620364 = 
+static const struct OamData gUnknown_08620364 =
 {
     .y = 0,
     .affineMode = 0,
@@ -238,7 +298,7 @@ const struct OamData gUnknown_08620364 =
     .paletteNum = 0,
 };
 
-const struct SpriteTemplate gUnknown_0862036C =
+static const struct SpriteTemplate gUnknown_0862036C =
 {
     .tileTag = 1,
     .paletteTag = 3,
@@ -249,25 +309,967 @@ const struct SpriteTemplate gUnknown_0862036C =
     .callback = SpriteCallbackDummy,
 };
 
-const struct ScanlineEffectParams gUnknown_08620384 = 
+static const struct ScanlineEffectParams gUnknown_08620384 =
 {
     (void *)REG_ADDR_WIN0H,
-    ((DMA_ENABLE | DMA_START_HBLANK | DMA_REPEAT | DMA_DEST_RELOAD) << 16) | 1,
-    1,
-    0
+        ((DMA_ENABLE | DMA_START_HBLANK | DMA_REPEAT | DMA_DEST_RELOAD) << 16) | 1,
+        1,
+        0
 };
 
-bool32 sub_81C98D4(void)
+static bool32 sub_81C98D4(void)
 {
     s32 i;
 
     for (i = 0; i < REMATCH_TABLE_ENTRIES; i++)
     {
         if (sub_81CB0C8(i) == gMapHeader.regionMapSectionId
-         && sub_81CAE08(i)
-         && gSaveBlock1Ptr->trainerRematches[i])
+            && sub_81CAE08(i)
+            && gSaveBlock1Ptr->trainerRematches[i])
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+bool32 sub_81C9924(void)
+{
+    struct Pokenav2Struct * unk = sub_81C9958();
+
+    if (unk == NULL)
+        return FALSE;
+    
+    unk->field_00d = 0;
+    return TRUE;
+}
+
+bool32 sub_81C9940(void)
+{
+    struct Pokenav2Struct * unk = sub_81C9958();
+
+    if (unk == NULL)
+        return FALSE;
+
+    unk->field_00d = 1;
+    return TRUE;
+}
+
+static struct Pokenav2Struct * sub_81C9958(void)
+{
+    struct Pokenav2Struct * unk = AllocSubstruct(2, sizeof(struct Pokenav2Struct));
+
+    if (unk != NULL)
+    {
+        unk->otherIconsInMotion = FALSE;
+        unk->loopedTaskId = CreateLoopedTask(sub_81C9A10, 1);
+        unk->callback = sub_81C99FC;
+    }
+
+    return unk;
+}
+
+
+void sub_81C9990(s32 ltIdx)
+{
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    unk->loopedTaskId = CreateLoopedTask(gUnknown_086201A0[ltIdx], 1);
+    unk->callback = sub_81C99FC;
+}
+
+bool32 sub_81C99C0(void)
+{
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    return unk->callback();
+}
+
+void sub_81C99D4(void)
+{
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    sub_81CA7F4();
+    RemoveWindow(unk->optionDescriptionWindowId);
+    sub_81C9FEC();
+    sub_81CA994();
+    FreePokenavSubstruct(2);
+}
+
+static bool32 sub_81C99FC(void)
+{
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    return IsLoopedTaskActive(unk->loopedTaskId);
+}
+
+static u32 sub_81C9A10(s32 state)
+{
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    switch (state)
+    {
+    case 0:
+        InitBgTemplates(gUnknown_08620194, ARRAY_COUNT(gUnknown_08620194));
+        decompress_and_copy_tile_data_to_vram(1, gPokenavMessageBox_Gfx, 0, 0, 0);
+        SetBgTilemapBuffer(1, unk->bg1TilemapBuffer);
+        CopyToBgTilemapBuffer(1, gPokenavMessageBox_Tilemap, 0, 0);
+        CopyBgTilemapBufferToVram(1);
+        CopyPaletteIntoBufferUnfaded(gPokenavMessageBox_Pal, 0x10, 0x20);
+        ChangeBgX(1, 0, 0);
+        ChangeBgY(1, 0, 0);
+        ChangeBgX(2, 0, 0);
+        ChangeBgY(2, 0, 0);
+        ChangeBgX(3, 0, 0);
+        ChangeBgY(3, 0, 0);
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (free_temp_tile_data_buffers_if_possible())
+            return LT_PAUSE;
+        decompress_and_copy_tile_data_to_vram(2, gUnknown_0861FD6C, 0, 0, 0);
+        decompress_and_copy_tile_data_to_vram(2, gUnknown_0861FFF4, 0, 0, 1);
+        CopyPaletteIntoBufferUnfaded(gUnknown_0861FD4C, 0x20, 0x20);
+        return LT_INC_AND_PAUSE;
+    case 2:
+        if (free_temp_tile_data_buffers_if_possible())
+            return LT_PAUSE;
+        decompress_and_copy_tile_data_to_vram(3, gUnknown_0861FC98, 0, 0, 0);
+        decompress_and_copy_tile_data_to_vram(3, gUnknown_0861FCAC, 0, 0, 1);
+        CopyPaletteIntoBufferUnfaded(gUnknown_0861FC78, 0x30, 0x20);
+        if (sub_81C9894() == 3 || sub_81C9894() == 4)
+            sub_81CA850();
+        return LT_INC_AND_PAUSE;
+    case 3:
+        if (free_temp_tile_data_buffers_if_possible())
+            return LT_PAUSE;
+        sub_81CA6E0();
+        sub_81CA7D4();
+        return LT_INC_AND_CONTINUE;
+    case 4:
+        sub_81C9FC4();
+        return LT_INC_AND_CONTINUE;
+    case 5:
+        sub_81CA714();
+        sub_81CA02C();
+        sub_81CA640();
+        sub_81CA0C8();
+        return LT_INC_AND_PAUSE;
+    case 6:
+        if (sub_81CA7C4())
+            return LT_PAUSE;
+        return LT_INC_AND_CONTINUE;
+    case 7:
+        ShowBg(1);
+        ShowBg(2);
+        ShowBg(3);
+        if (unk->field_00d)
+            sub_81C7AC0(1);
+        else
+        {
+            PlaySE(SE_PN_ON);
+            sub_81C7AC0(3);
+        }
+        switch (sub_81C9894())
+        {
+        case 4:
+            LoadLeftHeaderGfxForIndex(7);
+            // fallthrough
+        case 3:
+            LoadLeftHeaderGfxForIndex(1);
+            break;
+        default:
+            LoadLeftHeaderGfxForIndex(0);
+            break;
+        }
+        return LT_INC_AND_PAUSE;
+    case 8:
+        if (IsPaletteFadeActive())
+            return LT_PAUSE;
+        switch (sub_81C9894())
+        {
+        case 4:
+            sub_81C7FA0(7, FALSE, FALSE);
+            // fallthrough
+        case 3:
+            sub_81C7FA0(1, FALSE, FALSE);
+            break;
+        default:
+            sub_81C7FA0(0, FALSE, FALSE);
+            break;
+        }
+        sub_81CA20C();
+        sub_81CA92C();
+        return LT_INC_AND_CONTINUE;
+    case 9:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9C6C(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        sub_81CAA3C();
+        sub_81CA278();
+        sub_81CA714();
+        PlaySE(SE_SELECT);
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81CA7C4())
+            return LT_PAUSE;
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9CA8(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        sub_81CA9C8();
+        sub_81CA2DC();
+        sub_81C7FC4(0, 0);
+        PlaySE(SE_SELECT);
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        sub_81CA0C8();
+        LoadLeftHeaderGfxForIndex(1);
+        return LT_INC_AND_PAUSE;
+    case 2:
+        sub_81CA20C();
+        sub_81C7FA0(1, FALSE, FALSE);
+        sub_81CA818();
+        sub_81CA714();
+        return LT_INC_AND_PAUSE;
+    case 3:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        if (sub_81CA89C())
+            return LT_PAUSE;
+        if (sub_81CA7C4())
+            return LT_PAUSE;
+        sub_81CA9D8();
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9D44(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        sub_81CA9C8();
+        sub_81CA2DC();
+        sub_81C7FC4(1, 0);
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        sub_81CA0C8();
+        LoadLeftHeaderGfxForIndex(0);
+        return LT_INC_AND_PAUSE;
+    case 2:
+        sub_81CA20C();
+        sub_81C7FA0(0, FALSE, FALSE);
+        sub_81CA864();
+        sub_81CA714();
+        return LT_INC_AND_PAUSE;
+    case 3:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        if (sub_81CA89C())
+            return LT_PAUSE;
+        if (sub_81CA7C4())
+            return LT_PAUSE;
+        sub_81CA9D8();
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9DD8(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        sub_81CA9C8();
+        sub_81CA2DC();
+        PlaySE(SE_SELECT);
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        LoadLeftHeaderGfxForIndex(7);
+        sub_81CA0C8();
+        return LT_INC_AND_PAUSE;
+    case 2:
+        sub_81CA20C();
+        sub_81C7FA0(7, FALSE, FALSE);
+        sub_81CA714();
+        return LT_INC_AND_PAUSE;
+    case 3:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        if (sub_81CA89C())
+            return LT_PAUSE;
+        sub_81CA9D8();
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9E58(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        sub_81CA9C8();
+        sub_81CA2DC();
+        sub_81C7FC4(7, 0);
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        sub_81CA0C8();
+        return LT_INC_AND_PAUSE;
+    case 2:
+        sub_81CA20C();
+        sub_81CA714();
+        return LT_INC_AND_PAUSE;
+    case 3:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81CA89C())
+            return LT_PAUSE;
+        sub_81CA9D8();
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9EC8(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        PlaySE(SE_HAZURE);
+        sub_81CA770();
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (IsDma3ManagerBusyWithBgCopy())
+            return LT_PAUSE;
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9EF8(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        PlaySE(SE_SELECT);
+        sub_81CA714();
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (IsDma3ManagerBusyWithBgCopy())
+            return LT_PAUSE;
+        break;
+    }
+    return LT_FINISH;
+}
+
+static u32 sub_81C9F28(s32 state)
+{
+    switch (state)
+    {
+    case 0:
+        sub_81C7BA4(sub_81C98C4());
+        return LT_INC_AND_PAUSE;
+    case 1:
+        if (IsDma3ManagerBusyWithBgCopy_())
+            return LT_PAUSE;
+        sub_81C7880();
+        sub_81CA9C8();
+        sub_81CA2DC();
+        switch (sub_81C9894())
+        {
+        case 4:
+            sub_81C7FC4(7, FALSE);
+            // fallthrough
+        case 3:
+            sub_81C7FC4(1, FALSE);
+            break;
+        default:
+            sub_81C7FC4(0, FALSE);
+            break;
+        }
+        PlaySE(SE_SELECT);
+        return LT_INC_AND_PAUSE;
+    case 2:
+        if (sub_81CA324())
+            return LT_PAUSE;
+        if (sub_81C8010())
+            return LT_PAUSE;
+        sub_81C7AC0(0);
+        return LT_INC_AND_PAUSE;
+    case 3:
+        if (IsPaletteFadeActive())
+            return LT_PAUSE;
+        break;
+    }
+    return LT_FINISH;
+}
+
+static void sub_81C9FC4(void)
+{
+    s32 i;
+
+    for (i = 0; i < NELEMS(gUnknown_086201C4); i++)
+        LoadCompressedSpriteSheet(&gUnknown_086201C4[i]);
+    Pokenav_AllocAndLoadPalettes(gUnknown_086201D4);
+}
+
+static void sub_81C9FEC(void)
+{
+    FreeSpriteTilesByTag(3);
+    FreeSpriteTilesByTag(1);
+    FreeSpritePaletteByTag(4);
+    FreeSpritePaletteByTag(5);
+    FreeSpritePaletteByTag(6);
+    FreeSpritePaletteByTag(7);
+    FreeSpritePaletteByTag(8);
+    FreeSpritePaletteByTag(3);
+    sub_81CA094();
+    sub_81CA698();
+}
+
+static void sub_81CA02C(void)
+{
+    s32 i, j;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    for (i = 0; i < 6; i++)
+    {
+        for (j = 0; j < 4; j++)
+        {
+            u8 spriteId = CreateSprite(&gUnknown_0862034C, 0x8c, 20 * i + 40, 3);
+            unk->iconSprites[i][j] = &gSprites[spriteId];
+            gSprites[spriteId].pos2.x = 32 * j;
+        }
+    }
+}
+
+static void sub_81CA094(void)
+{
+    s32 i, j;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    for (i = 0; i < 6; i++)
+    {
+        for (j = 0; j < 4; j++)
+        {
+            FreeSpriteOamMatrix(unk->iconSprites[i][j]);
+            DestroySprite(unk->iconSprites[i][j]);
+        }
+    }
+}
+
+static void sub_81CA0C8(void)
+{
+    s32 r0 = sub_81C9894();
+    sub_81CA0EC(gUnknown_08620240[r0].unk4, gUnknown_08620240[r0].unk0, gUnknown_08620240[r0].unk2);
+}
+
+static void sub_81CA0EC(const u16 *const *a0, s32 a1, s32 a2)
+{
+    s32 i, j;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+    s32 sp04 = GetSpriteTileStartByTag(3);
+
+    for (i = 0; i < 6; i++)
+    {
+        if (*a0 != NULL)
+        {
+            for (j = 0; j < 4; j++)
+            {
+                unk->iconSprites[i][j]->oam.tileNum = (*a0)[0] + sp04 + 8 * j;
+                unk->iconSprites[i][j]->oam.paletteNum = IndexOfSpritePaletteTag((*a0)[1] + 4);
+                unk->iconSprites[i][j]->invisible = TRUE;
+                unk->iconSprites[i][j]->pos1.y = a1;
+                unk->iconSprites[i][j]->pos1.x = 0x8c;
+                unk->iconSprites[i][j]->pos2.x = 32 * j;
+            }
+            unk->iconVisible[i] = TRUE;
+        }
+        else
+        {
+            for (j = 0; j < 4; j++)
+            {
+                unk->iconSprites[i][j]->invisible = TRUE;
+            }
+            unk->iconVisible[i] = FALSE;
+        }
+        a0++;
+        a1 += a2;
+    }
+}
+
+static void sub_81CA20C(void)
+{
+    s32 i;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+    s32 r8 = sub_81C98A4();
+    s32 r7 = 0;
+    s32 r2;
+
+    for (i = 0; i < 6; i++)
+    {
+        if (unk->iconVisible[i])
+        {
+            if (r7++ == r8)
+            {
+                r2 = 0x82;
+                unk->cursorPos = i;
+            }
+            else
+                r2 = 0x8c;
+            sub_81CA35C(unk->iconSprites[i], 0x100, r2, 0xC);
+            sub_81CA448(unk->iconSprites[i], FALSE);
+        }
+        else
+            sub_81CA448(unk->iconSprites[i], TRUE);
+    }
+}
+
+static void sub_81CA278(void)
+{
+    s32 i;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+    s32 r3 = sub_81C98A4();
+    s32 r5;
+
+    for (i = 0, r5 = 0; i < 6; i++)
+    {
+        if (unk->iconVisible[i])
+        {
+            if (r5 == r3)
+            {
+                r5 = i;
+                break;
+            }
+            r5++;
+        }
+    }
+
+    sub_81CA35C(unk->iconSprites[unk->cursorPos], 0x82, 0x8c, 0x4);
+    sub_81CA35C(unk->iconSprites[r5], 0x8c, 0x82, 0x4);
+    unk->cursorPos = r5;
+}
+
+static void sub_81CA2DC(void)
+{
+    s32 i;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    for (i = 0; i < 6; i++)
+    {
+        if (unk->iconVisible[i])
+        {
+            if (unk->cursorPos != i)
+                sub_81CA35C(unk->iconSprites[i], 0x8C, 0x100, 0x8);
+            else
+                sub_81CA3B4(unk->iconSprites[i]);
+        }
+    }
+}
+
+static bool32 sub_81CA324(void)
+{
+    s32 i;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+
+    for (i = 0; i < 6; i++)
+    {
+        if (unk->iconSprites[i][0]->callback != SpriteCallbackDummy)
             return TRUE;
     }
 
+    if (unk->otherIconsInMotion)
+        return TRUE;
+
     return FALSE;
 }
+
+static void sub_81CA35C(struct Sprite ** sprites, s32 a1, s32 a2, s32 a3)
+{
+    s32 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        (*sprites)->pos1.x = a1;
+        (*sprites)->data[0] = a3;
+        (*sprites)->data[1] = 16 * (a2 - a1) / a3;
+        (*sprites)->data[2] = 16 * a1;
+        (*sprites)->data[7] = a2;
+        (*sprites)->callback = sub_81CA474;
+        sprites++;
+    }
+}
+
+static void sub_81CA3B4(struct Sprite ** sprites)
+{
+    s32 i;
+    struct Pokenav2Struct * unk = GetSubstructPtr(2);
+    u8 taskId;
+
+    for (i = 0; i < 4; i++)
+    {
+        (*sprites)->oam.objMode = ST_OAM_OBJ_BLEND;
+        (*sprites)->oam.affineMode = ST_OAM_AFFINE_DOUBLE;
+        (*sprites)->callback = sub_81CA4AC;
+        (*sprites)->data[0] = 8;
+        (*sprites)->data[1] = 0;
+        (*sprites)->data[7] = i;
+        InitSpriteAffineAnim(sprites[0]);
+        StartSpriteAffineAnim(sprites[0], 0);
+        sprites++;
+    }
+
+    SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x10, 0x00));
+    taskId = CreateTask(sub_81CA580, 3);
+    gTasks[taskId].data[0] = 8;
+    unk->otherIconsInMotion++;
+}
+
+static void sub_81CA448(struct Sprite ** sprites, bool32 a1)
+{
+    s32 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        (*sprites)->invisible = a1;
+        sprites++;
+    }
+}
+
+static void sub_81CA474(struct Sprite * sprite)
+{
+    sprite->data[0]--;
+    if (sprite->data[0] != -1)
+    {
+        sprite->data[2] += sprite->data[1];
+        sprite->pos1.x = sprite->data[2] >> 4;
+    }
+    else
+    {
+        sprite->pos1.x = sprite->data[7];
+        sprite->callback = SpriteCallbackDummy;
+    }
+}
+
+static void sub_81CA4AC(struct Sprite * sprite)
+{
+    s32 r0;
+    s32 r1;
+    if (sprite->data[0] == 0)
+    {
+        if (sprite->data[1] == 0)
+        {
+            StartSpriteAffineAnim(sprite, 1);
+            sprite->data[1]++;
+            sprite->data[2] = 0x100;
+            sprite->pos1.x += sprite->pos2.x;
+            sprite->pos2.x = 0;
+        }
+        else
+        {
+            sprite->data[2] += 16;
+            r0 = sprite->data[2];
+            r1 = r0 >> 3;
+            r1 = (r1 - 32) / 2;
+            switch (sprite->data[7])
+            {
+            case 0:
+                sprite->pos2.x = -r1 * 3;
+                break;
+            case 1:
+                sprite->pos2.x = -r1;
+                break;
+            case 2:
+                sprite->pos2.x = r1;
+                break;
+            case 3:
+                sprite->pos2.x = r1 * 3;
+                break;
+            }
+            if (sprite->affineAnimEnded)
+            {
+                sprite->invisible = TRUE;
+                FreeOamMatrix(sprite->oam.matrixNum);
+                CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, 0);
+                sprite->oam.affineMode = ST_OAM_AFFINE_OFF;
+                sprite->oam.objMode = ST_OAM_OBJ_NORMAL;
+                sprite->callback = SpriteCallbackDummy;
+            }
+        }
+    }
+    else
+    {
+        sprite->data[0]--;
+    }
+}
+
+static void sub_81CA580(u8 taskId)
+{
+    s16 * data = gTasks[taskId].data;
+
+    if (data[0] == 0)
+    {
+        switch (data[1])
+        {
+        case 0:
+            data[2] = 16;
+            data[3] = 0;
+            SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_NONE | BLDCNT_TGT2_ALL);
+            SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x10, 0x00));
+            data[1]++;
+            break;
+        case 1:
+            if (data[4] & 1)
+            {
+                data[2] -= 3;
+                if (data[2] < 0)
+                    data[2] = 0;
+            }
+            else
+            {
+                data[3] += 3;
+                if (data[3] > 16)
+                    data[3] = 16;
+            }
+            SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(data[2], data[3]));
+            data[4]++;
+            if (data[4] == 12)
+            {
+                ((struct Pokenav2Struct *)GetSubstructPtr(2))->otherIconsInMotion--;
+                SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x00, 0x10));
+                DestroyTask(taskId);
+            }
+            break;
+        }
+    }
+    else
+        data[0]--;
+}
+
+static void sub_81CA640(void)
+{
+    struct Pokenav2Struct * ptr = GetSubstructPtr(2);
+    u8 spriteId = CreateSprite(&gUnknown_0862036C, 0x10, 0x60, 4);
+    ptr->field_028 = &gSprites[spriteId];
+    if (sub_81C98D4())
+        ptr->field_028->callback = sub_81CA6AC;
+    else
+        ptr->field_028->invisible = TRUE;
+}
+
+static void sub_81CA698(void)
+{
+    struct Pokenav2Struct * ptr = GetSubstructPtr(2);
+    DestroySprite(ptr->field_028);
+}
+
+static void sub_81CA6AC(struct Sprite * sprite)
+{
+    sprite->data[0]++;
+    if (sprite->data[0] > 8)
+    {
+        sprite->data[0] = 0;
+        sprite->invisible ^= 1;
+    }
+}
+
+static void sub_81CA6E0(void)
+{
+    struct Pokenav2Struct * ptr = GetSubstructPtr(2);
+
+    ptr->optionDescriptionWindowId = AddWindow(&gUnknown_086202CC);
+    PutWindowTilemap(ptr->optionDescriptionWindowId);
+    FillWindowPixelBuffer(ptr->optionDescriptionWindowId, PIXEL_FILL(6));
+    CopyWindowToVram(ptr->optionDescriptionWindowId, 3);
+}
+
+static void sub_81CA714(void)
+{
+    struct Pokenav2Struct * ptr = GetSubstructPtr(2);
+    int i = sub_81C98B4();
+    const u8 * s = gUnknown_086202D4[i];
+    u32 width = GetStringWidth(1, s, -1);
+    FillWindowPixelBuffer(ptr->optionDescriptionWindowId, PIXEL_FILL(6));
+    AddTextPrinterParameterized3(ptr->optionDescriptionWindowId, 1, (192 - width) / 2, 1, gUnknown_0862030C, 0, s);
+}
+
+
+static void sub_81CA770(void)
+{
+    struct Pokenav2Struct * ptr = GetSubstructPtr(2);
+    const u8 * s = gText_NoRibbonWinners;
+    u32 width = GetStringWidth(1, s, -1);
+    FillWindowPixelBuffer(ptr->optionDescriptionWindowId, PIXEL_FILL(6));
+    AddTextPrinterParameterized3(ptr->optionDescriptionWindowId, 1, (192 - width) / 2, 1, gUnknown_0862030F, 0, s);
+}
+
+static bool32 sub_81CA7C4(void)
+{
+    return IsDma3ManagerBusyWithBgCopy();
+}
+
+static void sub_81CA7D4(void)
+{
+    struct Pokenav2Struct * ptr = GetSubstructPtr(2);
+    ptr->bg3ScrollTaskId = CreateTask(sub_81CA808, 2);
+}
+
+static void sub_81CA7F4(void)
+{
+    struct Pokenav2Struct * ptr = GetSubstructPtr(2);
+    DestroyTask(ptr->bg3ScrollTaskId);
+}
+
+static void sub_81CA808(u8 taskId)
+{
+    ChangeBgX(3, 0x80, 1);
+}
+
+static void sub_81CA818(void)
+{
+    u8 taskId = CreateTask(sub_81CA8B0, 3);
+    SetWordTaskArg(taskId, 1, (uintptr_t)(gUnknown_0861FC78 + 1));
+    SetWordTaskArg(taskId, 3, (uintptr_t)(gUnknown_0861FC78 + 7));
+}
+
+static void sub_81CA850(void)
+{
+    CopyPaletteIntoBufferUnfaded(gUnknown_0861FC78 + 7, 0x31, 4);
+}
+
+static void sub_81CA864(void)
+{
+    u8 taskId = CreateTask(sub_81CA8B0, 3);
+    SetWordTaskArg(taskId, 1, (uintptr_t)(gUnknown_0861FC78 + 7));
+    SetWordTaskArg(taskId, 3, (uintptr_t)(gUnknown_0861FC78 + 1));
+}
+
+static bool32 sub_81CA89C(void)
+{
+    return FuncIsActiveTask(sub_81CA8B0);
+}
+
+static void sub_81CA8B0(u8 taskId)
+{
+    u16 sp8[2];
+    s16 * data = gTasks[taskId].data;
+    const u16 * pal1 = (const u16 *)GetWordTaskArg(taskId, 1);
+    const u16 * pal2 = (const u16 *)GetWordTaskArg(taskId, 3);
+
+    sub_81C79BC(pal1, pal2, 2, 12, ++data[0], sp8);
+    LoadPalette(sp8, 0x31, 4);
+    if (data[0] == 12)
+        DestroyTask(taskId);
+}
+
+static void sub_81CA914(void)
+{
+    TransferPlttBuffer();
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    ScanlineEffect_InitHBlankDmaTransfer();
+}
+
+static void sub_81CA92C(void)
+{
+    SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_LIGHTEN);
+    SetGpuReg(REG_OFFSET_BLDY, 0);
+    SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+    SetGpuRegBits(REG_OFFSET_WININ, 0x3F);
+    SetGpuRegBits(REG_OFFSET_WINOUT, 0x1F);
+    SetGpuRegBits(REG_OFFSET_WIN0V, 0xA0);
+    ScanlineEffect_Stop();
+    sub_81CAA3C();
+    ScanlineEffect_SetParams(gUnknown_08620384);
+    SetVBlankCallback_(sub_81CA914);
+    CreateTask(sub_81CA9EC, 3);
+}
+
+static void sub_81CA994(void)
+{
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+    ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+    ScanlineEffect_Stop();
+    DestroyTask(FindTaskIdByFunc(sub_81CA9EC));
+    SetPokenavVBlankCallback();
+}
+
+static void sub_81CA9C8(void)
+{
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+}
+
+static void sub_81CA9D8(void)
+{
+    sub_81CAA3C();
+    SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_LIGHTEN);
+}
+
+static void sub_81CA9EC(u8 taskId)
+{
+    s16 * data = gTasks[taskId].data;
+    data[0]++;
+    if (data[0] > 0)
+    {
+        data[0] = 0;
+        data[1] += 3;
+        data[1] &= 0x7F;
+        SetGpuReg(REG_OFFSET_BLDY, gSineTable[data[1]] >> 5);
+    }
+}
+
+static void sub_81CAA3C(void)
+{
+    int i = sub_81C9894();
+    int j = sub_81C98A4();
+    int r4 = gUnknown_08620240[i].unk2 * j + gUnknown_08620240[i].unk0 - 8;
+    CpuFill16(0, gScanlineEffectRegBuffers[0], 0x140);
+    CpuFill16(0, gScanlineEffectRegBuffers[1], 0x140);
+    CpuFill16(RGB(16, 23, 28), &gScanlineEffectRegBuffers[0][r4], 0x20);
+    CpuFill16(RGB(16, 23, 28), &gScanlineEffectRegBuffers[1][r4], 0x20);
+}
+
+void sub_81CAADC(void)
+{
+    sub_81CA9C8();
+}
diff --git a/src/trainer_hill.c b/src/trainer_hill.c
index 650a748cb..77c8fcb53 100644
--- a/src/trainer_hill.c
+++ b/src/trainer_hill.c
@@ -915,7 +915,7 @@ void SetHillTrainerFlag(void)
     }
 }
 
-const u8 *sub_81D62AC(void)
+const u8 *GetTrainerHillTrainerScript(void)
 {
     return EventScript_2C83F0;
 }
diff --git a/src/trainer_see.c b/src/trainer_see.c
index 9925aa6bc..22b256a99 100644
--- a/src/trainer_see.c
+++ b/src/trainer_see.c
@@ -235,7 +235,7 @@ static u8 CheckTrainer(u8 eventObjectId)
     u8 approachDistance;
 
     if (InTrainerHill() == TRUE)
-        scriptPtr = sub_81D62AC();
+        scriptPtr = GetTrainerHillTrainerScript();
     else
         scriptPtr = GetEventObjectScriptPointerByEventObjectId(eventObjectId);