Merge remote-tracking branch 'zeldaret/main' into hammer

src/00_Core/Actor/Actor.cpp

@@ -860,7 +860,7 @@ ARM bool Actor::func_ov00_020c3094() {
     Vec3p pos, prevPos;
     Vec3p_Copy(&mPos, &pos);
     Vec3p_Copy(&mPrevPos, &prevPos);
-    s32 unk1 = gMapManager->func_ov00_02083ef8(&pos, &prevPos, 0);
+    s32 unk1 = gMapManager->func_ov00_02083ef8(&pos, &prevPos, false);
     if (mPos.y <= unk1) {
         result = true;
         mPos.y = unk1;
@@ -886,7 +886,7 @@ ARM bool Actor::func_ov00_020c313c(u32 param1) {
 
 ARM void Actor::func_ov00_020c3158() {
     if (mUnk_03c < 0) return;
-    gMapManager->func_ov00_02084c5c(mUnk_03c, 1);
+    gMapManager->SetMapDataFlag1(mUnk_03c, 1);
 }
 
 ARM void Actor::Kill() {

src/00_Core/Actor/ActorSpawner.cpp

@@ -68,8 +68,8 @@ ARM s32 ActorSpawner::Spawn(ActorTypeId type, Vec3p *pos, ActorSpawnOptions *opt
         Actor *actor2          = *actorSlot;
         actor2->mPos           = *pos;
         actor2->mPrevPos       = *pos;
-        (*actorSlot)->mUnk_010 = gMapManager->GetCourseData_Unk_1c();
-        (*actorSlot)->mUnk_011 = gMapManager->GetCourseData_Unk_1d();
+        (*actorSlot)->mUnk_010 = gMapManager->GetCurrentMapPosX();
+        (*actorSlot)->mUnk_011 = gMapManager->GetCurrentMapPosY();
         u16 nextIndex          = index + 1;
         if (actorManager->mMaxActorIndex < nextIndex) {
             actorManager->mMaxActorIndex = nextIndex;

src/00_Core/Map/Course.cpp

@@ -15,7 +15,7 @@ void Course::GetMCSFilePath(unk32 buf, s32 fileIndex, unk32 fileType) {}
 void Course::GetMRCFilePath(unk32 param_2, unk32 buf, unk32 param_4) {}
 void Course::func_ov00_0207ce20(unk32 param_2, unk32 param_3, char *param_4, unk32 param_5) {}
 void Course::func_ov00_0207ce4c(s32 param_2, s32 param_3, unk32 param_4, char *param_5, unk32 param_6) {}
-bool Course::func_ov00_0207d404(s32 param_2, unk32 param_3, unk32 param_4) {}
+bool Course::func_ov00_0207d404(s32 param_2, unk32 param_3, unk32 param_4, unk32 param_5) {}
 bool Course::IsCurrentMapInMainGrid() {}
 bool Course::IsInMainGrid(s32 x, s32 y) {}
 bool Course::IsMapInMainGrid(u32 map) {}
@@ -45,7 +45,7 @@ void Course::SetMapDataFlag2(unk32 param_2, bool param_3) {}
 bool Course::GetMapDataFlag2(unk32 param_2) {}
 void Course::SetMapDataFlag3(unk32 param_2, bool param_3) {}
 bool Course::GetMapDataFlag3(unk32 param_2) {}
-void Course::SetMapDataFlag4(unk32 param_2, unk32 param_3) {}
+void Course::SetMapDataFlag4(unk32 param_2, bool param_3) {}
 bool Course::GetMapDataFlag4(unk32 param_2) {}
 MapData *Course::FindMapData(u32 map) {}
 MapData *Course::FindCurrentMapData() {}

src/00_Core/Map/MapBase.cpp

@@ -11,25 +11,25 @@ void MapBase::func_ov00_0207ddf8(bool param_2) {}
 void MapBase::func_ov00_0207de68(unk32 param_2) {}
 void MapBase::func_ov00_0207de88() {}
 void MapBase::func_ov00_0207dea0(bool param_2) {}
-unk8 MapBase::vfunc_b0(unk32 param_2, unk32 param_3) {}
-bool MapBase::func_ov00_0207e08c(unk32 param_2, unk32 param_3) {}
-s32 MapBase::func_ov00_0207e0f0(unk32 param_2) {}
-s32 MapBase::func_ov00_0207e28c(unk32 param_2) {}
+void MapBase::vfunc_b0(unk32 param_2, unk32 param_3) {}
+bool MapBase::func_ov00_0207e08c(s32 *param_2, s32 param_3) {}
+s32 MapBase::func_ov00_0207e0f0(s32 param_2) {}
+s32 MapBase::func_ov00_0207e28c(s32 param_2) {}
 void MapBase::vfunc_b4() {}
 void MapBase::vfunc_48() {}
 unk32 MapBase::vfunc_50() {}
-unk32 MapBase::vfunc_54() {}
-unk32 MapBase::vfunc_58() {}
+unk32 MapBase::vfunc_54(Vec2b *param_1) {}
+unk32 MapBase::vfunc_58(Vec2b *param_1, int param_2) {}
 unk32 MapBase::vfunc_5c() {}
-unk32 MapBase::vfunc_60() {}
+unk32 MapBase::vfunc_60(Vec2b *param_1) {}
 unk32 MapBase::vfunc_64() {}
-unk8 MapBase::vfunc_68(unk32 param_2, unk32 param_3) {}
+unk32 MapBase::vfunc_68(Vec3p *param_1, bool param_2) {}
 unk8 MapBase::func_ov00_0207e940(unk8 *param_1) {}
 unk8 MapBase::func_ov00_0207e968() {}
 unk8 MapBase::func_ov00_0207e96c() {}
 unk8 MapBase::vfunc_6c(unk32 param_2, unk32 param_3, unk32 param_4) {}
 unk32 MapBase::vfunc_70(Vec3p *param_2) {}
-s32 *MapBase::vfunc_74(Vec3p *param_2) {}
+unk32 *MapBase::vfunc_74(Vec3p *param_2) {}
 unk8 MapBase::func_ov00_0207f100() {}
 bool MapBase::func_ov00_0207f104(unk32 param_2, unk32 param_3) {}
 unk32 MapBase::func_ov00_0207f1f4(Vec3p *param_2, unk32 *param_3) {}
@@ -37,15 +37,15 @@ unk32 MapBase::vfunc_88() {}
 unk32 MapBase::vfunc_8c() {}
 void MapBase::vfunc_9c() {}
 void MapBase::vfunc_a0() {}
-unk32 MapBase::vfunc_a4() {}
+unk32 MapBase::vfunc_a4(unk8 *param_1) {}
 void MapBase::vfunc_a8() {}
 void MapBase::vfunc_ac() {}
-unk32 MapBase::vfunc_78() {}
-unk32 MapBase::vfunc_7c() {}
+unk32 *MapBase::vfunc_78(Vec2b *param_1) {}
+s32 MapBase::vfunc_7c(s32 param_1, unk32 *param_2, s32 param_3, short param_4[4]) {}
 unk32 MapBase::vfunc_80() {}
 void MapBase::vfunc_84(unk32 param_2) {}
-unk8 MapBase::func_ov00_0207f38c(unk32 param_2) {}
-unk8 MapBase::vfunc_90(unk32 param_2, unk32 param_3, unk32 param_4) {}
+bool MapBase::func_ov00_0207f38c(s32 *param_2) {}
+unk8 MapBase::vfunc_90(Vec2b *param_2, unk32 param_3) {}
 void MapBase::vfunc_94() {}
 void MapBase::func_ov00_0207f4a4(Vec2s *param_2, unk32 param_3) {}
 void MapBase::func_ov00_0207f53c(Vec2s *param_1, MapBase *param_2, Vec3p *param_3) {}
@@ -56,54 +56,54 @@ unk8 MapBase::GetTileStartZ(unk32 z) {}
 s32 MapBase::GetTileEndX(unk32 x) {}
 s32 MapBase::GetTileEndZ(unk32 z) {}
 void MapBase::GetTileBounds(Vec2b *tilePos, AABB *bounds) {}
-unk8 MapBase::GetClampedTileX(unk32 worldX) {}
-unk8 MapBase::GetClampedTileY(unk32 worldZ) {}
-unk8 MapBase::GetTileX(unk32 worldX) {}
-unk8 MapBase::GetTileY(unk32 worldZ) {}
+s32 MapBase::GetClampedTileX(s32 worldX) {}
+s32 MapBase::GetClampedTileY(s32 worldZ) {}
+unk8 MapBase::GetTileX(s32 worldX) {}
+unk8 MapBase::GetTileY(s32 worldZ) {}
 bool MapBase::IsInBounds(Vec3p *tileWorldPos) {}
 s32 MapBase::AddEntrance(Entrance *param_2) {}
-unk8 MapBase::FindEntrance(unk32 id) {}
-unk8 MapBase::func_ov00_0207f924(unk32 param_2) {}
+Entrance *MapBase::FindEntrance(unk32 id) {}
+void MapBase::func_ov00_0207f924(s32 param_2) {}
 unk8 MapBase::func_ov00_0207f934() {}
 unk8 MapBase::func_ov00_0207f948(unk32 param_2) {}
 void MapBase::AddTrigger(TriggerParams *param_2) {}
 void TriggerBase::vfunc_08() {}
 s32 MapBase::GetTriggerBoundingBox(unk32 param_2, AABB *param_3) {}
 bool TriggerBase::GetBoundingBox(AABB *bbox) {}
-unk8 MapBase::GetTriggerBoundingBoxes(unk32 param_2, AABB *param_3, unk32 param_4) {}
-unk32 MapBase::GetOverlappingTrigger(Vec3p *param_2) {}
+s32 MapBase::GetTriggerBoundingBoxes(s32 param_2, AABB *param_3, s32 param_4) {}
+bool MapBase::GetOverlappingTrigger(Vec3p *param_2) {}
 bool TriggerBase::Overlaps(Vec3p *point) {}
-unk8 MapBase::FindTrigger(unk32 type) {}
+TriggerBase *MapBase::FindTrigger(unk32 type) {}
 unk8 MapBase::GetOverlappingTriggers(Vec3p *param_2, TriggerBase **triggers, unk32 capacity) {}
 bool MapBase::IsTriggerTypeOverlapped(unk32 type, Vec3p *param_3) {}
 bool MapBase::AnyTrigger_func_0c(unk32 type) {}
 unk32 TriggerBase::vfunc_0c() {}
 unk8 MapBase::Trigger_vfunc_08() {}
 bool MapBase::AddTrigger(unk32 param_2) {}
-bool MapBase::func_ov00_0207ff88(unk32 param_2) {}
+bool MapBase::func_ov00_0207ff88(s32 param_2) {}
 void MapBase::func_ov00_0208005c(s32 param_2, s32 param_3, unk32 param_4) {}
 void MapBase::func_ov00_0208006c(unk32 param_2, s32 param_3) {}
 void MapBase::func_ov00_0208007c(s32 param_2, s32 param_3) {}
 void MapBase::func_ov00_0208008c(u32 param_2) {}
 unk8 MapBase::AddExit(Exit *param_2) {}
-unk8 MapBase::func_ov00_02080140(Exit *param_2) {}
+char MapBase::func_ov00_02080140(Exit *param_2) {}
 void MapBase_Unk1::func_ov00_02080324(s32 param_2, s32 param_3, s32 param_4) {}
-bool MapBase::FindExit(unk32 param_2, Exit *param_3) {}
+bool MapBase::FindExit(u32 param_2, Exit *param_3) {}
 unk8 MapBase::AddCameraViewpoint(CameraViewpoint *param_2) {}
-bool MapBase::FindViewpoint_Unk_4(unk8 id, CameraViewpoint *param_3) {}
-bool MapBase::FindViewpoint_Unk_0(unk32 param_2, CameraViewpoint *param_3) {}
-void MapBase::GetCurrentViewpoint(CameraViewpoint *param_2, unk32 param_3) {}
-unk8 MapBase::GetCurrentViewpoint_Unk_00(s32 param_2) {}
+bool MapBase::FindViewpoint_Unk_4(char id, CameraViewpoint *param_3) {}
+bool MapBase::FindViewpoint_Unk_0(s32 param_2, CameraViewpoint *param_3) {}
+void MapBase::GetCurrentViewpoint(CameraViewpoint *param_2, s32 param_3) {}
+unk32 MapBase::GetCurrentViewpoint_Unk_00(s32 param_2) {}
 unk32 MapBase::vfunc_b8() {}
-bool MapBase::func_ov00_02080824(unk32 param_2, unk32 param_3) {}
-bool MapBase::AddUnk_130(unk32 param_2) {}
-bool MapBase::func_ov00_020809b8(unk32 param_2) {}
+bool MapBase::func_ov00_02080824(u32 param_2, unk8 *param_3) {}
+bool MapBase::AddUnk_130(s32 param_2) {}
+bool MapBase::func_ov00_020809b8(s32 param_2) {}
 unk8 MapBase::func_ov00_02080a78(Vec3p *param_2) {}
 void MapBase_Unk2::func_ov00_02080ad0(TriggerBase **param_2, TriggerBase **param_3) {}
 unk8 MapBase::func_ov00_02080b24(Vec2b *param_2) {}
 void MapBase::func_ov00_02080d08(unk32 param_2) {}
 void MapBase::vfunc_bc() {}
-void MapBase::vfunc_98() {}
+void MapBase::vfunc_98(unk32 param_2, unk32 param_3, unk32 param_4) {}
 void MapBase::vfunc_c0() {}
 bool MapBase::TriggerOfType_vfunc_10(unk32 type) {}
 unk32 TriggerBase::vfunc_10() {}

src/04_Load/Map/MapManager.cpp

@@ -7,5 +7,5 @@ void MapManager::Destroy() {}
 void MapManager::LoadMapTexSprites(s32 param1) {}
 void MapManager::func_ov004_02102260() {}
 void MapManager::func_ov004_02102264(unk32 *param1, char *param2) {}
-void MapManager::func_ov004_021024c4(s32 param1, unk32 param2, unk32 param3) {}
+void MapManager::func_ov004_021024c4(unk32 *param1, unk32 param2, bool param3) {}
 void MapManager::func_ov004_021025d8() {}

src/18_Overworld/Map/MapOverworld.cpp

@@ -22,10 +22,10 @@ s32 MapOverworld::func_ov018_0215c380(u8 *param1) {}
 void MapOverworld::vfunc_bc() {}
 void MapOverworld::vfunc_98() {}
 void MapOverworld::vfunc_c0() {}
-unk32 MapOverworld::vfunc_78() {}
+unk32 *MapOverworld::vfunc_78() {}
 unk32 MapOverworld::vfunc_7c() {}
 unk32 MapOverworld::vfunc_80() {}
-unk8 MapOverworld::vfunc_b0(unk32 param_2, unk32 param_3) {}
+void MapOverworld::vfunc_b0(unk32 param_2, unk32 param_3) {}
 void MapOverworld::func_ov018_0215c650() {}
 void MapOverworld::func_ov018_0215c6ac() {}
 void MapOverworld::func_ov018_0215c6d0() {}
@@ -35,4 +35,4 @@ void MapOverworld::func_ov018_0215c9ac() {}
 void func_ov018_0215ca24(s32 param1) {}
 void func_ov018_0215ca3c(s32 param1, s32 param2, unk32 param3, unk32 param4) {}
 void func_ov018_0215ca8c(s32 param1) {}
-void MapOverworld::vfunc_4c() {}
+s32 MapOverworld::vfunc_4c() {}

src/Main/Unknown/UnkStruct_02063220.cpp

@@ -0,0 +1,284 @@
+#include "Unknown/UnkStruct_02063220.hpp"
+#include "DTCM/UnkStruct_027e02a0.hpp"
+#include "DTCM/UnkStruct_027e05f8.hpp"
+#include "DTCM/UnkStruct_027e0618.hpp"
+#include "DTCM/UnkStruct_027e08f8.hpp"
+#include "System/OverlayManager.hpp"
+#include "Unknown/UnkStruct_0206322c.hpp"
+#include "Unknown/UnkStruct_020ee734.hpp"
+#include "nds/button.h"
+#include "nds/math.h"
+#include <stdarg.h>
+#include <string.h>
+
+void DisplayDebugText(unk32 x, unk32 y, unk32 unkVal1, unk32 unkVal2, char *, unk32);
+void DisplayDebugTextFormat(unk32 param1, unk32 x, unk32 y, unk32 unkVal1, unk32 unkVal2, char *fmt, va_list args);
+void DisplayDebugTextFormat_thunk(unk32 param1, unk32 param2, unk32 param3, unk32 param4, unk32 param5, char *fmt, ...);
+void DisplayDebugTextF(unk32 x, unk32 y, unk32 unkVal1, unk32 unkVal2, char *fmt, ...);
+extern u8 data_02075ebc;
+
+extern "C" {
+void func_0200f248();
+void func_0202bac4();
+void func_0202c5e8(void);
+void func_0202cf34(unk32);
+void func_0202d164();
+void func_0202e6a4(void);
+void func_0203e8a0(void);
+void func_0202f374();
+char *strncpy(char *, char const *, unsigned int);
+
+// probably GX/GXS functions?
+void func_02003ce4(unk32);
+void func_02004730(unk32);
+void func_02003a9c(unk32, unk32, unk32);
+void func_02003b04(unk32);
+void SetBrightColor(u16 *, unk32);
+}
+
+#define ITCM_END ((s8 *) 0x01FFFFFF)
+#define ARM9_RAM_START ((s8 *) 0x02000000)
+#define ARM9_RAM_END ((s8 *) 0x0219B1C0)
+
+#define REG_A_DISPCNT (*(u32 *) 0x04000000)
+#define REG_A_2D_ENGINE (*(u16 *) 0x04000008)
+#define REG_A_MASTER_BRIGHT ((u16 *) 0x0400006C)
+#define REG_B_DISPCNT_ADDR (0x04001000)
+#define REG_B_DISPCNT (*(u32 *) REG_B_DISPCNT_ADDR)
+#define REG_B_2D_ENGINE (*(u16 *) 0x04001008)
+#define REG_B_MASTER_BRIGHT ((u16 *) 0x0400106C)
+
+const u16 data_020562e2[] = {
+    BTN_DUP,   BTN_DDOWN, BTN_DDOWN, BTN_DUP,    BTN_SELECT, BTN_B,     BTN_R,
+    BTN_START, BTN_DLEFT, BTN_DLEFT, BTN_DRIGHT, BTN_DLEFT,  BTN_START, BTN_DUP,
+};
+
+THUMB bool UnkStruct_02063220::func_0202f3f0(unk32 param1) {
+    switch (param1) {
+        case 2:
+        case 3: return true;
+        default: break;
+    }
+
+    return false;
+}
+
+THUMB unk32 UnkStruct_02063220::func_0202f400(unk32 param1) {
+    unk32 ret = 0;
+
+    switch (param1) {
+        case 2: ret = 1; break;
+        case 3: ret = 2; break;
+        default: break;
+    }
+
+    return ret;
+}
+
+THUMB void UnkStruct_02063220::DisplayAssertError(char *file, u16 line, char *msg, ...) {
+    va_list args;
+
+    // reset screen data
+    data_0206322c.func_020304a8(true, true);
+
+    // "draw" strings to the screen array
+    DisplayDebugText(0, 0, false, true, "Assert", 0);
+    DisplayDebugTextF(0, 2, false, true, "FILE:%s", file);
+    DisplayDebugTextF(0, 3, false, true, "LINE:%d", line);
+    va_start(args, msg);
+    DisplayDebugTextFormat(0, 0, 5, false, true, msg, args);
+    va_end(args);
+
+    // unknown but other "draw" stuff
+    func_0202f374();
+    func_0202d164();
+
+    // "draw" last file
+    this->func_0202f4b4();
+
+    // actual draw of the screen
+    this->func_0202f754(0);
+}
+
+// non-matching
+THUMB void UnkStruct_02063220::func_0202f4b4(void) {
+    char buffer[0x40];
+
+    if (this->path != NULL) {
+        DisplayDebugText(0, 21, 0, 0, "(LastFile)", 1);
+        strncpy(buffer, this->path, sizeof(buffer) - 1);
+        buffer[0] = '\0';
+        DisplayDebugText(0, 22, 0, 0, buffer, 1);
+    }
+}
+
+THUMB void UnkStruct_02063220::func_0202f500(void) {
+    // "reigaichuu(%d,%d)"
+    DisplayDebugTextF(16, 0, 0, 1, "レイガイチュウ(%d,%d)", data_02075ebc, this->mUnk_05);
+}
+
+// non-matching
+THUMB void UnkStruct_02063220::DisplayException(Registers *param1) {
+    int iVar1;
+    s8 *pbVar2;
+    int iVar3;
+    s32 *puVar4;
+    int *piVar5;
+
+    if (this->mUnk_05 != 0) {
+        this->func_0202f500();
+    } else {
+        this->mUnk_05++;
+        this->mUnk_05++;
+
+        data_0206322c.func_020304a8(true, true);
+        this->mUnk_05++;
+
+        DisplayDebugText(0, 0, false, false, "レイガイ_ハセイ", 0);
+        this->mUnk_05++;
+
+        if (data_02075ebc != 0) {
+            this->func_0202f500();
+            this->mUnk_05++;
+        }
+
+        for (iVar3 = 0; iVar3 < ARRAY_LEN(param1->mUnk_04); iVar3++) {
+            DisplayDebugTextF(0, iVar3 + 2, 0, 0, "R%02d  = 0x%08X", iVar3, param1->mUnk_04[iVar3]);
+            this->mUnk_05++;
+        }
+
+        DisplayDebugTextF(0, 15, 0, 0, "SP    = 0x%08X", param1->mUnk_0C);
+        this->mUnk_05++;
+
+        DisplayDebugTextF(0, 16, 0, 1, "LR    = 0x%08X", param1->mUnk_10);
+        this->mUnk_05++;
+
+        DisplayDebugTextF(0, 17, 0, 1, "PC    = 0x%08X", param1->mUnk_14);
+        this->mUnk_05++;
+
+        DisplayDebugTextF(0, 18, 0, 0, "CPSR = 0x%08X", param1->mUnk_00);
+        this->mUnk_05++;
+
+        DisplayDebugTextF(0, 19, 0, 0, "SPSR = 0x%08X", param1->mUnk_3C);
+        this->mUnk_05++;
+
+        DisplayDebugTextF(0, 20, 0, 0, "CP15 = 0x%08X", param1->mUnk_38);
+        this->mUnk_05++;
+
+        func_0202f374();
+        this->mUnk_05++;
+
+        func_0203e8a0();
+        this->mUnk_05++;
+
+        func_0202d164();
+        this->mUnk_05++;
+
+        func_0202e6a4();
+        this->mUnk_05++;
+
+        this->func_0202f4b4();
+        this->mUnk_05++;
+
+        puVar4 = param1->mUnk_04;
+        DisplayDebugText(21, 0, 0, 0, "SP", 1);
+        DisplayDebugTextFormat_thunk(1, 23, 0, 0, 0, "%08X", puVar4);
+
+        iVar3 = 1;
+
+        for (iVar3 = 1; puVar4 < data_027e02a0[1].mUnk_94; puVar4++) {
+            pbVar2 = (s8 *) puVar4;
+
+            if ((ITCM_END < pbVar2 && pbVar2 < ARM9_RAM_END) || pbVar2 < ARM9_RAM_START) {
+                DisplayDebugTextFormat_thunk(1, 23, iVar3, 0, 0, "%08X", pbVar2);
+                iVar3++;
+                if (iVar3 > 0x17) {
+                    break;
+                }
+            }
+        }
+
+        this->mUnk_05++;
+    }
+
+    this->func_0202f754(1);
+}
+
+THUMB void UnkStruct_02063220::func_0202f754(unk32 param1) {
+    u16 uVar1;
+    int iVar3;
+    u16 uVar4;
+    bool bVar5;
+    bool bVar6;
+
+    func_0202c5e8();
+    this->mUnk_04 = 0;
+    this->mUnk_05 = 0;
+
+    if (this->func_0202f3f0(param1) != 0) {
+        this->mUnk_08.func_0202fd9c(this->func_0202f400(param1));
+    } else {
+        func_02003ce4(2);
+        func_02004730(4);
+        func_02003a9c(1, 0, 0);
+        func_02003b04(0);
+
+        REG_A_DISPCNT   = (REG_A_DISPCNT & 0xFFFFE0FF) | 0x100;
+        REG_B_DISPCNT   = (REG_B_DISPCNT & 0xFFFFE0FF) | (REG_B_DISPCNT_ADDR >> 0x12);
+        REG_A_2D_ENGINE = (REG_A_2D_ENGINE & 0x43) | 0x4;
+        REG_B_2D_ENGINE = (REG_B_2D_ENGINE & 0x43) | 0x4;
+        data_0206322c.func_02030354(1, 1);
+    }
+
+    do {
+        if (this->func_0202f3f0(param1)) {
+            bVar6 = true;
+        } else {
+            data_027e05f8.func_0202adf4(1, 0);
+
+            if (param1 != 1) {
+                data_027e08f8.func_0202f9a0(1);
+            }
+
+            uVar1 = data_027e05f8.mUnk_2;
+            uVar4 = data_020562e2[this->mUnk_04];
+            bVar5 = (uVar1 & uVar4) != 0;
+
+            if (bVar5) {
+                bVar6 = false;
+
+                if (((~uVar4 & 0xFFF) & (~uVar1 & 0xFFFF)) != 0 && (uVar1 & 0xFFF) != 0) {
+                    this->mUnk_04 = 0;
+                }
+            }
+        }
+
+        this->mUnk_04++;
+        if (this->mUnk_04 >= 0xC ? 1 : 0) {
+            this->func_0202f3f0(param1);
+        }
+
+        func_0202bac4();
+
+        if (bVar6) {
+            SetBrightColor(REG_A_MASTER_BRIGHT, 0);
+            SetBrightColor(REG_B_MASTER_BRIGHT, 0);
+
+            if (this->func_0202f3f0(param1) == 0) {
+                data_0206322c.func_02030464(1, 1);
+            }
+
+            data_027e0618.func_0202cf34();
+
+            if (gOverlayManager.mLoadedOverlays[OverlayIndex_Core] != -1) {
+                data_ov000_020ee734.func_ov000_020d6620();
+            }
+
+            for (iVar3 = 0; iVar3 < 0x3C; iVar3++) {
+                func_0202bac4();
+            }
+
+            func_0200f248();
+        }
+    } while (true);
+}

src/Main/Unknown/UnkStruct_0206322c.cpp

@@ -0,0 +1,105 @@
+#include "Unknown/UnkStruct_0206322c.hpp"
+#include "global.h"
+#include "types.h"
+#include <stdarg.h>
+
+void func_02027ab4(unk32, Screen *, UNK_PTR, UNK_PTR, unk32, unk32, unk32, unk32);
+
+extern "C" {
+unk32 *MountCompressedNarc(char *, char *, unk8 *, unk32, unk32);
+unk8 data_020691a0[0xCC00];
+UNK_PTR func_02032054(char *, unk32);
+UNK_PTR func_0203206c(char *, unk32);
+void func_02016fcc(unk32 *);
+
+void GX_LoadBG0Scr(u16 *data, unk32, u32 size);
+void GXS_LoadBG0Scr(u16 *data, unk32, u32 size);
+void CleanAndInvalidateDataCacheLines(void *, u32 size); // DC_FlushRange?
+void Fill16(unk32, void *, u32 size);
+int vsnprintf(char *s, size_t n, const char *format, va_list arg);
+}
+
+THUMB void UnkStruct_0206322c::func_02030354(bool doTopScreen, bool doBottomScreen) {
+    Screen *pScreen;
+    unk32 *uVar1;
+
+    uVar1         = MountCompressedNarc("BGF", "Menu/UI_main/DbgFntM.bin", data_020691a0, sizeof(data_020691a0), 1);
+    this->mUnk_00 = func_02032054("BGF:DbgFntM.ncgr", 1);
+    this->mUnk_04 = func_0203206c("BGF:UIM.nclr", 1);
+
+    if (doTopScreen) {
+        pScreen          = &this->topScreen;
+        pScreen->mUnk_00 = 0x100;
+        pScreen->mUnk_02 = 0xC0;
+        pScreen->mUnk_04 = 0;
+        pScreen->mUnk_06 = 0;
+        pScreen->mUnk_08 = 0xC00;
+        func_02027ab4(0, pScreen, this->mUnk_00, this->mUnk_04, 0, 0, 0, 2);
+    }
+
+    if (doBottomScreen) {
+        pScreen          = &this->bottomScreen;
+        pScreen->mUnk_00 = 0x100;
+        pScreen->mUnk_02 = 0xC0;
+        pScreen->mUnk_04 = 0;
+        pScreen->mUnk_06 = 0;
+        pScreen->mUnk_08 = 0xC00;
+        func_02027ab4(4, pScreen, this->mUnk_00, this->mUnk_04, 0, 0, 0, 2);
+    }
+
+    func_02016fcc(uVar1);
+}
+
+THUMB void *UnkStruct_0206322c::func_02030408(void) {
+    this->mUnk_00 = NULL;
+    this->mUnk_04 = NULL;
+    this->func_020304a8(true, true);
+    return this;
+}
+
+THUMB void UnkStruct_0206322c::func_02030464(bool doTopScreen, bool doBottomScreen) {
+    if (doTopScreen) {
+        CleanAndInvalidateDataCacheLines(&this->topScreen.data, sizeof(this->topScreen.data));
+        GX_LoadBG0Scr(this->topScreen.data, 0, sizeof(this->topScreen.data));
+    }
+
+    if (doBottomScreen) {
+        CleanAndInvalidateDataCacheLines(&this->bottomScreen.data, sizeof(this->bottomScreen.data));
+        GXS_LoadBG0Scr(this->bottomScreen.data, 0, sizeof(this->bottomScreen.data));
+    }
+}
+
+THUMB void UnkStruct_0206322c::func_020304a8(bool doTopScreen, bool doBottomScreen) {
+    if (doTopScreen) {
+        Fill16(0, this->topScreen.data, sizeof(this->topScreen.data));
+    }
+
+    if (doBottomScreen) {
+        Fill16(0, this->bottomScreen.data, sizeof(this->bottomScreen.data));
+    }
+}
+
+void DisplayDebugText(unk32 x, unk32 y, unk32 unkVal1, unk32 unkVal2, char *, unk32);
+
+THUMB void DisplayDebugTextFormat(unk32 param1, unk32 x, unk32 y, unk32 unkVal1, unk32 unkVal2, char *fmt, va_list args) {
+    char buffer[0x100];
+
+    vsnprintf(buffer, sizeof(buffer), fmt, args);
+    DisplayDebugText(x, y, unkVal1, unkVal2, buffer, param1);
+}
+
+THUMB void DisplayDebugTextFormat_thunk(unk32 param1, unk32 param2, unk32 param3, unk32 param4, unk32 param5, char *fmt, ...) {
+    va_list args;
+
+    va_start(args, fmt);
+    DisplayDebugTextFormat(param1, param2, param3, param4, param5, fmt, args);
+    va_end(args);
+}
+
+THUMB void DisplayDebugTextF(unk32 x, unk32 y, unk32 unkVal1, unk32 unkVal2, char *fmt, ...) {
+    va_list args;
+
+    va_start(args, fmt);
+    DisplayDebugTextFormat(0, x, y, unkVal1, unkVal2, fmt, args);
+    va_end(args);
+}