Merge pull request #126 from robojumper/d_room

d_stage_parse OK, d_room largely matching, some d_stage, d_stage_mgr

30 files changed, 1936 insertions, 71 deletions

diff --git a/src/REL/d/a/obj/d_a_obj_appear_bridge.cpp b/src/REL/d/a/obj/d_a_obj_appear_bridge.cpp
index dc0e8296..1111db14 100644
--- a/src/REL/d/a/obj/d_a_obj_appear_bridge.cpp
+++ b/src/REL/d/a/obj/d_a_obj_appear_bridge.cpp
@@ -2,9 +2,9 @@
 
 #include "d/a/d_a_player.h"
 #include "d/col/bg/d_bg_s.h"
+#include "d/d_stage.h"
 #include "nw4r/types_nw4r.h"
 #include "toBeSorted/area_utils.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_APPEAR_BRIDGE, dAcOappearBridge_c, fProfile::OBJ_APPEAR_BRIDGE, 0x01FC, 0, 6);
 
@@ -18,7 +18,7 @@ STATE_DEFINE(dAcOappearBridge_c, Disappear);
 
 bool dAcOappearBridge_c::createHeap() {
     mResFile = nw4r::g3d::ResFile(getOarcResFile("TongueStage"));
-    RoomManager::bindStageResToFile(&mResFile);
+    dStage_c::bindStageResToFile(&mResFile);
     nw4r::g3d::ResMdl mdl = mResFile.GetResMdl("TongueStage");
     TRY_CREATE(mModel.create(mdl, &heap_allocator, 0x128));
     nw4r::g3d::ResAnmTexSrt srt = mResFile.GetResAnmTexSrt("TongueStage");
diff --git a/src/REL/d/a/obj/d_a_obj_bamboo_island.cpp b/src/REL/d/a/obj/d_a_obj_bamboo_island.cpp
index 1b727ce1..da0f38e9 100644
--- a/src/REL/d/a/obj/d_a_obj_bamboo_island.cpp
+++ b/src/REL/d/a/obj/d_a_obj_bamboo_island.cpp
@@ -1,9 +1,9 @@
 #include "d/a/obj/d_a_obj_bamboo_island.h"
 
 #include "d/col/bg/d_bg_s.h"
+#include "d/d_stage.h"
 #include "d/flag/storyflag_manager.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
-#include "toBeSorted/room_manager.h"
 
 const f32 dAcObambooIsland_c::unusedFloat1 = 100000.0f;
 const f32 dAcObambooIsland_c::unusedFloat2 = 0.0f;
@@ -23,8 +23,8 @@ void dAcObambooIsland_c::rideCallback(dBgW *unknown, dAcObjBase_c *actor, dAcObj
 
 bool dAcObambooIsland_c::createHeap() {
     mBrres = nw4r::g3d::ResFile(getOarcResFile("IslBamb"));
-    RoomManager::bindStageResToFile(&mBrres);
-    RoomManager::bindSkyCmnToResFile(&mBrres);
+    dStage_c::bindStageResToFile(&mBrres);
+    dStage_c::bindSkyCmnToResFile(&mBrres);
     for (int i = 0; i < 2; i++) {
         nw4r::g3d::ResMdl mdl = mBrres.GetResMdl(sBambooIslandNames[i]);
         TRY_CREATE(mModels[i].create(mdl, &heap_allocator, 0x120));
diff --git a/src/REL/d/a/obj/d_a_obj_island_nusi.cpp b/src/REL/d/a/obj/d_a_obj_island_nusi.cpp
index c4ee7b25..0177af16 100644
--- a/src/REL/d/a/obj/d_a_obj_island_nusi.cpp
+++ b/src/REL/d/a/obj/d_a_obj_island_nusi.cpp
@@ -2,6 +2,7 @@
 
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/col/bg/d_bg_s.h"
+#include "d/d_stage.h"
 #include "d/flag/storyflag_manager.h"
 #include "f/f_base.h"
 #include "m/m_vec.h"
@@ -10,7 +11,6 @@
 #include "nw4r/g3d/res/g3d_resfile.h"
 #include "nw4r/g3d/res/g3d_resmdl.h"
 #include "nw4r/g3d/res/g3d_resnode.h"
-#include "toBeSorted/room_manager.h"
 
 const f32 dAcOislandNusi_c::someFloat = 100000.0f;
 
@@ -26,8 +26,8 @@ STATE_DEFINE(dAcOislandNusi_c, NusiFight);
 
 bool dAcOislandNusi_c::createHeap() {
     mRes = nw4r::g3d::ResFile(getOarcResFile("IslNusi"));
-    RoomManager::bindStageResToFile(&mRes);
-    RoomManager::bindSkyCmnToResFile(&mRes);
+    dStage_c::bindStageResToFile(&mRes);
+    dStage_c::bindSkyCmnToResFile(&mRes);
     for (int i = 0; i < 2; i++) {
         nw4r::g3d::ResMdl mdl = mRes.GetResMdl(sMdlNames[i]);
         TRY_CREATE(mMdls[i].create(mdl, &heap_allocator, 0x160));
diff --git a/src/REL/d/a/obj/d_a_obj_lava_F200.cpp b/src/REL/d/a/obj/d_a_obj_lava_F200.cpp
index 068fd747..1a9311bc 100644
--- a/src/REL/d/a/obj/d_a_obj_lava_F200.cpp
+++ b/src/REL/d/a/obj/d_a_obj_lava_F200.cpp
@@ -1,13 +1,13 @@
 #include "d/a/obj/d_a_obj_lava_F200.h"
 
+#include "d/d_stage.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_LAVA_F200, dAcOlavaF200_c, fProfile::OBJ_LAVA_F200, 0x0214, 0, 0);
 
 bool dAcOlavaF200_c::createHeap() {
     mBrres = nw4r::g3d::ResFile(getOarcResFile("LavaF200"));
-    RoomManager::bindStageResToFile(&mBrres);
+    dStage_c::bindStageResToFile(&mBrres);
 
     nw4r::g3d::ResMdl mdl0 = mBrres.GetResMdl("LavaF200");
     TRY_CREATE(mModels[0].create(mdl0, &heap_allocator, 0x32C));
diff --git a/src/REL/d/a/obj/d_a_obj_megami_island.cpp b/src/REL/d/a/obj/d_a_obj_megami_island.cpp
index e8df429f..529e1f8a 100644
--- a/src/REL/d/a/obj/d_a_obj_megami_island.cpp
+++ b/src/REL/d/a/obj/d_a_obj_megami_island.cpp
@@ -3,12 +3,12 @@
 #include "common.h"
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/col/bg/d_bg_s.h"
+#include "d/d_stage.h"
 #include "d/flag/storyflag_manager.h"
 #include "f/f_base.h"
 #include "m/m_vec.h"
 #include "nw4r/g3d/res/g3d_resanmtexsrt.h"
 #include "nw4r/g3d/res/g3d_resmdl.h"
-#include "toBeSorted/room_manager.h"
 
 static const char *const sResFiles[] = {
     "F000Megami",
@@ -46,8 +46,8 @@ bool dAcOmegamiIsland_c::createHeap() {
     mVariant = getVariant();
 
     mRes = nw4r::g3d::ResFile(getOarcResFile(sResFiles[mVariant]));
-    RoomManager::bindStageResToFile(&mRes);
-    RoomManager::bindSkyCmnToResFile(&mRes);
+    dStage_c::bindStageResToFile(&mRes);
+    dStage_c::bindSkyCmnToResFile(&mRes);
 
     nw4r::g3d::ResMdl mdl1 = mRes.GetResMdl(sMdl1[mVariant]);
     TRY_CREATE(mMdls[0].create(mdl1, &heap_allocator, 0x120));
diff --git a/src/REL/d/a/obj/d_a_obj_pool_cock.cpp b/src/REL/d/a/obj/d_a_obj_pool_cock.cpp
index 3c786404..f52cd41e 100644
--- a/src/REL/d/a/obj/d_a_obj_pool_cock.cpp
+++ b/src/REL/d/a/obj/d_a_obj_pool_cock.cpp
@@ -1,9 +1,9 @@
 #include "d/a/obj/d_a_obj_pool_cock.h"
 
 #include "d/a/obj/d_a_obj_vortex.h"
+#include "d/d_stage.h"
 #include "d/flag/sceneflag_manager.h"
 #include "s/s_Math.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_POOL_COCK, dAcOPoolCock_c, fProfile::OBJ_POOL_COCK, 0x024D, 0, 7);
 
@@ -11,7 +11,7 @@ STATE_DEFINE(dAcOPoolCock_c, Wait);
 
 bool dAcOPoolCock_c::createHeap() {
     mBrres = nw4r::g3d::ResFile(getOarcResFile("WaterD101"));
-    RoomManager::bindStageResToFile(&mBrres);
+    dStage_c::bindStageResToFile(&mBrres);
     nw4r::g3d::ResMdl mdl = mBrres.GetResMdl("PoolCockD101");
     for (int i = 0; i < 2; i++) {
         TRY_CREATE(mModels[i].create(mdl, &heap_allocator, 0x120));
diff --git a/src/REL/d/a/obj/d_a_obj_sun_light.cpp b/src/REL/d/a/obj/d_a_obj_sun_light.cpp
index 6f141c95..7441e083 100644
--- a/src/REL/d/a/obj/d_a_obj_sun_light.cpp
+++ b/src/REL/d/a/obj/d_a_obj_sun_light.cpp
@@ -1,9 +1,9 @@
 #include "d/a/obj/d_a_obj_sun_light.h"
 
 #include "d/d_sc_game.h"
+#include "d/d_stage.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
 #include "toBeSorted/arc_managers/current_stage_arc_manager.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_SUN_LIGHT, dAcOsunLight_c, fProfile::OBJ_SUN_LIGHT, 0x0219, 0, 3);
 
@@ -11,8 +11,8 @@ STATE_DEFINE(dAcOsunLight_c, Wait);
 
 bool dAcOsunLight_c::createHeap() {
     mBrres = nw4r::g3d::ResFile(CurrentStageArcManager::sInstance->getData("g3d/stage.brres"));
-    RoomManager::bindStageResToFile(&mBrres);
-    RoomManager::bindSkyCmnToResFile(&mBrres);
+    dStage_c::bindStageResToFile(&mBrres);
+    dStage_c::bindSkyCmnToResFile(&mBrres);
     nw4r::g3d::ResMdl mdl = mBrres.GetResMdl("StageF000Light");
     TRY_CREATE(mModel.create(mdl, &heap_allocator, 0x120));
     nw4r::g3d::ResAnmTexSrt srt = mBrres.GetResAnmTexSrt("StageF000Light");
diff --git a/src/REL/d/a/obj/d_a_obj_time_stage_bg.cpp b/src/REL/d/a/obj/d_a_obj_time_stage_bg.cpp
index 3176ceba..ba496cd0 100644
--- a/src/REL/d/a/obj/d_a_obj_time_stage_bg.cpp
+++ b/src/REL/d/a/obj/d_a_obj_time_stage_bg.cpp
@@ -32,7 +32,7 @@ bool dAcOTimeStageBg_c::createHeap() {
     TRY_CREATE(mMdl1.create(mdl, &heap_allocator, 0x128));
     nw4r::g3d::ResNode nd = mdl.GetResNode(sMdlNames[mSubType]);
 
-    field_0x3EC.copyFrom((nd.ref().volume_min + nd.ref().volume_max) * 0.5f);
+    field_0x3EC.copyFrom((nd.GetBoundsMin() + nd.GetBoundsMax()) * 0.5f);
     if (mSubType == 4) {
         nw4r::g3d::ResAnmClr a = mRes.GetResAnmClr("Teniobj_0");
         TRY_CREATE(mAnm.create(mdl, a, &heap_allocator, nullptr, 1));
diff --git a/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp b/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp
index 06411982..c5e741e2 100644
--- a/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp
+++ b/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp
@@ -4,12 +4,12 @@
 #include "d/a/d_a_base.h"
 #include "d/a/obj/d_a_obj_tower_D101.h"
 #include "d/col/bg/d_bg_s_wtr_chk.h"
+#include "d/d_stage.h"
 #include "f/f_base.h"
 #include "f/f_manager.h"
 #include "f/f_profile_name.h"
 #include "m/m_vec.h"
 #include "nw4r/g3d/res/g3d_resmdl.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_TOWER_GEAR_D101, dAcOTowerGearD101_c, fProfile::OBJ_TOWER_GEAR_D101, 0x17E, 0, 7);
 
@@ -20,7 +20,7 @@ extern "C" void fn_80067340(mVec3_c &, nw4r::g3d::ResMdl *, const char *);
 bool dAcOTowerGearD101_c::createHeap() {
     const char *name = "TowerGearD101";
     mRes = nw4r::g3d::ResFile(getOarcResFile(name));
-    RoomManager::bindStageResToFile(&mRes);
+    dStage_c::bindStageResToFile(&mRes);
     nw4r::g3d::ResMdl mdl = mRes.GetResMdl(name);
     if (!mMdl.create(mdl, &heap_allocator, 0x120, 1, nullptr)) {
         return false;
diff --git a/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp b/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp
index ddd7498a..5a1a4190 100644
--- a/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp
+++ b/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp
@@ -5,6 +5,7 @@
 #include "d/a/d_a_player.h"
 #include "d/col/bg/d_bg_s.h"
 #include "d/col/bg/d_bg_w.h"
+#include "d/d_stage.h"
 #include "d/flag/sceneflag_manager.h"
 #include "f/f_base.h"
 #include "m/m3d/m_fanm.h"
@@ -17,7 +18,6 @@
 #include "s/s_Math.h"
 #include "toBeSorted/actor_event.h"
 #include "toBeSorted/event_manager.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_TOWER_HAND_D101, dAcOTowerHandD101_c, fProfile::OBJ_TOWER_HAND_D101, 0x180, 0, 6);
 
@@ -108,7 +108,7 @@ bool dAcOTowerHandD101_c::createHeap() {
     if (!res.IsValid()) {
         return false;
     }
-    RoomManager::bindStageResToFile(&res);
+    dStage_c::bindStageResToFile(&res);
     if (direction == 1) {
         mMdl.getModel().setCullModeAll(GX_CULL_FRONT, false);
     }
diff --git a/src/REL/d/a/obj/d_a_obj_uta_demo_pedest.cpp b/src/REL/d/a/obj/d_a_obj_uta_demo_pedest.cpp
index 3545cb7f..3be5c7b3 100644
--- a/src/REL/d/a/obj/d_a_obj_uta_demo_pedest.cpp
+++ b/src/REL/d/a/obj/d_a_obj_uta_demo_pedest.cpp
@@ -1,12 +1,12 @@
 #include "d/a/obj/d_a_obj_uta_demo_pedest.h"
 
 #include "d/a/obj/d_a_obj_base.h"
+#include "d/d_stage.h"
 #include "f/f_base.h"
 #include "m/m_vec.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
 #include "nw4r/g3d/res/g3d_resmdl.h"
 #include "toBeSorted/arc_managers/current_stage_arc_manager.h"
-#include "toBeSorted/room_manager.h"
 
 static const char *const sMdlNames[] = {
     "StageF010rPedest",
@@ -25,8 +25,8 @@ bool dAcOutaDemoPedest_c::createHeap() {
     }
 
     mRes = nw4r::g3d::ResFile(CurrentStageArcManager::sInstance->getData("g3d/stage.brres"));
-    RoomManager::bindStageResToFile(&mRes);
-    RoomManager::bindSkyCmnToResFile(&mRes);
+    dStage_c::bindStageResToFile(&mRes);
+    dStage_c::bindSkyCmnToResFile(&mRes);
     nw4r::g3d::ResMdl mdl = mRes.GetResMdl(sMdlNames[mModelType]);
     TRY_CREATE(mMdl.create(mdl, &heap_allocator, 0x120));
 
diff --git a/src/REL/d/a/obj/d_a_obj_utajima.cpp b/src/REL/d/a/obj/d_a_obj_utajima.cpp
index 09df9cfa..f7bd2ccf 100644
--- a/src/REL/d/a/obj/d_a_obj_utajima.cpp
+++ b/src/REL/d/a/obj/d_a_obj_utajima.cpp
@@ -4,8 +4,8 @@
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/col/bg/d_bg_s.h"
 #include "d/col/c/c_m3d_g_aab.h"
+#include "d/d_stage.h"
 #include "d/flag/storyflag_manager.h"
-#include "toBeSorted/room_manager.h"
 
 static const char *const mMdlNames[] = {
     "IslSon",
@@ -24,8 +24,8 @@ void dAcOutajima_c::rideCallback(dBgW *bg, dAcObjBase_c *o1, dAcObjBase_c *o2) {
 
 bool dAcOutajima_c::createHeap() {
     mRes = nw4r::g3d::ResFile(getOarcResFile("IslSon"));
-    RoomManager::bindStageResToFile(&mRes);
-    RoomManager::bindSkyCmnToResFile(&mRes);
+    dStage_c::bindStageResToFile(&mRes);
+    dStage_c::bindSkyCmnToResFile(&mRes);
 
     nw4r::g3d::ResMdl m(nullptr);
 
diff --git a/src/REL/d/a/obj/d_a_obj_utajima_island.cpp b/src/REL/d/a/obj/d_a_obj_utajima_island.cpp
index a85dfd6f..6ca9731a 100644
--- a/src/REL/d/a/obj/d_a_obj_utajima_island.cpp
+++ b/src/REL/d/a/obj/d_a_obj_utajima_island.cpp
@@ -4,13 +4,13 @@
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/a/obj/d_a_obj_utajima_main_mecha.h"
 #include "d/col/bg/d_bg_s.h"
+#include "d/d_stage.h"
 #include "f/f_base.h"
 #include "f/f_manager.h"
 #include "f/f_profile_name.h"
 #include "m/m_angle.h"
 #include "nw4r/g3d/res/g3d_resmdl.h"
 #include "s/s_Math.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_UTAJIMA_ISLAND, dAcOutajimaIsland_c, fProfile::OBJ_UTAJIMA_ISLAND, 0x1D2, 0, 6);
 
@@ -25,8 +25,8 @@ const f32 dAcOutajimaIsland_c::floats[] = {
 
 bool dAcOutajimaIsland_c::createHeap() {
     mRes = nw4r::g3d::ResFile(getOarcResFile("IslPuzIslet00"));
-    RoomManager::bindStageResToFile(&mRes);
-    RoomManager::bindSkyCmnToResFile(&mRes);
+    dStage_c::bindStageResToFile(&mRes);
+    dStage_c::bindSkyCmnToResFile(&mRes);
     nw4r::g3d::ResMdl m = mRes.GetResMdl("IslPuzIslet00");
 
     TRY_CREATE(mMdl.create(m, &heap_allocator, 0x120));
diff --git a/src/REL/d/a/obj/d_a_obj_utajima_lv2.cpp b/src/REL/d/a/obj/d_a_obj_utajima_lv2.cpp
index 2c68945a..b8624e2e 100644
--- a/src/REL/d/a/obj/d_a_obj_utajima_lv2.cpp
+++ b/src/REL/d/a/obj/d_a_obj_utajima_lv2.cpp
@@ -2,8 +2,8 @@
 
 #include "common.h"
 #include "d/col/bg/d_bg_s.h"
+#include "d/d_stage.h"
 #include "m/m_vec.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_UTAJIMA_LV2, dAcOutajimaLv2_c, fProfile::OBJ_UTAJIMA_LV2, 0x1D5, 0, 3);
 
@@ -11,8 +11,8 @@ const f32 dAcOutajimaLv2_c::someFloat = 100000.0f;
 
 bool dAcOutajimaLv2_c::createHeap() {
     mRes = nw4r::g3d::ResFile(getOarcResFile("IslCave"));
-    RoomManager::bindStageResToFile(&mRes);
-    RoomManager::bindSkyCmnToResFile(&mRes);
+    dStage_c::bindStageResToFile(&mRes);
+    dStage_c::bindSkyCmnToResFile(&mRes);
     nw4r::g3d::ResMdl mdl = mRes.GetResMdl("IslCave");
     TRY_CREATE(mMdl.create(mdl, &heap_allocator, 0x120));
 
diff --git a/src/REL/d/t/d_t_genki_dws_tgt.cpp b/src/REL/d/t/d_t_genki_dws_tgt.cpp
index ef184152..1d3479be 100644
--- a/src/REL/d/t/d_t_genki_dws_tgt.cpp
+++ b/src/REL/d/t/d_t_genki_dws_tgt.cpp
@@ -1,9 +1,10 @@
 #include "d/t/d_t_genki_dws_tgt.h"
 
+#include "d/d_room.h"
 #include "d/d_sc_game.h"
+#include "d/d_stage.h"
 #include "d/flag/sceneflag_manager.h"
 #include "d/flag/storyflag_manager.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(TAG_GENKI_DOWSING_TARGET, dTgGenkiDwsTgt_c, fProfile::TAG_GENKI_DOWSING_TARGET, 0x02A5, 0, 0);
 
@@ -49,11 +50,10 @@ int dTgGenkiDwsTgt_c::actorExecute() {
     if (flag) {
         deleteRequest();
     } else {
-        RoomManager *mgr = RoomManager::m_Instance;
-        if (mgr != nullptr) {
-            dRoom *room = RoomManager::m_Instance->GetRoomByIndex(roomid);
+        if (dStage_c::GetInstance() != nullptr) {
+            dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
             if (room != nullptr) {
-                if (room->flags & 8) {
+                if (room->checkFlag(8)) {
                     mDowsingTarget.doRegister();
                 } else {
                     mDowsingTarget.doUnregister();
diff --git a/src/d/a/d_a_base.cpp b/src/d/a/d_a_base.cpp
index b4bed28c..c56e80e9 100644
--- a/src/d/a/d_a_base.cpp
+++ b/src/d/a/d_a_base.cpp
@@ -3,14 +3,15 @@
 #include "d/a/d_a_player.h"
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/d_heap.h"
+#include "d/d_room.h"
 #include "d/d_sc_game.h"
+#include "d/d_stage.h"
 #include "d/flag/enemyflag_manager.h"
 #include "f/f_list_nd.h"
 #include "m/m_vec.h"
 #include "toBeSorted/event.h"
 #include "toBeSorted/event_manager.h"
 #include "toBeSorted/file_manager.h"
-#include "toBeSorted/room_manager.h"
 #include "toBeSorted/special_item_drop_mgr.h"
 
 // .sdata
@@ -35,7 +36,6 @@ extern "C" s16 targetAngleY(mVec3_c *, mVec3_c *);
 extern "C" s16 targetAngleX(mVec3_c *, mVec3_c *);
 extern "C" bool checkCollision(mVec3_c *pos);
 extern "C" s8 collisionCheckGetRoom();
-extern "C" dRoom *getRoomByIndex(RoomManager *mgr, s8 roomid);
 
 bool dAcBase_c::createHeap() {
     return true;
@@ -126,13 +126,13 @@ int dAcBase_c::initAllocator(int size, char *name, EGG::Heap *heap, int align) {
 }
 
 bool dAcBase_c::addActorToRoom(s32 roomId) {
-    dBase_c *room = RoomManager::getRoom(roomId);
+    dBase_c *room = dStage_c::getParentForRoom(roomId);
     if (room == nullptr) {
         return false;
     }
     if (setConnectChild(room)) {
         if (roomId == -1) {
-            this->roomid = RoomManager::m_Instance->curr_room_id;
+            this->roomid = dStage_c::GetInstance()->getCurrRoomId();
         } else {
             this->roomid = roomId;
         }
@@ -427,15 +427,15 @@ void dAcBase_c::updateRoomId(f32 yOffset) {
         if (checkCollision(&actorPos)) {
             roomid = collisionCheckGetRoom();
         } else {
-            roomid = RoomManager::m_Instance->curr_room_id;
+            roomid = dStage_c::GetInstance()->getCurrRoomId();
         }
     }
 }
 
 // 8002d540
 bool dAcBase_c::isRoomFlags_0x6_Set() {
-    dRoom *room = RoomManager::m_Instance->GetRoomByIndex(roomid);
-    return (room->flags & 6);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    return (room->checkFlag(0x4 | 0x2));
 }
 
 // Start of SoundSource stuff
@@ -478,12 +478,12 @@ void dAcBase_c::setEnemyDefeatFlag() {
 
 // 8002d940
 void dAcBase_c::changeLoadedEntitiesWithSet() {
-    RoomManager::m_Instance->changeLoadedEntities(RoomManager::m_Instance, obj_id, true);
+    dStage_c::GetInstance()->changeLoadedEntities(obj_id, true);
 }
 
 // 8002d960
 void dAcBase_c::changeLoadedEntitiesNoSet() {
-    RoomManager::m_Instance->changeLoadedEntities(RoomManager::m_Instance, obj_id, false);
+    dStage_c::GetInstance()->changeLoadedEntities(obj_id, false);
 }
 
 // spawns GroupType2 (ACTOR)
@@ -513,7 +513,7 @@ dAcBase_c *dAcBase_c::createActor(
     setTempCreateParams(
         actorPosition, actorRotation, actorScale, actorRoomid, newParams2, (dAcBase_c *)actorRef, 0, -1, 0xFF, nullptr
     );
-    dBase_c *room = RoomManager::getRoom(roomid);
+    dBase_c *room = dStage_c::getParentForRoom(roomid);
     return (dAcBase_c *)dBase_c::createBase(actorId, room, actorParams1, ACTOR);
 }
 
@@ -544,7 +544,7 @@ dAcBase_c *dAcBase_c::createActorStage(
     setTempCreateParams(
         actorPosition, actorRotation, actorScale, actorRoomid, newParams2, (dAcBase_c *)actorRef, 0, -1, 0xFF, nullptr
     );
-    dBase_c *room = RoomManager::getRoom(roomid);
+    dBase_c *room = dStage_c::getParentForRoom(roomid);
     return (dAcBase_c *)dBase_c::createBase(actorId, room, actorParams1, STAGE);
 }
 
diff --git a/src/d/a/obj/d_a_obj_tbox.cpp b/src/d/a/obj/d_a_obj_tbox.cpp
index d62b1169..d391c4af 100644
--- a/src/d/a/obj/d_a_obj_tbox.cpp
+++ b/src/d/a/obj/d_a_obj_tbox.cpp
@@ -11,6 +11,8 @@
 #include "d/col/c/c_bg_s_poly_info.h"
 #include "d/col/cc/d_cc_d.h"
 #include "d/col/cc/d_cc_s.h"
+#include "d/d_room.h"
+#include "d/d_stage.h"
 #include "d/flag/sceneflag_manager.h"
 #include "d/flag/storyflag_manager.h"
 #include "d/flag/tboxflag_manager.h"
@@ -31,7 +33,6 @@
 #include "toBeSorted/counters/goddess_chest_counter.h"
 #include "toBeSorted/dowsing_target.h"
 #include "toBeSorted/event_manager.h"
-#include "toBeSorted/room_manager.h"
 
 SPECIAL_ACTOR_PROFILE(TBOX, dAcTbox_c, fProfile::TBOX, 0x018D, 0, 6);
 
@@ -1191,7 +1192,7 @@ int dAcTbox_c::actorExecute() {
         (this->*mRegisterDowsingTarget)();
     }
 
-    dRoom *r = RoomManager::m_Instance->GetRoomByIndex(roomid);
+    dRoom_c *r = dStage_c::GetInstance()->getRoom(roomid);
     bool hasFlags = r->checkFlag(0x1E);
     if (hasFlags) {
         setObjectProperty(0x200);
@@ -1327,7 +1328,7 @@ int dAcTbox_c::actorExecuteInEvent() {
         (this->*mRegisterDowsingTarget)();
     }
 
-    dRoom *r = RoomManager::m_Instance->GetRoomByIndex(roomid);
+    dRoom_c *r = dStage_c::GetInstance()->getRoom(roomid);
     bool hasFlags = r->checkFlag(0x1E);
     if (hasFlags) {
         setObjectProperty(0x200);
diff --git a/src/d/col/bg/d_bg_s.cpp b/src/d/col/bg/d_bg_s.cpp
index b23d869e..229ad3d5 100644
--- a/src/d/col/bg/d_bg_s.cpp
+++ b/src/d/col/bg/d_bg_s.cpp
@@ -1028,7 +1028,7 @@ UNKTYPE *dBgS::GetMapAccessor() {
     return lbl_805754B0;
 }
 
-void dBgS::DrawMap(u8 roomId, mMtx_c *, bool bColor, int) {
+void dBgS::DrawMap(int roomId, mMtx_c *, bool bColor, int) {
     // TODO
 }
 
@@ -1068,7 +1068,7 @@ void dBgS::SetupScrollMaterial(int matIdx, s32, bool) {
     // TODO
 }
 
-void dBgS::DrawMapScroll(u8 roomId, mMtx_c *, bool bColor, int) {
+void dBgS::DrawMapScroll(int roomId, mMtx_c *, bool bColor, int) {
     // TODO
 }
 
diff --git a/src/d/col/cc/d_cc_s.cpp b/src/d/col/cc/d_cc_s.cpp
index 01f1d9e2..120ee9f0 100644
--- a/src/d/col/cc/d_cc_s.cpp
+++ b/src/d/col/cc/d_cc_s.cpp
@@ -4,9 +4,9 @@
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/col/c/c_cc_d.h"
 #include "d/col/c/c_m3d_g_aab.h"
+#include "d/d_stage_mgr.h"
 #include "f/f_base.h"
 #include "rvl/MTX/mtx.h"
-#include "toBeSorted/stage_manager.h"
 
 dCcS *dCcS::sInstance;
 
@@ -168,7 +168,6 @@ void dCcS::ClearArea() {
     mAreaCount = 0;
 }
 
-
 extern "C" bool fn_8019A7A0(void *stg, f32 *, f32 *);
 void dCcS::AdjustHitPos() {
     f32 x, z;
diff --git a/src/d/d_room.cpp b/src/d/d_room.cpp
new file mode 100644
index 00000000..3bfd760f
--- /dev/null
+++ b/src/d/d_room.cpp
@@ -0,0 +1,656 @@
+#include "d/d_room.h"
+
+#include "common.h"
+#include "d/a/d_a_base.h"
+#include "d/a/d_a_item.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_w_base.h"
+#include "d/col/bg/d_bg_w_kcol.h"
+#include "d/d_sc_game.h"
+#include "d/d_stage.h"
+#include "d/d_stage_mgr.h"
+#include "d/flag/sceneflag_manager.h"
+#include "d/flag/storyflag_manager.h"
+#include "d/t/d_t_mass_obj.h"
+#include "egg/math/eggMath.h"
+#include "f/f_base.h"
+#include "m/m3d/m_anmmatclr.h"
+#include "m/m3d/m_anmtexpat.h"
+#include "m/m3d/m_anmtexsrt.h"
+#include "m/m3d/m_anmvis.h"
+#include "m/m3d/m_fanm.h"
+#include "m/m3d/m_smdl.h"
+#include "m/m_mtx.h"
+#include "m/m_vec.h"
+#include "nw4r/g3d/g3d_scnmdl.h"
+#include "nw4r/g3d/g3d_scnobj.h"
+#include "nw4r/g3d/res/g3d_resanmclr.h"
+#include "nw4r/g3d/res/g3d_resanmtexpat.h"
+#include "nw4r/g3d/res/g3d_resanmtexsrt.h"
+#include "nw4r/g3d/res/g3d_resanmvis.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmat.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "nw4r/g3d/res/g3d_resnode.h"
+#include "nw4r/math/math_geometry.h"
+#include "nw4r/math/math_types.h"
+#include "sized_string.h"
+#include "toBeSorted/arc_managers/current_stage_arc_manager.h"
+#include "toBeSorted/time_area_mgr.h"
+#include "toBeSorted/unk_with_water.h"
+
+SPECIAL_BASE_PROFILE(ROOM, dRoom_c, fProfile::ROOM, 0x9, 96);
+
+STATE_DEFINE(dRoom_c, Active);
+STATE_DEFINE(dRoom_c, NonActive);
+
+extern "C" void parseRoomBzs(int roomid, void *bzs);
+
+int dRoom_c::create() {
+    roomid = params & 0x3F;
+    mCanHavePastState = dStageMgr_c::GetInstance()->getSTIFunk1() == 0 &&
+                        // SSH machine room (less sure about D303...)
+                        !(dScGame_c::isCurrentStage("D301") && roomid == 12) &&
+                        !(dScGame_c::isCurrentStage("D303") && roomid == 12) &&
+                        // LMF first two rooms, Gust Bellows room
+                        !(dScGame_c::isCurrentStage("D300") && (roomid == 0 || roomid == 1 || roomid == 4)) &&
+                        // LMF crawlspace, spike maze
+                        !(dScGame_c::isCurrentStage("D300_1") && (roomid == 7 || roomid == 9));
+    if (!mAllocator.createNewTempFrmHeap(
+            -1, CurrentStageArcManager::sInstance->getHeap(roomid), "dRoom_c::m_allocator", 0x20, 0
+        )) {
+        return FAILED;
+    }
+
+    bool anyError = false;
+
+    mRoomRes = nw4r::g3d::ResFile(CurrentStageArcManager::sInstance->loadFromRoomArc(roomid, "g3d/room.brres"));
+    dStage_c::bindStageResToFile(&mRoomRes);
+    dStage_c::bindSkyCmnToResFile(&mRoomRes);
+
+    for (s32 i = 0; i < ARRAY_LENGTH(mModels); i++) {
+        model_c *mdl = &mModels[i];
+        if (i != 2 || roomid != 1 || dScGame_c::currentSpawnInfo.layer != 14 || !dScGame_c::isCurrentStage("F406")) {
+            if (!mdl->create(mRoomRes, mAllocator, i, &mWaterThing)) {
+                anyError = true;
+                break;
+            }
+            if (mdl->mpAnmPat) {
+                mHasAnmTexPat = true;
+            }
+        }
+    }
+
+    if (!anyError) {
+        if (mWaterThing.hasLinks()) {
+            u32 val = 0;
+            dStageMgr_c *stageMr = dStageMgr_c::GetInstance();
+            if (stageMr->checkFlag0x88A0(2)) {
+                val = 3;
+            }
+            stageMr->initUnkWithWater(val, &mWaterThing);
+        }
+        anyError = setupBg();
+    }
+    mAllocator.adjustFrmHeapRestoreCurrent();
+
+    if (anyError) {
+        return FAILED;
+    }
+
+    dStage_c::GetInstance()->setRoom(roomid, this);
+    BZS = CurrentStageArcManager::sInstance->loadFromRoomArc(roomid, "dat/room.bzs");
+    parseRoomBzs(roomid, BZS);
+    mDidAlreadyInit = (params >> 6) & 1;
+    mStateMgr.changeState(StateID_Active);
+    if (roomid != dScGame_c::currentSpawnInfo.room) {
+        mFlags |= 2;
+        deactivateUpdates();
+    }
+
+    return SUCCEEDED;
+}
+
+int dRoom_c::doDelete() {
+    destroyModels();
+    if (mWaterThing.hasLinks()) {
+        u32 val = 0;
+        dStageMgr_c *stageMr = dStageMgr_c::GetInstance();
+        if (stageMr->checkFlag0x88A0(2)) {
+            val = 3;
+        }
+        stageMr->destroyUnkWithWater(val, &mWaterThing);
+    }
+
+    dStage_c::GetInstance()->setRoom(roomid, nullptr);
+    return SUCCEEDED;
+}
+
+int dRoom_c::execute() {
+    mStateMgr.executeState();
+    f32 val = 0.0f;
+    if (mCanHavePastState) {
+        val = dTimeAreaMgr_c::sInstance->checkPositionIsInPastState(roomid, mVec3_c::Zero, nullptr, 1000000.0f);
+        mSkipDrawing = !mHasAnmTexPat && (!dTimeAreaMgr_c::sInstance->isInLanayruMiningFacility() || val > 0.0f) &&
+                       dTimeAreaMgr_c::sInstance->isField0x78();
+    } else {
+        mSkipDrawing = false;
+    }
+
+    if ((mFlags & 2) != 0 || mSkipDrawing) {
+        releaseBg();
+        return SUCCEEDED;
+    }
+
+    executeBg();
+    for (s32 i = 0; i < ARRAY_LENGTH(mModels); i++) {
+        mModels[i].execute(i, mCanHavePastState, val);
+    }
+
+    return SUCCEEDED;
+}
+
+int dRoom_c::draw() {
+    if ((mFlags & 2) != 0 || mSkipDrawing) {
+        return SUCCEEDED;
+    }
+    for (s32 i = 0; i < ARRAY_LENGTH(mModels); i++) {
+        mModels[i].draw(roomid);
+    }
+    return SUCCEEDED;
+}
+
+void deactivateUpdatesCb(dAcBase_c *ac) {
+    if (!ac->checkActorProperty(0x400)) {
+        return;
+    }
+    ac->unkVirtFunc_0x60();
+}
+
+void dRoom_c::deactivateUpdates() {
+    if (!mUpdatesDeactivated) {
+        foreachObject(deactivateUpdatesCb);
+        setProcControlFlag(ROOT_DISABLE_EXECUTE | ROOT_DISABLE_DRAW);
+        mUpdatesDeactivated = true;
+    }
+}
+
+void activateUpdatesCb(dAcBase_c *ac) {
+    if (!ac->checkActorProperty(0x400)) {
+        return;
+    }
+    ac->restorePosRotFromCopy();
+}
+
+void dRoom_c::activateUpdates() {
+    if (mUpdatesDeactivated) {
+        foreachObject(activateUpdatesCb);
+        clearProcControlFlag(ROOT_DISABLE_EXECUTE);
+        clearProcControlFlag(ROOT_DISABLE_DRAW);
+        mUpdatesDeactivated = false;
+    }
+}
+
+s32 dRoom_c::foreachObject(foreachObjCallback cb) {
+    s32 count = 0;
+
+    fBase_c *start = getConnectBrNext();
+    if (start == nullptr) {
+        start = getConnectParent();
+    }
+
+    for (fBase_c *base = getConnectChild(); base != nullptr && base != start; base = getConnectTreeNext(base)) {
+        if (base->group_type == ACTOR || base->group_type == STAGE) {
+            cb(static_cast<dAcBase_c *>(base));
+            count++;
+        }
+    }
+    return count;
+}
+
+struct BgData {
+    const char *kcl;
+    const char *plc;
+};
+
+static const BgData sRoomBg[] = {
+    {  "kcl/room.kcl",   "dat/room.plc"},
+    {"kcl/room_n.kcl", "dat/room_n.plc"},
+};
+
+bool dRoom_c::setupBg() {
+    for (int i = 0; i < ARRAY_LENGTH(mBg); i++) {
+        dBgWKCol *bg = &mBg[i];
+        void *kcl = CurrentStageArcManager::sInstance->getDataFromRoomArc(roomid, sRoomBg[i].kcl);
+        if (kcl != nullptr) {
+            void *plc = CurrentStageArcManager::sInstance->loadFromRoomArc(roomid, sRoomBg[i].plc);
+            bg->Set(kcl, plc);
+            bg->SetRoomId(roomid);
+            bg->SetPriority(dBgW_Base::PRIORITY_0);
+            bool ok = (BOOL)bg->InitMapStuff(&mAllocator);
+            if (!ok) {
+                return true;
+            }
+
+            if (mCanHavePastState && !mHasAnmTexPat) {
+                bg->SetUnkBase();
+            }
+            // ???
+            dBgS::GetInstance()->Regist(bg, (dAcObjBase_c *)nullptr);
+            dBgS::GetInstance()->RegistBg(bg, nullptr);
+        }
+    }
+    return false;
+}
+
+void dRoom_c::executeBg() {
+    for (int i = 0; i < ARRAY_LENGTH(mBg); i++) {
+        if (!mBg[i].ChkNotReady()) {
+            dBgS::GetInstance()->Regist(&mBg[i], (dAcObjBase_c *)nullptr);
+        }
+    }
+}
+
+void dRoom_c::releaseBg() {
+    for (int i = 0; i < 2; i++) {
+        if (!mBg[i].ChkNotReady()) {
+            dBgS::GetInstance()->Release(&mBg[i]);
+        }
+    }
+}
+
+void dRoom_c::drawOnMapIfVisible(mMtx_c *mtx, int param) {
+    // Dungeon map shows rooms but doesn't fill them out
+    // Visited rooms are shown filled out
+    bool drawFully = true;
+    if (dStageMgr_c::GetInstance()->isAreaTypeDungeonOrBoss()) {
+        drawFully = dStage_c::GetInstance()->hasVisitedRoom(roomid);
+        if (!drawFully && !dAcItem_c::checkFlag(/* DUNGEON_MAP_FI */ 0x32)) {
+            return;
+        }
+    } else {
+        // Lake Floria interior
+        if (dStageMgr_c::GetInstance()->isAreaTypeOverworldOrSkyloft() && dScGame_c::isCurrentStage("F102") &&
+            !StoryflagManager::sInstance->getCounterOrFlag(115) && roomid >= 3 && roomid < 5) {
+            return;
+        }
+    }
+
+    dBgS::GetInstance()->DrawMap(roomid, mtx, drawFully, param);
+}
+
+void dRoom_c::getBounds(mVec3_c *min, mVec3_c *max) const {
+    for (int i = 0; i < ARRAY_LENGTH(mModels); i++) {
+        mVec3_c tMin, tMax;
+        mModels[i].getBounds(&tMin, &tMax);
+        if (i == 0) {
+            *min = tMin;
+            *max = tMax;
+        } else {
+            nw4r::math::VEC3Minimize(min, min, tMin);
+            nw4r::math::VEC3Maximize(max, max, tMax);
+        }
+    }
+}
+
+void dRoom_c::formatObj(int obj, SizedString<8> &str) {
+    str.sprintf("obj%d", obj);
+}
+
+void dRoom_c::updateObjNodeInEachRoom(int obj, bool visible) {
+    SizedString<8> objName;
+    formatObj(obj, objName);
+    for (int i = 0; i < ARRAY_LENGTH(mModels); i++) {
+        mModels[i].updateObjNode(objName, visible);
+    }
+}
+
+void dRoom_c::destroyModels() {
+    for (int i = 0; i < ARRAY_LENGTH(mModels); i++) {
+        mModels[i].destroy();
+    }
+}
+
+// Called from d_a_lastboss
+void dRoom_c::someLastBossThing(bool arg) {
+    const char *name = "model0";
+    if (!arg) {
+        name = "model_obj0";
+    }
+    nw4r::g3d::ResAnmTexSrt anmSrt = mRoomRes.GetResAnmTexSrt(name);
+    if (anmSrt.IsValid()) {
+        mModels[0].mpAnmSrt->setAnm(mModels[0].mMdl, anmSrt, 0, m3d::PLAY_MODE_4);
+        mModels[0].mMdl.setAnm(*mModels[0].mpAnmSrt);
+    }
+}
+
+f32 dRoom_c::getFrame() const {
+    return mModels[0].getFrame();
+}
+
+extern "C" void fn_800641D0(int roomid, void *roomBzs);
+extern "C" void fn_80064160(int roomid, void *roomBzs);
+
+void dRoom_c::initializeState_Active() {
+    SceneflagManager::sInstance->unsetZoneflagsForRoom(roomid);
+    executeBg();
+    fn_800641D0(roomid, BZS);
+    if (mDidAlreadyInit) {
+        fn_80064160(roomid, BZS);
+    } else {
+        mFlags |= 8 | 2;
+        mDidAlreadyInit = true;
+    }
+}
+
+void dRoom_c::executeState_Active() {
+    u8 flags = mFlags;
+    field_0x571 = (flags & (4 | 2)) != 0;
+    if (field_0x571) {
+        if ((flags & 8) != 0) {
+            mStateMgr.changeState(StateID_NonActive);
+        } else {
+            deactivateUpdates();
+        }
+        return;
+    }
+
+    activateUpdates();
+}
+
+void dRoom_c::finalizeState_Active() {}
+
+void deleteActor(dAcBase_c *ac) {
+    ac->setActorProperty(0x800);
+    ac->deleteRequest();
+}
+
+void dRoom_c::initializeState_NonActive() {
+    foreachObject(deleteActor);
+    if (dTgMassObj_c::GetInstance() != nullptr) {
+        dTgMassObj_c::GetInstance()->unloadRoom(roomid);
+    }
+}
+
+void dRoom_c::executeState_NonActive() {
+    if ((mFlags & 8) != 0) {
+        return;
+    }
+    mStateMgr.changeState(StateID_Active);
+}
+
+void dRoom_c::finalizeState_NonActive() {
+    mFlags = mFlags & ~8;
+    destroyModels();
+}
+
+void dRoom_c::mdl_c::remove() {
+    if (mpAabb != nullptr) {
+        delete[] mpAabb;
+        mpAabb = nullptr;
+        doSomethingWithVis(true);
+    }
+}
+
+bool dRoom_c::mdl_c::create(nw4r::g3d::ResMdl resMdl, mAllocator_c &alloc) {
+    if (!m3d::smdl_c::create(resMdl, &alloc, 0x40)) {
+        return false;
+    }
+    calc(false);
+    u32 numEntries = resMdl.GetResNodeNumEntries();
+    mpAabb = new nw4r::math::AABB[numEntries];
+
+    if (mpAabb == nullptr) {
+        return false;
+    }
+
+    nw4r::math::AABB *buf = mpAabb;
+    u32 id = 0;
+    if (numEntries != 0) {
+        for (; id < numEntries; id++) {
+            mMtx_c mtx;
+            getNodeWorldMtx(id, mtx);
+            nw4r::g3d::ResNode resNd = resMdl.GetResNode(id);
+            mVec3_c min, max;
+            min.copyFrom(resNd.GetBoundsMin());
+            max.copyFrom(resNd.GetBoundsMax());
+            nw4r::math::AABB bb(min, max);
+            buf->Set(&bb, mtx);
+            buf++;
+        }
+    }
+
+    doSomethingWithVis(false);
+    return true;
+}
+
+extern "C" bool fn_801BB750(nw4r::math::AABB *aabb, f32 f);
+
+void dRoom_c::mdl_c::configureSomething() {
+    nw4r::g3d::ResMdl mdl = getResMdl();
+    u32 numNodes = mdl.GetResNodeNumEntries();
+
+    nw4r::math::AABB *aabbs = mpAabb;
+    for (u32 i = 0; i < numNodes; i++) {
+        nw4r::g3d::ResNode nd = mdl.GetResNode(i);
+        if (nd.IsVisible() && (nd.ref().flags & nw4r::g3d::ResNodeData::FLAG_GEOMETRY) &&
+            nd.GetBillboardMode() == nw4r::g3d::ResNodeDataTypedef::BILLBOARD_OFF) {
+            somethingVisibility(i, !fn_801BB750(&aabbs[i], EGG::Math<f32>::maxNumber()));
+        }
+    }
+}
+
+void dRoom_c::mdl_c::somethingVisibility(u32 id, bool visible) {
+    nw4r::g3d::ScnMdl *mdl = nw4r::g3d::ScnObj::DynamicCast<nw4r::g3d::ScnMdl>(getG3dObject());
+    nw4r::g3d::ScnMdl::CopiedVisAccess v(mdl, id);
+    v.SetVisibility(visible);
+}
+
+void dRoom_c::mdl_c::doSomethingWithVis(bool arg) {
+    nw4r::g3d::ResMdl mdl = getResMdl();
+    const char *mdlName = mdl.GetName();
+    if (strequals(mdlName, "model0_s") && dScGame_c::isStageSkyloftLayer20()) {
+        nw4r::g3d::ResMat mat = mdl.GetResMat("MA03_C_Door_Kasan");
+        setMatVisible(mat.GetID(), arg);
+    }
+}
+
+bool dRoom_c::model_c::create(nw4r::g3d::ResFile resFile, mAllocator_c &alloc, s32 idx, UnkWithWater *waterThing) {
+    SizedString<16> mdlName;
+    mdlName.sprintf("model%d", idx >> 1);
+    if ((idx & 1) != 0) {
+        mdlName += "_s";
+    }
+
+    nw4r::g3d::ResMdl mdl = resFile.GetResMdl(mdlName);
+    if (!mdl.IsValid()) {
+        return true;
+    }
+
+    bool linkResult = UnkWithWater::linkMdl(mdl, waterThing);
+    if (!mMdl.create(mdl, alloc)) {
+        return false;
+    }
+
+    const DrawPriorityConfig *cfg = getDrawPriority(idx);
+    u8 xlu = linkResult != 0 ? dStageMgr_c::GetInstance()->checkFlag0x88A0(0x2) ? cfg->pDrawXlu : 0x84 : cfg->pDrawXlu;
+    mMdl.setPriorityDraw(cfg->pDrawOpa1, xlu);
+    bool anyAnims = false;
+    nw4r::g3d::ResAnmClr anmClr = resFile.GetResAnmClr(mdlName);
+    if (anmClr.IsValid()) {
+        mpAnmClr = new m3d::anmMatClr_c();
+        if (!mpAnmClr) {
+            return false;
+        }
+        if (!mpAnmClr->create(mdl, anmClr, &alloc, nullptr, 1)) {
+            return false;
+        }
+        mMdl.setAnm(*mpAnmClr);
+        anyAnims = true;
+    }
+
+    nw4r::g3d::ResAnmTexPat anmPat = resFile.GetResAnmTexPat(mdlName);
+    if (anmPat.IsValid()) {
+        mpAnmPat = new m3d::anmTexPat_c();
+        if (!mpAnmPat) {
+            return false;
+        }
+        if (!mpAnmPat->create(mdl, anmPat, &alloc, nullptr, 1)) {
+            return false;
+        }
+        mMdl.setAnm(*mpAnmPat);
+        anyAnims = true;
+    }
+
+    nw4r::g3d::ResAnmTexSrt anmSrt = resFile.GetResAnmTexSrt(mdlName);
+    if (!anmSrt.IsValid()) {
+        dStage_c::getMA0IndirectSrt(&anmSrt, mdl);
+    }
+    if (anmSrt.IsValid()) {
+        mpAnmSrt = new m3d::anmTexSrt_c();
+        if (!mpAnmSrt) {
+            return false;
+        }
+        if (!mpAnmSrt->create(mdl, anmSrt, &alloc, nullptr, 1)) {
+            return false;
+        }
+        mMdl.setAnm(*mpAnmSrt);
+        anyAnims = true;
+    }
+
+    nw4r::g3d::ResAnmVis anmVis = resFile.GetResAnmVis(mdlName);
+    if (anmVis.IsValid()) {
+        mpAnmVis = new m3d::anmVis_c();
+        if (!mpAnmVis) {
+            return false;
+        }
+        if (!mpAnmVis->create(mdl, anmVis, &alloc, nullptr)) {
+            return false;
+        }
+        mMdl.setAnm(*mpAnmVis);
+        anyAnims = true;
+    }
+
+    if (anyAnims) {
+        mMdl.setOption(nw4r::g3d::ScnObj::OPTION_DISABLE_CALC_WORLD, false);
+    }
+
+    return true;
+}
+
+void dRoom_c::model_c::execute(s32 idx, bool canHavePastState, f32 pastState) {
+    if (!mMdl.hasModel()) {
+        return;
+    }
+
+    if (mpAnmClr) {
+        mpAnmClr->play();
+    }
+
+    if (mpAnmSrt) {
+        mpAnmSrt->play();
+    }
+
+    if (mpAnmVis) {
+        mpAnmVis->play();
+    }
+
+    if (canHavePastState && !(idx >= 6)) {
+        if (mpAnmPat) {
+            int frame = (pastState > 0.0f);
+            mpAnmPat->setFrame(frame, 0);
+        } else {
+            const DrawPriorityConfig *cfg = getDrawPriority(idx);
+            if (pastState > 0.0f) {
+                mMdl.setPriorityDraw(cfg->pDrawOpa2, cfg->pDrawXlu);
+            } else {
+                mMdl.setPriorityDraw(cfg->pDrawOpa1, cfg->pDrawXlu);
+            }
+        }
+    } else {
+        if (mpAnmPat) {
+            mpAnmPat->play();
+        }
+    }
+}
+
+void dRoom_c::model_c::draw(int roomid) {
+    if (!mMdl.hasModel()) {
+        return;
+    }
+    mMdl.configureSomething();
+    configureSomething(roomid, &mMdl);
+    mMdl.entry();
+}
+
+extern "C" void fn_80017B10(nw4r::g3d::ResMdl &mdl, bool, bool);
+
+void dRoom_c::model_c::configureSomething(int roomid, mdl_c *mdl) {
+    nw4r::g3d::ResMdl resMdl = mdl->getResMdl();
+    fn_80017B10(resMdl, true, false);
+}
+
+const DrawPriorityConfig cfg[] = {
+    {0x18, 0x5, 0x7},
+    {0x1E, 0x5, 0x9},
+    {0x19, 0x6, 0x7},
+    {0x1F, 0x6, 0x9},
+    {0x1A, 0x7, 0x7},
+    {0x20, 0x7, 0x9},
+    {0x1B, 0x8, 0x7},
+    {0x21, 0x8, 0x9},
+};
+
+const DrawPriorityConfig *dRoom_c::model_c::getDrawPriority(s32 idx) {
+    return &cfg[idx];
+}
+
+bool dRoom_c::model_c::getBounds(mVec3_c *min, mVec3_c *max) const {
+    return mMdl.getBounds(min, max);
+}
+
+nw4r::g3d::ResNode dRoom_c::model_c::getResNode(const char *nodeName) {
+    return mMdl.getResMdl().GetResNode(nodeName);
+}
+
+void dRoom_c::model_c::updateObjNode(const char *node, bool visible) {
+    if (!mMdl.hasModel()) {
+        return;
+    }
+
+    nw4r::g3d::ResNode nd = getResNode(node);
+    if (!nd.IsValid()) {
+        return;
+    }
+
+    nd.SetVisibility(visible);
+    mMdl.somethingVisibility(nd.GetID(), visible);
+    if (visible) {
+        dTimeAreaMgr_c::sInstance->setField0x7A(true);
+    } else {
+        dTimeAreaMgr_c::sInstance->setField0x7A(false);
+    }
+}
+
+void dRoom_c::model_c::destroy() {
+    if (!mMdl.hasModel()) {
+        return;
+    }
+
+    nw4r::g3d::ScnMdl *mdl = nw4r::g3d::ScnObj::DynamicCast<nw4r::g3d::ScnMdl>(mMdl.getG3dObject());
+    nw4r::g3d::ResMdl resMdl = mMdl.getResMdl();
+    for (u32 i = 0; i < resMdl.GetResNodeNumEntries(); i++) {
+        nw4r::g3d::ResNode nd = resMdl.GetResNode(i);
+        nd.SetVisibility(true);
+        nw4r::g3d::ScnMdl::CopiedVisAccess v(mdl, i);
+        v.SetVisibility(true);
+    }
+}
+
+f32 dRoom_c::model_c::getFrame() const {
+    if (!mMdl.hasModel() || !mpAnmSrt) {
+        return 0.0f;
+    }
+    return mpAnmSrt->getFrame(0);
+}
diff --git a/src/d/d_sc_game.cpp b/src/d/d_sc_game.cpp
index d85b57a6..0ec9c5c7 100644
--- a/src/d/d_sc_game.cpp
+++ b/src/d/d_sc_game.cpp
@@ -2,6 +2,7 @@
 
 #include "common.h"
 #include "d/d_base.h"
+#include "d/d_stage_mgr.h"
 #include "d/flag/storyflag_manager.h"
 #include "f/f_base.h"
 #include "f/f_profile_name.h"
@@ -14,9 +15,7 @@
 #include "toBeSorted/file_manager.h"
 #include "toBeSorted/minigame_mgr.h"
 #include "toBeSorted/music_mgrs.h"
-#include "toBeSorted/room_manager.h"
 #include "toBeSorted/some_gxf_thing.h"
-#include "toBeSorted/stage_manager.h"
 
 #include <cstring>
 
@@ -249,11 +248,11 @@ void SpawnInfoExt::setSpawnData(
     mType0RotY = rot;
 }
 
-void LinkReloadInfo::set(u8 roomid, const mVec3_c &pos, mAng rot, u32 flags) {
+void LinkReloadInfo::set(u8 roomid, const mVec3_c &pos, mAng rot, u32 linkParams) {
     mRoomId = roomid;
     mPosition = pos;
     mRotY = rot;
-    mUnkFlags = flags;
+    mLinkParams = linkParams;
     mType0CsFlag = 1;
 }
 
diff --git a/src/d/d_stage.cpp b/src/d/d_stage.cpp
new file mode 100644
index 00000000..56fa4b6f
--- /dev/null
+++ b/src/d/d_stage.cpp
@@ -0,0 +1,399 @@
+#include "d/d_stage.h"
+
+#include "common.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/d_base.h"
+#include "d/d_bzs_types.h"
+#include "d/d_room.h"
+#include "d/d_sc_game.h"
+#include "d/d_sc_title.h"
+#include "d/d_stage_mgr.h"
+#include "d/flag/dungeonflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
+#include "d/flag/storyflag_manager.h"
+#include "f/f_base.h"
+#include "f/f_profile.h"
+#include "f/f_profile_name.h"
+#include "m/m_fader_base.h"
+#include "m/m_vec.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmat.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "nw4r/math/math_types.h"
+#include "s/s_FPhase.h"
+#include "toBeSorted/arc_managers/current_stage_arc_manager.h"
+#include "toBeSorted/arc_managers/layout_arc_manager.h"
+#include "toBeSorted/arc_managers/oarc_manager.h"
+#include "toBeSorted/event_manager.h"
+#include "toBeSorted/music_mgrs.h"
+#include "toBeSorted/time_area_mgr.h"
+
+#include <cstring>
+
+SPECIAL_BASE_PROFILE(STAGE, dStage_c, fProfile::STAGE, 6, 0x4E0);
+
+sFPhase<dStage_c>::phaseCallback dStage_c::sCallbacks[] = {
+    &dStage_c::createRooms,
+    &dStage_c::waitForRooms,
+    nullptr,
+};
+
+extern "C" void fn_8001BE60(f32, f32);
+extern "C" void *SCRAPPER_PTR;
+
+dStage_c::dStage_c() : mPhase(this, sCallbacks) {
+    memset(loaded_entities, 0, sizeof(loaded_entities));
+    sInstance = this;
+    dScGame_c::resetUpdateFrameCount();
+    SCRAPPER_PTR = nullptr;
+    fn_8001BE60(2000.0f, 1700.0f);
+}
+
+extern "C" void *SCRAPPER_PICKUP_TARGET;
+extern "C" void ScrapperPickupMgr__update(void *);
+extern "C" void ScrapperPickupMgr__dtor();
+extern "C" void fn_80028A80();
+extern "C" void fn_80028EC0();
+extern "C" void fn_80066D30(s32);
+extern "C" void setPCAMpos2(const PCAM *);
+
+int dStage_c::create() {
+    if (mPhase.step() != sFPhaseBase::PHASE_ALL_DONE) {
+        return NOT_READY;
+    }
+
+    dStageMgr_c *stageMgr = dStageMgr_c::GetInstance();
+    const PCAM *pcam = stageMgr->getPcam();
+    for (int i = 0; i < stageMgr->getPcamCount(); i++) {
+        setPCAMpos2(pcam);
+        pcam++;
+    }
+
+    if (mapRelated.field_0x1EB == 0) {
+        mVec3_c min, max;
+        for (s32 i = 0; i < MAX_ROOM_NUMBER - 1; i++) {
+            dRoom_c *room = getRoom(i);
+            if (room != nullptr) {
+                mVec3_c tmin, tmax;
+                room->getBounds(&tmin, &tmax);
+                if (i == 0) {
+                    min = tmin;
+                    max = tmax;
+                } else {
+                    nw4r::math::VEC3Minimize(min, min, tmin);
+                    nw4r::math::VEC3Maximize(max, max, tmax);
+                }
+            }
+        }
+        max.y += 6000.0f;
+        mVec3_c size = max - min;
+        mVec3_c center = mVec3_c(min.x + size.x * 0.5f, min.y, min.z + size.z * 0.5f);
+        mapRelated.fn_801B4B80(0, center, size);
+        mVec3_c v = mVec3_c(10000.0f, 10000.0f, 100000.0f);
+        mapRelated.fn_801B4C70(v);
+    }
+    mapRelated.fn_801B50C0(0);
+    fn_80028A80();
+
+    return SUCCEEDED;
+}
+
+int dStage_c::doDelete() {
+    fn_80028EC0();
+    fn_80066D30(-1);
+    ScrapperPickupMgr__dtor();
+    return SUCCEEDED;
+}
+
+int dStage_c::execute() {
+    mFader.calc();
+    ScrapperPickupMgr__update(SCRAPPER_PICKUP_TARGET);
+    return SUCCEEDED;
+}
+
+extern "C" void resetViewClipVals();
+
+int dStage_c::draw() {
+    resetViewClipVals();
+    return SUCCEEDED;
+}
+
+void dStage_c::deleteReady() {}
+
+sFPhaseBase::sFPhaseState dStage_c::createRooms() {
+    // TODO
+    // if (dScGame_c::sCo)
+    mFader.create();
+    mFader.setTypes(1, 1);
+    mFader.setFadeInFrame(1);
+    mFader.fadeIn();
+    mFader.calc();
+    mFader.setFrames(15, 15);
+    mFader.initForLyt();
+    // TODO
+
+    if (dScTitle_c::sInstance != nullptr) {
+        dBase_c::createBase(fProfile::TITLE, this, 0, OTHER);
+    }
+
+    dTimeAreaMgr_c::sInstance->setField0x78(false);
+
+    return sFPhaseBase::PHASE_NEXT;
+}
+
+sFPhaseBase::sFPhaseState dStage_c::waitForRooms() {
+    if (checkChildProcessCreateState()) {
+        return sFPhaseBase::PHASE_RETRY;
+    }
+    return sFPhaseBase::PHASE_NEXT;
+}
+
+void dStage_c::setRoom(int roomid, dRoom_c *room) {
+    rooms.setRoom(roomid, room);
+}
+
+dRoom_c *dStage_c::getRoom(s32 idx) {
+    return rooms.getRoom(idx);
+}
+
+bool dStage_c::fadeIn(s32 fadeType, u16 frames) {
+    if (mFader.getStatus() != mFaderBase_c::FADED_OUT) {
+        return false;
+    }
+    mFader.setFadeInType(fadeType);
+    mFader.setFadeInFrame(frames);
+    mFader.fadeIn();
+    fn_80384570(ENEMY_BGM_RELATED_MGR, false);
+    return true;
+}
+
+bool dStage_c::fadeOut(s32 fadeType, u16 frames) {
+    if (mFader.getStatus() != mFaderBase_c::FADED_IN) {
+        return false;
+    }
+    mFader.setFadeOutType(fadeType);
+    mFader.setFadeOutFrame(frames);
+    mFader.fadeOut();
+    fn_80384570(ENEMY_BGM_RELATED_MGR, true);
+    return true;
+}
+
+void dStage_c::forceFadeOut() {
+    mFader.setStatus(mFaderBase_c::FADED_OUT);
+    fn_80384570(ENEMY_BGM_RELATED_MGR, true);
+}
+
+void dStage_c::forceFadeIn() {
+    mFader.setStatus(mFaderBase_c::FADED_IN);
+    fn_80384570(ENEMY_BGM_RELATED_MGR, false);
+}
+
+void dStage_c::drawMap(mMtx_c *mtx, int param) {
+    dBgS::GetInstance()->UpdateScrollTex();
+    for (s32 i = 0; i < MAX_ROOM_NUMBER - 1; i++) {
+        dRoom_c *room = getRoom(i);
+        if (room != nullptr) {
+            room->drawOnMapIfVisible(mtx, param);
+        }
+    }
+    dBgS::GetInstance()->DrawSkyKeepMap(mtx, param);
+}
+
+static void getFlagPositionForRoomVisit(int roomid, u16 *o_flag, u16 *o_shift) {
+    *o_flag = (roomid / 16) + 8;
+    *o_shift = 1 << (roomid % 16);
+}
+
+bool dStage_c::hasVisitedRoom(int roomid) const {
+    u16 flag, shift;
+    getFlagPositionForRoomVisit(roomid, &flag, &shift);
+    DungeonflagManager *mg = DungeonflagManager::sInstance;
+    return (mg->getCounterOrFlag(flag, 8) & shift) != 0;
+}
+
+void dStage_c::setRoomVisited(int roomid) {
+    // TODO this is probably an inline but inline bools cause extra instructions
+    if (EventManager::getCurrentEventName() != nullptr &&
+        std::strncmp(EventManager::getCurrentEventName(), "Save", 0x20) == 0) {
+        return;
+    }
+
+    if (dScGame_c::sInstance == nullptr || dScGame_c::sInstance->profile_name == fProfile::GAME) {
+        u16 flag, shift;
+        getFlagPositionForRoomVisit(roomid, &flag, &shift);
+        DungeonflagManager *mg = DungeonflagManager::sInstance;
+        u16 newVal = shift | mg->getCounterOrFlag(flag, 8);
+        mg->setToValue(flag, newVal);
+    }
+}
+
+dRoom_c *dStage_c::createRoom(int roomid, bool flag0x40) {
+    return static_cast<dRoom_c *>(
+        dBase_c::createBase(fProfile::ROOM, this, (roomid & 0x3F) | (flag0x40 ? 0x40 : 0), OTHER)
+    );
+}
+
+void dStage_c::createLytSeekerStone() {
+    dBase_c::createBase(fProfile::LYT_CONTROL_GAME, this, 0, OTHER);
+    if (LayoutArcManager::sInstance->hasEntry("SeekerStone")) {
+        dBase_c::createBase(fProfile::LYT_SEEKER_STONE, this, 0, OTHER);
+    }
+}
+
+dBase_c *dStage_c::getParentForRoom(s32 idx) {
+    if (idx == -1) {
+        return dStage_c::GetInstance();
+    }
+    return dStage_c::GetInstance()->getRoom(idx);
+}
+
+void dStage_c::bindStageResToFile(nw4r::g3d::ResFile *file) {
+    nw4r::g3d::ResFile f = nw4r::g3d::ResFile(CurrentStageArcManager::sInstance->getData("g3d/stage.brres"));
+    if (f.IsValid()) {
+        file->Bind(f);
+    }
+}
+
+void dStage_c::bindSkyCmnToResFile(nw4r::g3d::ResFile *file) {
+    nw4r::g3d::ResFile f = nw4r::g3d::ResFile(OarcManager::sInstance->getSubEntryData("SkyCmn", "g3d/model.brres"));
+    if (f.IsValid()) {
+        file->Bind(f);
+    }
+}
+
+static const char *sMatsToTry[] = {
+    "MA01",
+    "MA02",
+    "MA04",
+};
+
+bool dStage_c::getMA0AnmTexSrt(nw4r::g3d::ResAnmTexSrt *o_srt, const char *matName) {
+    const char **candidate = sMatsToTry;
+    for (int i = 0; i < ARRAY_LENGTH(sMatsToTry); i++, candidate++) {
+        if (!std::strncmp(matName, *candidate, std::strlen(*candidate))) {
+            nw4r::g3d::ResFile mdl = nw4r::g3d::ResFile(OarcManager::sInstance->getMdlFromArc2("Common"));
+            *o_srt = mdl.GetResAnmTexSrt(*candidate);
+            return true;
+        }
+    }
+    return false;
+}
+
+bool dStage_c::getMA0IndirectSrt(nw4r::g3d::ResAnmTexSrt *o_srt, const nw4r::g3d::ResMdl &mdl) {
+    for (u32 i = 0; i < mdl.GetResMatNumEntries(); i++) {
+        nw4r::g3d::ResMat mat = mdl.GetResMat(i);
+        const char *name = mat.GetName();
+        if (getMA0AnmTexSrt(o_srt, name)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+dRoomTable_c::dRoomTable_c() {
+    // Okay
+    mRooms[0] = nullptr;
+    mRooms[1] = nullptr;
+    mRooms[2] = nullptr;
+    mRooms[3] = nullptr;
+    mRooms[4] = nullptr;
+    mRooms[5] = nullptr;
+    mRooms[6] = nullptr;
+    mRooms[7] = nullptr;
+    mRooms[8] = nullptr;
+    mRooms[9] = nullptr;
+    mRooms[10] = nullptr;
+    mRooms[11] = nullptr;
+    mRooms[12] = nullptr;
+    mRooms[13] = nullptr;
+    mRooms[14] = nullptr;
+    mRooms[15] = nullptr;
+    mRooms[16] = nullptr;
+    mRooms[17] = nullptr;
+    mRooms[18] = nullptr;
+    mRooms[19] = nullptr;
+    mRooms[20] = nullptr;
+    mRooms[21] = nullptr;
+    mRooms[22] = nullptr;
+    mRooms[23] = nullptr;
+    mRooms[24] = nullptr;
+    mRooms[25] = nullptr;
+    mRooms[26] = nullptr;
+    mRooms[27] = nullptr;
+    mRooms[28] = nullptr;
+    mRooms[29] = nullptr;
+    mRooms[30] = nullptr;
+    mRooms[31] = nullptr;
+    mRooms[32] = nullptr;
+    mRooms[33] = nullptr;
+    mRooms[34] = nullptr;
+    mRooms[35] = nullptr;
+    mRooms[36] = nullptr;
+    mRooms[37] = nullptr;
+    mRooms[38] = nullptr;
+    mRooms[39] = nullptr;
+    mRooms[40] = nullptr;
+    mRooms[41] = nullptr;
+    mRooms[42] = nullptr;
+    mRooms[43] = nullptr;
+    mRooms[44] = nullptr;
+    mRooms[45] = nullptr;
+    mRooms[46] = nullptr;
+    mRooms[47] = nullptr;
+    mRooms[48] = nullptr;
+    mRooms[49] = nullptr;
+    mRooms[50] = nullptr;
+    mRooms[51] = nullptr;
+    mRooms[52] = nullptr;
+    mRooms[53] = nullptr;
+    mRooms[54] = nullptr;
+    mRooms[55] = nullptr;
+    mRooms[56] = nullptr;
+    mRooms[57] = nullptr;
+    mRooms[58] = nullptr;
+    mRooms[59] = nullptr;
+    mRooms[60] = nullptr;
+    mRooms[61] = nullptr;
+    mRooms[62] = nullptr;
+}
+
+MapRelated::MapRelated()
+    : field_0x0FC(0.0f, 0.0f, 0.0f),
+      field_0x108(0.0f),
+      field_0x10C(0.0f),
+      field_0x110(0.0f),
+      field_0x114(0.0f),
+      field_0x118(0.0f),
+      field_0x11C(0.0f),
+      field_0x120(0.0f),
+      field_0x124(0.0f),
+      field_0x128(0.0f),
+      field_0x12C(0.0f),
+      field_0x1E0(0),
+      field_0x1E6(0),
+      field_0x1E8(0),
+      field_0x1E9(4),
+      field_0x1EA(-3),
+      field_0x1EB(0),
+      field_0x1EC(0),
+      field_0x1ED(0),
+      field_0x1EE(0),
+      field_0x1F0(0) {
+    mPostEffect.setField0x30(0.15f);
+    bool showPastVariant = true;
+    bool showDesertPast = dScGame_c::isCurrentStage("S300") ||
+                          ((dScGame_c::isCurrentStage("F300") || dScGame_c::isCurrentStage("F300_4")) &&
+                           SceneflagManager::sInstance->checkTempOrSceneflag(3));
+    if (!showDesertPast) {
+        bool hideSeaPast = !(dScGame_c::isCurrentStage("F301_1") && StoryflagManager::sInstance->getCounterOrFlag(519));
+        if (hideSeaPast) {
+            showPastVariant = false;
+        }
+    }
+    field_0x1EF = showPastVariant;
+}
+
+extern "C" void fn_801B4AE0();
+MapRelated::~MapRelated() {
+    fn_801B4AE0();
+}
diff --git a/src/d/d_stage_mgr.cpp b/src/d/d_stage_mgr.cpp
new file mode 100644
index 00000000..b5056a69
--- /dev/null
+++ b/src/d/d_stage_mgr.cpp
@@ -0,0 +1,295 @@
+#include "d/d_stage_mgr.h"
+
+#include "common.h"
+#include "d/d_base.h"
+#include "d/d_bzs_types.h"
+#include "d/d_heap.h"
+#include "d/d_last.h"
+#include "d/d_sc_game.h"
+#include "d/d_stage_parse.h"
+#include "d/d_sys.h"
+#include "d/flag/flag_managers.h"
+#include "egg/core/eggHeap.h"
+#include "f/f_base.h"
+#include "f/f_profile_name.h"
+#include "m/m_dvd.h"
+#include "toBeSorted/arc_managers/current_stage_arc_manager.h"
+#include "toBeSorted/arc_managers/layout_arc_manager.h"
+#include "toBeSorted/arc_managers/oarc_manager.h"
+#include "toBeSorted/music_mgrs.h"
+
+SPECIAL_BASE_PROFILE(STAGE_MANAGER, dStageMgr_c, fProfile::STAGE_MANAGER, 0X5, 1536);
+
+STATE_DEFINE(dStageMgr_c, ReadStageRes);
+STATE_DEFINE(dStageMgr_c, ReadRoomRes);
+STATE_DEFINE(dStageMgr_c, ReadObjectRes);
+STATE_DEFINE(dStageMgr_c, ReadStageLayerRes);
+STATE_DEFINE(dStageMgr_c, ReadLayerObjectRes);
+STATE_DEFINE(dStageMgr_c, SoundLoadSceneData);
+STATE_DEFINE(dStageMgr_c, CreateObject);
+STATE_DEFINE(dStageMgr_c, ReadObjectSound);
+STATE_DEFINE(dStageMgr_c, SceneChangeSave);
+STATE_DEFINE(dStageMgr_c, RestartSceneWait);
+STATE_DEFINE(dStageMgr_c, RestartScene);
+
+dStageMgr_c::dStageMgr_c() : mStateMgr(*this, sStateID::null), mPhase(this, sCallbacks) {
+    sInstance = this;
+}
+
+dStageMgr_c::~dStageMgr_c() {
+    sInstance = nullptr;
+}
+
+void dStageMgr_c::initializeState_ReadStageRes() {
+    CurrentStageArcManager::sInstance->setStage(dScGame_c::currentSpawnInfo.stageName);
+}
+
+void dStageMgr_c::executeState_ReadStageRes() {
+    if (CurrentStageArcManager::sInstance->ensureAllEntriesLoaded() == 0) {
+        mStateMgr.changeState(StateID_ReadRoomRes);
+    }
+}
+
+void dStageMgr_c::finalizeState_ReadStageRes() {
+    const void *stageBzs = CurrentStageArcManager::sInstance->getData("dat/stage.bzs");
+    if (stageBzs != nullptr) {
+        parseStageBzs(-1, stageBzs);
+        parseRoomStageBzs(-1, stageBzs);
+    }
+    fn_803618F0(ENEMY_SOUND_MGR);
+}
+
+void dStageMgr_c::initializeState_ReadRoomRes() {}
+
+void dStageMgr_c::executeState_ReadRoomRes() {
+    if (CurrentStageArcManager::sInstance->ensureAllEntriesLoaded() == 0 &&
+        LayoutArcManager::sInstance->ensureAllEntriesLoaded() == 0) {
+        mStateMgr.changeState(StateID_ReadObjectRes);
+    }
+}
+
+void dStageMgr_c::finalizeState_ReadRoomRes() {
+    if (mpRmpl != nullptr) {
+        const RMPL *itRmpl = mpRmpl;
+        for (int i = 0; i < mRmplCount; itRmpl++, i++) {
+            const void *bzs = CurrentStageArcManager::sInstance->loadFromRoomArc(itRmpl->roomId, "dat/room.bzs");
+            parseRoomStageBzs(itRmpl->roomId, bzs);
+        }
+    } else {
+        u32 roomId = dScGame_c::currentSpawnInfo.room;
+        const void *bzs =
+            CurrentStageArcManager::sInstance->loadFromRoomArc(dScGame_c::currentSpawnInfo.room, "dat/room.bzs");
+        parseRoomStageBzs(roomId, bzs);
+    }
+}
+
+void dStageMgr_c::initializeState_ReadObjectRes() {
+    mStageObjCtrl.doLoad();
+}
+
+void dStageMgr_c::executeState_ReadObjectRes() {
+    if (mStageObjCtrl.isLoaded()) {
+        mStateMgr.changeState(StateID_ReadStageLayerRes);
+    }
+}
+
+void dStageMgr_c::finalizeState_ReadObjectRes() {}
+
+void dStageMgr_c::initializeState_ReadStageLayerRes() {
+    CurrentStageArcManager::sInstance->loadFileFromExtraLayerArc(dScGame_c::currentSpawnInfo.layer);
+}
+
+void dStageMgr_c::executeState_ReadStageLayerRes() {
+    if (CurrentStageArcManager::sInstance->ensureAllEntriesLoaded() == 0) {
+        mStateMgr.changeState(StateID_ReadLayerObjectRes);
+    }
+}
+
+void dStageMgr_c::finalizeState_ReadStageLayerRes() {}
+
+const char demoName[] = "";
+static const char *sSeekerStoneLayoutArcs[] = {
+    "SeekerStone",
+};
+
+void dStageMgr_c::initializeState_ReadLayerObjectRes() {
+    mDemoName = demoName;
+
+    const void *bzs = CurrentStageArcManager::sInstance->getData("dat/stage.bzs");
+    if (bzs != nullptr) {
+        parseBzsStageRoom(-1, bzs);
+    }
+
+    if (mpRmpl != nullptr) {
+        const RMPL *itRmpl = mpRmpl;
+        for (int i = 0; i < mRmplCount; itRmpl++, i++) {
+            const void *bzs = CurrentStageArcManager::sInstance->loadFromRoomArc(itRmpl->roomId, "dat/room.bzs");
+            parseBzsStageRoom(itRmpl->roomId, bzs);
+        }
+    } else {
+        u32 roomId = dScGame_c::currentSpawnInfo.room;
+        const void *bzs =
+            CurrentStageArcManager::sInstance->loadFromRoomArc(dScGame_c::currentSpawnInfo.room, "dat/room.bzs");
+        parseBzsStageRoom(roomId, bzs);
+    }
+
+    if (dScGame_c::isStateLayerWithSeekerStoneHintMenu()) {
+        mLayoutArcCtrl2.set(sSeekerStoneLayoutArcs, ARRAY_LENGTH(sSeekerStoneLayoutArcs));
+        mLayoutArcCtrl2.load(dHeap::work2Heap.heap);
+        addActorId(fProfile::LYT_SEEKER_STONE);
+    }
+    mLayerObjCtrl.doLoad();
+}
+
+void dStageMgr_c::executeState_ReadLayerObjectRes() {
+    if (mLayerObjCtrl.isLoaded() && LayoutArcManager::sInstance->ensureAllEntriesLoaded() == 0) {
+        mStateMgr.changeState(StateID_SoundLoadSceneData);
+    }
+}
+
+extern "C" void fn_800C85D0(void *, EGG::Heap *heap, bool, void *jpc, void *jpn);
+extern "C" void *FOR_LOADED_PARTICLES;
+
+void dStageMgr_c::finalizeState_ReadLayerObjectRes() {
+    if (mDemoName.len() != 0) {
+        const char *name = mDemoName;
+        void *jpc = OarcManager::sInstance->getSubEntryData(name, "dat/jparticle.jpc");
+        if (jpc != nullptr) {
+            void *jpn = OarcManager::sInstance->getSubEntryData(name, "dat/jparticle.jpn");
+            fn_800C85D0(FOR_LOADED_PARTICLES, dHeap::work2Heap.heap, true, jpc, jpn);
+        }
+    }
+}
+
+static void *soundCallback(void *arg) {
+    fn_80362730(ENEMY_SOUND_MGR);
+    return reinterpret_cast<void *>(true);
+}
+
+void dStageMgr_c::initializeState_SoundLoadSceneData() {
+    fn_803624F0(ENEMY_SOUND_MGR);
+    mpDvdCallback = mDvd_callback_c::createOrDie(soundCallback, nullptr);
+}
+
+void dStageMgr_c::executeState_SoundLoadSceneData() {
+    if (mpDvdCallback != nullptr && mpDvdCallback->mStatus != 0) {
+        mStateMgr.changeState(StateID_CreateObject);
+    }
+}
+
+void dStageMgr_c::finalizeState_SoundLoadSceneData() {
+    mpDvdCallback->do_delete();
+    mpDvdCallback = nullptr;
+}
+
+void dStageMgr_c::initializeState_CreateObject() {
+    // too much egg
+}
+
+void dStageMgr_c::executeState_CreateObject() {
+    if (!checkChildProcessCreateState()) {
+        mStateMgr.changeState(StateID_ReadObjectSound);
+    }
+}
+
+void dStageMgr_c::finalizeState_CreateObject() {}
+
+static void *soundCallback2(void *arg) {
+    fn_80365D20(ENEMY_SOUND_MGR);
+    return reinterpret_cast<void *>(true);
+}
+
+void dStageMgr_c::initializeState_ReadObjectSound() {
+    mpDvdCallback2 = mDvd_callback_c::createOrDie(soundCallback2, nullptr);
+}
+
+void dStageMgr_c::executeState_ReadObjectSound() {
+    if (mpDvdCallback2 == nullptr) {
+        return;
+    }
+
+    if (mpDvdCallback2->mStatus == 0) {
+        return;
+    }
+
+    if (dScGame_c::sInstance != nullptr) {
+        if (dScGame_c::sInstance->savePromptFlag() == true) {
+            mStateMgr.changeState(StateID_SceneChangeSave);
+        } else {
+            mStateMgr.changeState(StateID_RestartSceneWait);
+        }
+        return;
+    }
+
+    mStateMgr.changeState(StateID_RestartSceneWait);
+}
+
+void dStageMgr_c::finalizeState_ReadObjectSound() {
+    mpDvdCallback2->do_delete();
+    // mpDvdCallback2 = nullptr;
+    clearProcControlFlag(ROOT_DISABLE_EXECUTE);
+    clearProcControlFlag(ROOT_DISABLE_DRAW);
+    dLast_c::setExecuteCallback(lastExecuteCallback);
+}
+
+extern "C" void *LYT_SAVE_MGR;
+extern "C" void fn_80285600(void *, int, int);
+void dStageMgr_c::initializeState_SceneChangeSave() {
+    dScGame_c::sInstance->setSavePromptFlag(false);
+    if (LYT_SAVE_MGR != nullptr) {
+        fn_80285600(LYT_SAVE_MGR, 3, 0);
+    }
+    dBase_c::s_NextExecuteControlFlags |= 1;
+    dSys::setFrameRate(2);
+}
+
+void dStageMgr_c::executeState_SceneChangeSave() {
+    if (LYT_SAVE_MGR != nullptr) {
+        // "isNotSaving???"
+        if (((u8 *)LYT_SAVE_MGR)[0x119C] == true) {
+            mStateMgr.changeState(StateID_RestartSceneWait);
+        }
+    } else {
+        mStateMgr.changeState(StateID_RestartSceneWait);
+    }
+}
+
+void dStageMgr_c::finalizeState_SceneChangeSave() {
+    dBase_c::s_NextExecuteControlFlags &= ~1;
+    dBase_c::s_DrawControlFlags &= ~1;
+}
+
+void dStageMgr_c::initializeState_RestartSceneWait() {
+    dSys::setFrameRate(2);
+}
+
+void dStageMgr_c::executeState_RestartSceneWait() {
+    if (mFader.isSettled()) {
+        if (mFader.isStatus(mFaderBase_c::FADED_IN)) {
+            if (field_0x88BC) {
+                mStateMgr.changeState(StateID_RestartScene);
+            }
+        } else {
+            mFader.fadeIn();
+        }
+        // TODO
+        mFader.calc();
+    }
+}
+
+void dStageMgr_c::finalizeState_RestartSceneWait() {}
+
+void dStageMgr_c::initializeState_RestartScene() {
+    triggerFade(dScGame_c::nextSpawnInfo.transitionType, dScGame_c::nextSpawnInfo.transitionFadeFrames);
+    mFader.setFadeInType(dScGame_c::nextSpawnInfo.transitionType);
+    fn_803625F0(ENEMY_SOUND_MGR, mFader.getFadeOutFrame());
+}
+
+void dStageMgr_c::executeState_RestartScene() {
+    if (mFader.isStatus(mFaderBase_c::FADED_OUT)) {}
+}
+
+void dStageMgr_c::finalizeState_RestartScene() {
+    commitAllFlagManagers();
+    dSys::setFrameRate(1);
+}
diff --git a/src/d/d_stage_parse.cpp b/src/d/d_stage_parse.cpp
new file mode 100644
index 00000000..30e2f20e
--- /dev/null
+++ b/src/d/d_stage_parse.cpp
@@ -0,0 +1,519 @@
+#include "d/d_stage_parse.h"
+
+#include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/d_base.h"
+#include "d/d_bzs_types.h"
+#include "d/d_room.h"
+#include "d/d_sc_game.h"
+#include "d/d_stage.h"
+#include "d/d_stage_mgr.h"
+#include "d/flag/flag_managers.h"
+#include "d/flag/storyflag_manager.h"
+#include "f/f_base.h"
+#include "f/f_profile_name.h"
+#include "m/m_angle.h"
+#include "m/m_vec.h"
+#include "sized_string.h"
+#include "toBeSorted/file_manager.h"
+
+struct BzsHeader {
+    /* 0x00 */ u32 mName;
+    /* 0x04 */ u16 mSectionCount;
+    /* 0x08 */ u32 mOffset;
+};
+
+struct BzsSectionHead {
+    /* 0x00 */ u32 mTag;
+    /* 0x04 */ u16 mCount;
+    /* 0x08 */ u32 mOffset;
+};
+
+typedef void (*BzsParseFunc)(int roomid, const BzsSectionHead *section);
+
+struct BzsTagToParseFunc {
+    /* 0x00 */ u32 mTag;
+    /* 0x04 */ BzsParseFunc mParseFunc;
+};
+
+#define OFS_TO_PTR(ty, section)                                                                                        \
+    (reinterpret_cast<const ty *>(reinterpret_cast<const char *>(section) + section->mOffset))
+
+static void findAndRunStageTagParseFunc(
+    int roomid, const BzsSectionHead *head, const BzsTagToParseFunc *handlerTable, s32 tableSize
+);
+
+static void handleBzsPcam(int roomid, const BzsSectionHead *section) {
+    dStageMgr_c::GetInstance()->setPcam(OFS_TO_PTR(PCAM, section), section->mCount);
+}
+
+static void handleBzsLyse(int roomid, const BzsSectionHead *section) {
+    dStageMgr_c::GetInstance()->setLyse(OFS_TO_PTR(LYSE, section), section->mCount);
+    dStageMgr_c::GetInstance()->overrideLayer0WithLyse();
+}
+
+static void handleBzsStif(int roomid, const BzsSectionHead *section) {
+    // section->mCount == 1
+    dStageMgr_c::GetInstance()->setStif(OFS_TO_PTR(STIF, section));
+    s16 flagIndex = dStageMgr_c::GetInstance()->getFlagIndex();
+    FileManager::sInstance->setSceneFlagIndex(flagIndex);
+    updateFlagForFlagIndex(flagIndex);
+}
+
+static void handleBzsRmpl(int roomid, const BzsSectionHead *section) {
+    dStageMgr_c::GetInstance()->setRmpl(OFS_TO_PTR(RMPL, section), section->mCount);
+}
+
+static void handleBzsFile(int roomid, const BzsSectionHead *section) {
+    const bzsFILE *file = OFS_TO_PTR(bzsFILE, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setFile(file, section->mCount);
+}
+
+static void handleBzsLylt(int roomid, const BzsSectionHead *section) {
+    const LYLT *lylt = OFS_TO_PTR(LYLT, section);
+    for (s32 i = 0; i < section->mCount; i++) {
+        if (lylt->layer == dScGame_c::currentSpawnInfo.layer && lylt->demoHigh >= 0) {
+            SizedString<16> demoName;
+            demoName.sprintf("Demo%02d_%02d", lylt->demoHigh, lylt->demoLow);
+            dStageMgr_c::GetInstance()->setDemoName(demoName);
+            dStageMgr_c::GetInstance()->addLayerArcn(dStageMgr_c::GetInstance()->getDemoName());
+        }
+        lylt++;
+    }
+}
+
+static void handleBzsScen(int roomid, const BzsSectionHead *section) {
+    const SCEN *scen = OFS_TO_PTR(SCEN, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setScen(scen, section->mCount);
+}
+
+static void handleBzsCam(int roomid, const BzsSectionHead *section) {
+    const CAM *cam = OFS_TO_PTR(CAM, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setCam(cam, section->mCount);
+}
+
+static void handleBzsEvnt(int roomid, const BzsSectionHead *section) {
+    const EVNT *evnt = OFS_TO_PTR(EVNT, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setEvnt(evnt, section->mCount);
+}
+
+static void handleBzsPath(int roomid, const BzsSectionHead *section) {
+    const PATH *path = OFS_TO_PTR(PATH, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setPath(path, section->mCount);
+}
+
+static void handleBzsPnt(int roomid, const BzsSectionHead *section) {
+    const PNT *pnt = OFS_TO_PTR(PNT, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setPnt(pnt, section->mCount);
+}
+
+static void handleBzsBpnt(int roomid, const BzsSectionHead *section) {
+    const BPNT *bpnt = OFS_TO_PTR(BPNT, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setBpnt(bpnt, section->mCount);
+}
+
+static void handleBzsSpth(int roomid, const BzsSectionHead *section) {
+    const SPTH *spth = OFS_TO_PTR(SPTH, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setSpth(spth, section->mCount);
+}
+
+static void handleBzsSpnt(int roomid, const BzsSectionHead *section) {
+    const SPNT *spnt = OFS_TO_PTR(SPNT, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setSpnt(spnt, section->mCount);
+}
+
+static void handleBzsSbpt(int roomid, const BzsSectionHead *section) {
+    const SBPT *sbpt = OFS_TO_PTR(SBPT, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setSbpt(sbpt, section->mCount);
+}
+
+static void handleBzsArea(int roomid, const BzsSectionHead *section) {
+    const AREA *area = OFS_TO_PTR(AREA, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setArea(area, section->mCount);
+}
+
+extern "C" bool fn_8005C5D0(u32);
+extern "C" void spawnLightObject();
+extern "C" void spawnWeatherTag();
+
+static void handleBzsPly(int roomid, const BzsSectionHead *section) {
+    const PLY *ply = OFS_TO_PTR(PLY, section);
+    dRoom_c *room = dStage_c::GetInstance()->getRoom(roomid);
+    room->setPly(ply, section->mCount);
+
+    if (roomid == dScGame_c::currentSpawnInfo.room) {
+        dScGame_c *sc = dScGame_c::GetInstance();
+        const mVec3_c *linkPos;
+        const mAng3_c *linkAngle;
+        mAng3_c ang(0, 0, 0);
+        mVec3_c pos;
+        u32 linkActorParams = 0x7FFFFFF;
+        bool param = 0;
+        bool preventSetRespawnInfo = false;
+        u8 reloaderType = dScGame_c::getReloaderType();
+        if (reloaderType != 0) {
+            FileManager *fileMgr = FileManager::sInstance;
+            if (reloaderType == 2) {
+                pos = *FileManager::sInstance->getPosT2();
+                ang.y = fileMgr->getAngleT2();
+                linkPos = &pos;
+                linkAngle = &ang;
+                linkActorParams = 0x7FFFF1B;
+            } else if (reloaderType == 3) {
+                pos = *FileManager::sInstance->getPosT3();
+                ang.y = fileMgr->getAngleT3();
+                linkPos = &pos;
+                linkAngle = &ang;
+                if (!StoryflagManager::sInstance->getCounterOrFlag(752) &&
+                    !StoryflagManager::sInstance->getCounterOrFlag(119)) {
+                    const PLY *entrance = room->getEntranceById(dScGame_c::currentSpawnInfo.entrance);
+                    if (fn_8005C5D0(entrance->linkParams) == true) {
+                        linkActorParams = entrance->linkParams;
+                    }
+                }
+            } else {
+                if (FileManager::sInstance->getEntranceLoadFlagT1() == 0 && dScGame_c::getReloaderType() != 4) {
+                    pos = *fileMgr->getPosT1();
+                    ang.y = fileMgr->getAngleT1();
+                    if (fileMgr->fn_8000CC00() == 2) {
+                        const PLY *entrance = room->getEntranceById(dScGame_c::currentSpawnInfo.entrance);
+                        linkActorParams = entrance->linkParams;
+                    }
+                    linkPos = &pos;
+                    linkAngle = &ang;
+                } else {
+                    const PLY *entrance = room->getEntranceById(dScGame_c::currentSpawnInfo.entrance);
+                    linkActorParams = entrance->linkParams;
+                    linkPos = &entrance->position;
+                    linkAngle = &entrance->angle;
+                }
+            }
+            dScGame_c::setReloaderType(0);
+            if (sc->getType0CsFlag() != 0) {
+                sc->setType0CsFlag(0);
+            }
+        } else {
+            if (dScGame_c::GetInstance()->getType0CsFlag() != 0) {
+                preventSetRespawnInfo = true;
+                const LinkReloadInfo &info = dScGame_c::GetInstance()->getLinkReloadInfo();
+                ang.y = info.mRotY;
+                linkPos = &info.mPosition;
+                linkAngle = &ang;
+                linkActorParams = info.mLinkParams;
+                sc->setType0CsFlag(0);
+            } else if (dScGame_c::GetInstance()->getType0PosFlag() != 0) {
+                const SpawnInfoExt &info = dScGame_c::GetInstance()->getSpawnInfo();
+                pos = info.mType0Pos;
+                linkPos = &pos;
+                ang.y = info.mType0RotY;
+                linkAngle = &ang;
+                sc->setType0PosFlag(0);
+            } else {
+                const PLY *entrance = room->getEntranceById(dScGame_c::currentSpawnInfo.entrance);
+                linkActorParams = entrance->linkParams;
+                linkPos = &entrance->position;
+                linkAngle = &entrance->angle;
+                param = true;
+            }
+        }
+
+        // TODO constify args
+        dAcObjBase_c::create(
+            fProfile::PLAYER, -1, linkActorParams, (mVec3_c *)linkPos, (mAng3_c *)linkAngle, nullptr, -1
+        );
+        if (!preventSetRespawnInfo) {
+            dScGame_c::GetInstance()->setRespawnInfo(*linkPos, *linkAngle, param);
+        }
+        dStage_c::GetInstance()->handleRoomChange(roomid);
+        dBase_c::createBase(fProfile::CAMERA, dStage_c::GetInstance(), 0, fBase_c::OTHER);
+        spawnLightObject();
+        spawnWeatherTag();
+    }
+}
+
+extern "C" u16 getActorIdForObjName2(const char *objname);
+
+static void handleBzsObjn(int roomid, const BzsSectionHead *section) {
+    const OBJN *objn = OFS_TO_PTR(OBJN, section);
+    const char *buf = reinterpret_cast<const char *>(objn);
+    for (s32 i = 0; i < section->mCount; i++) {
+        dStageMgr_c::GetInstance()->addObjId(getActorIdForObjName2(buf + objn->offset));
+        objn++;
+    }
+}
+
+static void handleBzsArcn(int roomid, const BzsSectionHead *section) {
+    const ARCN *arcn = OFS_TO_PTR(ARCN, section);
+    const char *buf = reinterpret_cast<const char *>(arcn);
+    for (s32 i = 0; i < section->mCount; i++) {
+        dStageMgr_c::GetInstance()->addStageArcn(buf + arcn->offset);
+        arcn++;
+    }
+}
+
+static void handleBzsLayerObjn(int roomid, const BzsSectionHead *section) {
+    const OBJN *objn = OFS_TO_PTR(OBJN, section);
+    const char *buf = reinterpret_cast<const char *>(objn);
+    for (s32 i = 0; i < section->mCount; i++) {
+        u16 id = getActorIdForObjName2(buf + objn->offset);
+        dStageMgr_c::GetInstance()->addActorId(id);
+        objn++;
+    }
+}
+
+static void handleBzsLayerArcn(int roomid, const BzsSectionHead *section) {
+    const ARCN *arcn = OFS_TO_PTR(ARCN, section);
+    const char *buf = reinterpret_cast<const char *>(arcn);
+    for (s32 i = 0; i < section->mCount; i++) {
+        dStageMgr_c::GetInstance()->addLayerArcn(buf + arcn->offset);
+        arcn++;
+    }
+}
+
+static u16 getEnemyDefeatFlagFromId(s32 roomid, u16 id) {
+    u16 val = id & 0x3FF;
+    if (val >= 0x400) {
+        // Interesting condition
+        return -1;
+    }
+    if (roomid == -1) {
+        return val + (0x3F << 10);
+    }
+    return val + (roomid << 10);
+}
+
+static s8 getViewClipIndexFromId(u16 id) {
+    s8 val = (id >> 10) & 0x3F;
+    if (val == 0x3F) {
+        return -1;
+    }
+    return val;
+}
+
+static void handleBzsObj(int roomid, const BzsSectionHead *section) {
+    dStage_c *stage = dStage_c::GetInstance();
+    const OBJ *obj = OFS_TO_PTR(OBJ, section);
+    for (s32 i = 0; i < section->mCount; i++) {
+        u16 flag = getEnemyDefeatFlagFromId(roomid, obj->id);
+        s8 viewClipIdx = getViewClipIndexFromId(obj->id);
+        if (stage->checkEnemyDefeatFlag(flag)) {
+            dAcObjBase_c::create(
+                obj->name, roomid, obj->params1, &obj->position, &obj->angle, nullptr, obj->params2, flag, viewClipIdx
+            );
+        }
+        obj++;
+    }
+}
+
+static void handleBzsSobj(int roomid, const BzsSectionHead *section) {
+    dStage_c *stage = dStage_c::GetInstance();
+    const SOBJ *obj = OFS_TO_PTR(SOBJ, section);
+    for (s32 i = 0; i < section->mCount; i++) {
+        u16 flag = getEnemyDefeatFlagFromId(roomid, obj->id);
+        s8 viewClipIdx = getViewClipIndexFromId(obj->id);
+        if (stage->checkEnemyDefeatFlag(flag)) {
+            dAcObjBase_c::create(
+                obj->name, roomid, obj->params1, &obj->position, &obj->angle, (mVec3_c *)&obj->scale, obj->params2,
+                flag, viewClipIdx
+            );
+        }
+        obj++;
+    }
+}
+
+static void handleBzsStas(int roomid, const BzsSectionHead *section) {
+    dStage_c *stage = dStage_c::GetInstance();
+    const SOBJ *obj = OFS_TO_PTR(SOBJ, section);
+    for (s32 i = 0; i < section->mCount; i++) {
+        u16 flag = getEnemyDefeatFlagFromId(roomid, obj->id);
+        s8 viewClipIdx = getViewClipIndexFromId(obj->id);
+        if (stage->checkEnemyDefeatFlag(flag)) {
+            dAcObjBase_c::createActorUnkGroup3(
+                obj->name, roomid, obj->params1, &obj->position, &obj->angle, &obj->scale, obj->params2, flag,
+                viewClipIdx
+            );
+        }
+        obj++;
+    }
+}
+
+static void parseLayerBzs(int roomid, u32 layer, const LAY *head, const BzsTagToParseFunc *handlerTable, s32 tableSize) {
+    const LAY *lay = head + layer;
+    const BzsSectionHead *newHead = OFS_TO_PTR(BzsSectionHead, lay);
+    for (s32 i = 0; i < lay->mCount; i++) {
+        findAndRunStageTagParseFunc(roomid, newHead++, handlerTable, tableSize);
+    }
+}
+
+static const BzsTagToParseFunc layerHandlers[] = {
+    {'OBJN', handleBzsLayerObjn},
+    {'ARCN', handleBzsLayerArcn},
+};
+
+static void handleBzsLay(int roomid, const BzsSectionHead *section) {
+    const LAY *lay = OFS_TO_PTR(LAY, section);
+    parseLayerBzs(roomid, 0, lay, layerHandlers, ARRAY_LENGTH(layerHandlers));
+    if (dScGame_c::currentSpawnInfo.layer != 0) {
+        parseLayerBzs(roomid, dScGame_c::currentSpawnInfo.layer, lay, layerHandlers, ARRAY_LENGTH(layerHandlers));
+    }
+}
+
+static const BzsTagToParseFunc layerHandlers2[] = {
+    {'OBJ ',  handleBzsObj},
+    {'SOBJ', handleBzsSobj},
+    {'STAG', handleBzsStas},
+};
+
+static void handleBzsLay2(int roomid, const BzsSectionHead *section) {
+    const LAY *lay = OFS_TO_PTR(LAY, section);
+    parseLayerBzs(roomid, 0, lay, layerHandlers2, ARRAY_LENGTH(layerHandlers2));
+    if (dScGame_c::currentSpawnInfo.layer != 0) {
+        parseLayerBzs(roomid, dScGame_c::currentSpawnInfo.layer, lay, layerHandlers2, ARRAY_LENGTH(layerHandlers2));
+    }
+}
+
+static const BzsTagToParseFunc layerHandlers3[] = {
+    {'OBJS',  handleBzsObj},
+    {'SOBS', handleBzsSobj},
+    {'STAS', handleBzsStas},
+    {'SNDT', handleBzsStas},
+    {'TBOX',  handleBzsObj},
+    {'DOOR',  handleBzsObj},
+};
+
+static void handleBzsLay3(int roomid, const BzsSectionHead *section) {
+    const LAY *lay = OFS_TO_PTR(LAY, section);
+    parseLayerBzs(roomid, 0, lay, layerHandlers3, ARRAY_LENGTH(layerHandlers3));
+    if (dScGame_c::currentSpawnInfo.layer != 0) {
+        parseLayerBzs(roomid, dScGame_c::currentSpawnInfo.layer, lay, layerHandlers3, ARRAY_LENGTH(layerHandlers3));
+    }
+}
+
+static const BzsTagToParseFunc defaultHandlers[] = {
+    {'PCAM', handleBzsPcam},
+    {'LYSE', handleBzsLyse},
+    {'STIF', handleBzsStif},
+    {'RMPL', handleBzsRmpl},
+    {'SCEN', handleBzsScen},
+    {'CAM ',  handleBzsCam},
+    {'EVNT', handleBzsEvnt},
+    {'PATH', handleBzsPath},
+    {'PNT ',  handleBzsPnt},
+    {'BPNT', handleBzsBpnt},
+    {'SPTH', handleBzsSpth},
+    {'SPNT', handleBzsSpnt},
+    {'SBPT', handleBzsSbpt},
+    {'AREA', handleBzsArea},
+};
+
+static void findAndRunStageTagParseFunc(
+    int roomid, const BzsSectionHead *head, const BzsTagToParseFunc *handlerTable, s32 tableSize
+) {
+    if (handlerTable == nullptr) {
+        tableSize = ARRAY_LENGTH(defaultHandlers);
+        handlerTable = defaultHandlers;
+    }
+    while (tableSize > 0) {
+        if (head->mTag == handlerTable->mTag) {
+            handlerTable->mParseFunc(roomid, head);
+            return;
+        }
+        handlerTable++;
+        tableSize--;
+    }
+}
+
+static const BzsTagToParseFunc roomStageHandlers[] = {
+    {'OBJN', handleBzsObjn},
+    {'ARCN', handleBzsArcn},
+};
+
+void parseRoomStageBzs(int roomid, const void *bzs) {
+    const BzsHeader *header = static_cast<const BzsHeader *>(bzs);
+    const BzsSectionHead *head = OFS_TO_PTR(BzsSectionHead, header);
+    for (s32 i = 0; i < header->mSectionCount; i++) {
+        findAndRunStageTagParseFunc(roomid, head++, roomStageHandlers, ARRAY_LENGTH(roomStageHandlers));
+    }
+}
+
+static const BzsTagToParseFunc stageRoomHandlers[] = {
+    {'LYLT', handleBzsLylt},
+    {'LAY ',  handleBzsLay},
+};
+
+void parseBzsStageRoom(int roomid, const void *bzs) {
+    const BzsHeader *header = static_cast<const BzsHeader *>(bzs);
+    const BzsSectionHead *head = OFS_TO_PTR(BzsSectionHead, header);
+    for (s32 i = 0; i < header->mSectionCount; i++) {
+        findAndRunStageTagParseFunc(roomid, head++, stageRoomHandlers, ARRAY_LENGTH(stageRoomHandlers));
+    }
+}
+
+void parseStageBzs(int roomid, const void *bzs) {
+    const BzsHeader *header = static_cast<const BzsHeader *>(bzs);
+    const BzsSectionHead *head = OFS_TO_PTR(BzsSectionHead, header);
+    for (s32 i = 0; i < header->mSectionCount; i++) {
+        // Run "default handlers"
+        findAndRunStageTagParseFunc(roomid, head++, nullptr, 0);
+    }
+}
+
+static const BzsTagToParseFunc roomHandlers[] = {
+    {'FILE', handleBzsFile},
+    {'SCEN', handleBzsScen},
+    {'CAM ',  handleBzsCam},
+    {'EVNT', handleBzsEvnt},
+    {'PATH', handleBzsPath},
+    {'PNT ',  handleBzsPnt},
+    {'BPNT', handleBzsBpnt},
+    {'SPTH', handleBzsSpth},
+    {'SPNT', handleBzsSpnt},
+    {'SBPT', handleBzsSbpt},
+    {'AREA', handleBzsArea},
+    {'PLY ',  handleBzsPly},
+};
+
+void parseRoomBzs(int roomid, const void *bzs) {
+    const BzsHeader *header = static_cast<const BzsHeader *>(bzs);
+    const BzsSectionHead *head = OFS_TO_PTR(BzsSectionHead, header);
+    for (s32 i = 0; i < header->mSectionCount; i++) {
+        findAndRunStageTagParseFunc(roomid, head++, roomHandlers, ARRAY_LENGTH(roomHandlers));
+    }
+}
+
+static const BzsTagToParseFunc roomReactivateHandlers[] = {
+    {'SOBJ', handleBzsSobj},
+    {'STAG', handleBzsStas},
+    {'LAY ', handleBzsLay2},
+};
+
+void parseRoomReactivateBzs(int roomid, const void *bzs) {
+    const BzsHeader *header = static_cast<const BzsHeader *>(bzs);
+    const BzsSectionHead *head = OFS_TO_PTR(BzsSectionHead, header);
+    for (s32 i = 0; i < header->mSectionCount; i++) {
+        findAndRunStageTagParseFunc(roomid, head++, roomReactivateHandlers, ARRAY_LENGTH(roomReactivateHandlers));
+    }
+}
+
+static const BzsTagToParseFunc roomActivateHandlers[] = {
+    {'LAY ', handleBzsLay3},
+};
+
+void parseRoomActivateBzs(int roomid, const void *bzs) {
+    const BzsHeader *header = static_cast<const BzsHeader *>(bzs);
+    const BzsSectionHead *head = OFS_TO_PTR(BzsSectionHead, header);
+    for (s32 i = 0; i < header->mSectionCount; i++) {
+        findAndRunStageTagParseFunc(roomid, head++, roomActivateHandlers, ARRAY_LENGTH(roomActivateHandlers));
+    }
+}
diff --git a/src/d/flag/sceneflag_manager.inc b/src/d/flag/sceneflag_manager.inc
index 5101567e..2fb9d2b7 100644
--- a/src/d/flag/sceneflag_manager.inc
+++ b/src/d/flag/sceneflag_manager.inc
@@ -146,7 +146,7 @@ bool SceneflagManager::checkSceneflagGlobal(u16 sceneIdx, u16 flag) {
     u16 *pData = FileManager::sInstance->getSceneFlagsConst();
     return mFlagHelper.checkFlag(getSceneflagSlotGlobal(sceneIdx, flag), flag % 16, pData, 0x800);
 }
-bool SceneflagManager::checkTempOrSceneflag(u16 flag) {
+u16 SceneflagManager::checkTempOrSceneflag(u16 flag) {
     if (flag >= 0x80) {
         u16 tempflag = flag - 0x80;
         const u16 *pData = FileManager::sInstance->getTempFlagsConst();
diff --git a/src/d/lyt/meter/d_lyt_meter.cpp b/src/d/lyt/meter/d_lyt_meter.cpp
index 302892bd..2f6bcfbc 100644
--- a/src/d/lyt/meter/d_lyt_meter.cpp
+++ b/src/d/lyt/meter/d_lyt_meter.cpp
@@ -2,11 +2,11 @@
 #include "common.h"
 #include "d/d_sc_game.h"
 #include "d/d_sc_title.h"
+#include "d/d_stage_mgr.h"
 #include "d/lyt/d_lyt_area_caption.h"
 #include "d/lyt/d_lyt_meter_configuration.h"
 #include "d/lyt/d_window.h"
 #include "d/lyt/meter/d_lyt_meter.h"
-#include "toBeSorted/stage_manager.h"
 #include "toBeSorted/arc_managers/layout_arc_manager.h"
 // clang-format on
 
diff --git a/src/m/m3d/m_bmdl.cpp b/src/m/m3d/m_bmdl.cpp
index 1eec02e8..39bc384b 100644
--- a/src/m/m3d/m_bmdl.cpp
+++ b/src/m/m3d/m_bmdl.cpp
@@ -219,7 +219,7 @@ int bmdl_c::setMatTexture(char *name, GXTexObj *texObj, bool copy, void *unk, in
     // TODO
 }
 
-bool bmdl_c::getBounds(mVec3_c *min, mVec3_c *max) {
+bool bmdl_c::getBounds(mVec3_c *min, mVec3_c *max) const {
     // TODO
 }
 
diff --git a/src/toBeSorted/arc_managers/current_stage_arc_manager.cpp b/src/toBeSorted/arc_managers/current_stage_arc_manager.cpp
index be757b81..33ed8bac 100644
--- a/src/toBeSorted/arc_managers/current_stage_arc_manager.cpp
+++ b/src/toBeSorted/arc_managers/current_stage_arc_manager.cpp
@@ -95,7 +95,7 @@ void *CurrentStageArcManager::getDataFromRoomArc(int roomId, const char *fileNam
     return mArcTable.getSubEntryData(getRoomArcDirectory(roomId), fileName);
 }
 
-EGG::ExpHeap *getHeap() {
+EGG::ExpHeap *CurrentStageArcManager::getHeap(s32 roomid) {
     return dHeap::workExHeap.heap;
 }
 
diff --git a/src/toBeSorted/file_manager.cpp b/src/toBeSorted/file_manager.cpp
index 8554415a..752d9f89 100644
--- a/src/toBeSorted/file_manager.cpp
+++ b/src/toBeSorted/file_manager.cpp
@@ -235,12 +235,12 @@ u16 *FileManager::getStoryFlagsMut() {
 
 /* 8000CAD0 */ bool FileManager::isNew_FileA() {}
 
-/* 8000CB00 */ void FileManager::setSceneFlagIndex(u16 idx) {}
+/* 8000CB00 */ void FileManager::setSceneFlagIndex(s16 idx) {}
 /* 8000CB30 */ u32 FileManager::getSceneFlagIndex() {}
 /* 8000CB80 */ s32 FileManager::getFileAreaIndex() {}
 
 /* 8000CBD0 */ void FileManager::fn_8000CBD0(u8) {}
-/* 8000CC00 */ void FileManager::fn_8000CC00() {}
+/* 8000CC00 */ u8 FileManager::fn_8000CC00() {}
 
 /* 8000CC50 */ void FileManager::setFileTimes() {}
 /* 8000CCB0 */ void FileManager::setPlayTime(s64 time) {}
diff --git a/src/toBeSorted/room_manager.cpp b/src/toBeSorted/room_manager.cpp
deleted file mode 100644
index fe904bf2..00000000
--- a/src/toBeSorted/room_manager.cpp
+++ /dev/null
@@ -1,3 +0,0 @@
-#include "toBeSorted/room_manager.h"
-
-RoomManager* RoomManager::m_Instance;
\ No newline at end of file