Merge branch 'zeldaret:main' into d_lyt_draw_mark

18 files changed, 2121 insertions, 104 deletions

diff --git a/src/REL/d/a/obj/d_a_obj_door.cpp b/src/REL/d/a/obj/d_a_obj_door.cpp
index 3f172d1f..a0a442b0 100644
--- a/src/REL/d/a/obj/d_a_obj_door.cpp
+++ b/src/REL/d/a/obj/d_a_obj_door.cpp
@@ -1,3 +1,1801 @@
 #include "d/a/obj/d_a_obj_door.h"
 
+#include "c/c_lib.h"
+#include "common.h"
+#include "d/a/d_a_base.h"
+#include "d/a/d_a_item.h"
+#include "d/a/d_a_player.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/a/obj/d_a_obj_fence.h"
+#include "d/a/obj/d_a_obj_lock.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_s_gnd_chk.h"
+#include "d/col/c/c_m3d_g_aab.h"
+#include "d/d_room.h"
+#include "d/d_rumble.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/snd/d_snd_wzsound.h"
+#include "egg/math/eggMath.h"
+#include "f/f_base.h"
+#include "f/f_manager.h"
+#include "f/f_profile_name.h"
+#include "m/m3d/m_anmmdl.h"
+#include "m/m3d/m_fanm.h"
+#include "m/m_mtx.h"
+#include "m/m_vec.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "nw4r/math/math_arithmetic.h"
+#include "s/s_Math.h"
+#include "sized_string.h"
+#include "toBeSorted/attention.h"
+#include "toBeSorted/d_emitter.h"
+#include "toBeSorted/event.h"
+#include "toBeSorted/event_manager.h"
+
 SPECIAL_ACTOR_PROFILE(OBJ_DOOR, dAcOdoor_c, fProfile::OBJ_DOOR, 0x188, 0, 7);
+
+namespace {
+
+const char *const DoorAnim = "DoorAnim";
+const char *const DoorAnim_ = "DoorAnim";
+const char *const DoorAnimPull = "DoorAnimPull";
+const char *const DoorAnimPush = "DoorAnimPush";
+
+struct DoorFileMapping {
+    const dAcOdoor_c::Subtype_e mType;
+    const char *mResName;
+    const char *mMdlName;
+};
+DoorFileMapping sDoorMappings[8] = {
+    {           dAcOdoor_c::DOOR_NORMAL, "DoorA00", "DoorA00"},
+    {            dAcOdoor_c::DOOR_METAL, "DoorA01", "DoorA01"},
+    {         dAcOdoor_c::DOOR_BATREAUX, "DoorA02", "DoorA02"},
+    {      dAcOdoor_c::DOOR_TEMPLE_SIDE, "DoorB00", "DoorB00"},
+    {           dAcOdoor_c::DOOR_DOUBLE, "DoorC00", "DoorC00"},
+    {   dAcOdoor_c::DOOR_DOUBLE_OUTSIDE, "DoorC01", "DoorC01"},
+    {dAcOdoor_c::DOOR_SANDSEA_TIMESHIFT,   "DoorE", "DoorE_T"},
+    {    dAcOdoor_c::DOOR_SPARRING_HALL,   "DoorH",   "DoorH"},
+};
+
+const char *const DoorF = "DoorF";
+const char *const DoorF_ = "DoorF";
+const char *const DoorF_Open = "DoorF_Open";
+const char *const DoorF_Close = "DoorF_Close";
+
+static const u8 sDoorCallbackTypeMap[2] = {
+    0, // Doesnt have callbacks
+    1  // Has Callbacks
+};
+
+const dAcOdoor_c::Subtype_e sDoubleDoorTypes[5] = {
+    sDoorMappings[3].mType, // dAcOdoor_c::DOOR_TEMPLE_SIDE
+    sDoorMappings[4].mType, // dAcOdoor_c::DOOR_DOUBLE
+    sDoorMappings[5].mType, // dAcOdoor_c::DOOR_DOUBLE_OUTSIDE
+    sDoorMappings[6].mType, // dAcOdoor_c::DOOR_SANDSEA_TIMESHIFT
+    sDoorMappings[7].mType, // dAcOdoor_c::DOOR_SPARRING_HALL
+};
+
+const char *const DoorPull = "DoorPull";
+const char *const DoorPush = "DoorPush";
+const char *const DoorPullLock = "DoorPullLock";
+const char *const DoorPushLock = "DoorPushLock";
+const char *const DoorTalk = "DoorTalk";
+
+bool getDoorMapping(u32 type, const DoorFileMapping *&filemap) {
+    bool found = false;
+    int i = 0;
+    while (!found && i <= (int)ARRAY_LENGTH(sDoorMappings) - 1) {
+        if (sDoorMappings[i].mType == type) {
+            found = true;
+        } else {
+            i++;
+        }
+    }
+
+    if (found) {
+        filemap = &sDoorMappings[i];
+    }
+
+    return found;
+}
+
+bool getDoorResName(u32 type, const char *&name) {
+    const DoorFileMapping *filemap = nullptr;
+    bool found = getDoorMapping(type, filemap);
+    if (found) {
+        name = filemap->mResName;
+    }
+    return found;
+}
+
+bool getDoorMdlName(u32 type, const char *&name) {
+    const DoorFileMapping *filemap = nullptr;
+    bool found = getDoorMapping(type, filemap);
+    if (found) {
+        name = filemap->mMdlName;
+    }
+    return found;
+}
+
+bool getDoorCallbackTypeMapped(u8 search, u8 &idx) {
+    bool found = false;
+    int i = 0;
+    while (!found && i <= (int)ARRAY_LENGTH(sDoorCallbackTypeMap) - 1) {
+        if (sDoorCallbackTypeMap[i] == search) {
+            found = true;
+        } else {
+            i++;
+        }
+    }
+
+    if (found) {
+        idx = i;
+    }
+
+    return found;
+}
+
+bool isDoubleDoorType(s32 type) {
+    bool found = false;
+    int i = 0;
+    while (!found && i <= (int)ARRAY_LENGTH(sDoubleDoorTypes) - 1) {
+        if (sDoubleDoorTypes[i] == type) {
+            found = true;
+        } else {
+            i++;
+        }
+    }
+
+    return found;
+}
+const char *getDoorInteractionName() {
+    return DoorTalk;
+}
+
+const char *const sSandShipBossStages[2] = {"B301", "D301_1"};
+bool isInSandshipBoss() {
+    bool found = true;
+    int i = 0;
+    while (found && i <= (int)ARRAY_LENGTH(sSandShipBossStages) - 1) {
+        if (dScGame_c::isCurrentStage(sSandShipBossStages[i])) {
+            found = false;
+        } else {
+            i++;
+        }
+    }
+
+    return !found;
+}
+
+bool isInEvent(const char *eventName) {
+    return strequals(EventManager::getCurrentEventName(), eventName);
+}
+
+const char *const sTimeDoorEventNames[2] = {
+    "TimeDoorIn",
+    "TimeDoorOut",
+};
+
+bool isInTimeDoorEvent() {
+    int i = 0;
+    bool found = true;
+    while (found && i <= (int)ARRAY_LENGTH(sTimeDoorEventNames) - 1) {
+        if (isInEvent(sTimeDoorEventNames[i])) {
+            found = false;
+        } else {
+            i++;
+        }
+    }
+    return !found;
+}
+
+bool checkRoom(s8 roomID, bool &b) {
+    dRoom_c *pRoom = dStage_c::GetInstance()->getRoom(roomID);
+    if (pRoom == nullptr) {
+        return false;
+    }
+
+    b = pRoom->checkFlag(0x1E) != 0;
+    return true;
+}
+
+} // namespace
+
+void rodata0() {
+    const f32 a[] = {0.f, 16.f, 60.f, 0.f, 80.f, 100.f, 0.f, 160.f, 100.f};
+    const u32 b[] = {0x2D2D7832, 0x73010000, 0x03000000};
+}
+static mVec3_c sDoorknobOffset0(70.f, 0.f, 0.f);
+static mVec3_c sDoorknobOffset1(52.f, 110.f, 0.f);
+
+static mVec3_c sVec2(0.f, 0.f, 70.f);
+static mVec3_c sVec3(0.f, 0.f, -70.f);
+
+static const InteractionTargetDef sOpenInteraction = {
+    0, 2, 1, OPEN, 0, 1000.f, 60.f, 0.f, -100.f, 100.f, 50.f, 1.f,
+};
+static const InteractionTargetDef sLockedInteraction = {
+    0, 2, 1, EXAMINE_TALK, 0, 1000.f, 60.f, 0.f, -100.f, 100.f, 50.f, 1.f,
+};
+void rodata1() {
+    const f32 a[] = {200.f, 0.f};
+}
+
+SizedString<32> sStageF402("F402");
+
+bool dAcOdoor_c::createHeap() {
+    s32 type = getFromParams(0, 0x3F);
+    if (type == DOOR_TEMPLE_MAIN) {
+        nw4r::g3d::ResFile resFile(getOarcResFile(DoorF));
+        if (!resFile.IsValid()) {
+            return false;
+        }
+        mAnmChr.create(resFile.ptr(), DoorF_, DoorF_Open, &mAllocator, 0x120);
+    } else {
+        nw4r::g3d::ResFile resFileAnim(getOarcResFile(DoorAnim));
+        if (!resFileAnim.IsValid()) {
+            return false;
+        }
+        if (!mAnmChr.create(resFileAnim.ptr(), DoorAnim_, DoorAnimPull, &mAllocator, 0)) {
+            return false;
+        }
+
+        const char *resFileName = nullptr;
+        getDoorResName(type, resFileName);
+        if (resFileName == nullptr) {
+            return false;
+        }
+
+        nw4r::g3d::ResFile resFileMdl(getOarcResFile(resFileName));
+        if (!resFileMdl.IsValid()) {
+            return false;
+        }
+
+        const char *resMdlName = nullptr;
+        getDoorMdlName(type, resMdlName);
+        if (resMdlName == nullptr) {
+            return false;
+        }
+
+        nw4r::g3d::ResMdl resMdl = resFileMdl.GetResMdl(resMdlName);
+        if (!resMdl.IsValid()) {
+            return false;
+        }
+
+        if (!mMdl0.create(resMdl, &mAllocator, 0x120, 1, nullptr)) {
+            return false;
+        }
+
+        if (isTimeEffected()) {
+            nw4r::g3d::ResMdl resMdl = resFileMdl.GetResMdl("DoorE_N");
+            if (!resMdl.IsValid()) {
+                return false;
+            }
+
+            if (!mMdl1.create(resMdl, &mAllocator, 0x120, 1, nullptr)) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+int dAcOdoor_c::actorCreate() {
+    // NONMATCHING - Regalloc issues
+    s32 subtype = getType();
+    setSubtype(subtype);
+    changeLoadedEntitiesWithSet();
+
+    if (subtype == DOOR_SANDSEA_TIMESHIFT &&
+        !(dScGame_c::isCurrentStage("B301") || dScGame_c::isCurrentStage("D301_1"))) {
+        setTimeEffected();
+    } else {
+        setTimeStatic();
+    }
+
+    CREATE_ALLOCATOR(dAcOdoor_c);
+
+    mSceneflag = getSceneflag();
+
+    if (getLockParameter() == LOCK_KEY) {
+        if (mSceneflag < 0xFF && !SceneflagManager::sInstance->checkBoolFlag(mRoomID, mSceneflag)) {
+            mLock.link(
+                static_cast<dAcOLock_c *>(
+                    create(this, fProfile::OBJ_SHUTTER_LOCK, 0, nullptr, nullptr, nullptr, 0, 0x3F)
+                )
+            );
+        }
+    } else {
+        u8 type = getLockBehavior();
+        if (type <= LOCK_NIGHT) {
+            mLockBehavior = type;
+        } else {
+            mLockBehavior = LOCK_NEVER;
+        }
+    }
+
+    u8 callbackType;
+    if (!getDoorCallbackTypeMapped(getDoorCallbackType(), callbackType)) {
+        callbackType = 0; // Default to no callback
+    }
+    setEventCallbackType(callbackType);
+
+    setFrontRoom(getFrontRoomParam());
+    setBackRoom(getBackRoomParam());
+
+    mRotation.z = mAng(0);
+    mRotation.x = mAng(0);
+    {
+        s32 roomId = mRoomID;
+        addActorToRoom(-1);
+        setRoomId(roomId);
+    }
+
+    if (isDoubleDoorType(subtype)) {
+        setDoubleDoor();
+    } else {
+        setNotDoubleDoor();
+    }
+
+    if (getType() == DOOR_TEMPLE_MAIN) {
+        mAnmChr.setAnm(DoorF_Open, m3d::PLAY_MODE_4, 0.f);
+        mAnmChr.setFrame(mAnmChr.getAnm().getStartFrame());
+        mAnmChr.getModel().setPriorityDraw(0x1C, 0);
+    } else {
+        mAnmChr.setAnm(DoorAnimPull, m3d::PLAY_MODE_4, 0.f);
+        mAnmChr.setFrame(mAnmChr.getAnm().getStartFrame());
+        if (isTimeEffected()) {
+            mMdl0.setPriorityDraw(0xF, 0);
+            mMdl1.setPriorityDraw(0xB, 0);
+        } else {
+            mMdl0.setPriorityDraw(0x1C, 0);
+        }
+    }
+
+    bool inAcademy = dScGame_c::isCurrentStage("F001r");
+    if (inAcademy) {
+        inAcademy = mVec3_c(1832.5f, 0.f, -1978.0f).squareDistanceToXZ(mPosition) < 100.f;
+    }
+    mbKobunDoor = inAcademy;
+
+    return SUCCEEDED;
+}
+
+extern "C" void fn_80067290(dTimeBits *pBits, s32 roomId, const mVec3_c &pos, f32);
+
+int dAcOdoor_c::actorPostCreate() {
+    if (mbDoubleDoor) {
+        if (!isConnectedToOtherDoor()) {
+            bool foundPair = false;
+            dAcOdoor_c *pDoor =
+                static_cast<dAcOdoor_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_DOOR, nullptr));
+            while (!foundPair && pDoor != nullptr) {
+                if (mID != pDoor->mID && pDoor->mbDoubleDoor && !pDoor->isConnectedToOtherDoor() &&
+                    mPosition.squareDistance(pDoor->mPosition) < 40000.f) {
+                    foundPair = true;
+                    this->getConnectedDoorRef().link(pDoor);
+                    pDoor->getConnectedDoorRef().link(this);
+
+                    // Not really sure the point of this
+                    // How does this prevent Door ordering issues
+                    // This may be why the field goes unused?
+                    if (getLockParameter() == LOCK_KEY) {
+                        this->setSingleDoor();
+                        pDoor->setNotSingleDoor();
+                    } else {
+                        this->setNotSingleDoor();
+                        pDoor->setSingleDoor();
+                    }
+                }
+                pDoor = static_cast<dAcOdoor_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_DOOR, pDoor));
+            }
+
+            if (!foundPair) {
+                setSingleDoor();
+            }
+        }
+    } else {
+        setSingleDoor();
+    }
+
+    mVec3_c pos = mPosition + mVec3_c::Ey * 10.f;
+    bool gndChk = dBgS_ObjGndChk::CheckPos(pos);
+    dBgS_ObjGndChk *objGndCheck = dBgS_ObjGndChk::GetPInstance();
+    if (gndChk) {
+        mLightingInfo.mLightingCode = dBgS_ObjGndChk::GetLightingCode();
+        if (objGndCheck != nullptr) {
+            setPolyAttrs(*objGndCheck);
+        }
+    }
+
+    if (isInSandshipBoss()) {
+        setInSandshipBoss();
+        unsetActorProperty(AC_PROP_0x1);
+
+        if (gndChk) {
+            dBgS *pBgS = dBgS::GetInstance();
+            if (pBgS != nullptr && objGndCheck != nullptr) {
+                const dAcObjBase_c *pObj = pBgS->GetActorPointer(*objGndCheck);
+                if (pObj) {
+                    mObjRef.link(const_cast<dAcObjBase_c *>(pObj));
+                    mVec3_c v(mPosition.x, dBgS_ObjGndChk::GetGroundHeight(), mPosition.z);
+                    v -= pObj->mPosition;
+
+                    v.rotY(-pObj->mRotation.y);
+
+                    mAng rotY = mRotation.y - pObj->mRotation.y;
+                    mMtx.transS(v);
+                    mMtx.YrotM(rotY);
+                }
+            }
+        }
+    }
+
+    if (!mObjRef.isLinked()) {
+        s32 type = getType();
+        updateMatrix();
+        mAnmChr.getModel().setLocalMtx(mWorldMtx);
+        mAnmChr.getModel().calc(false);
+
+        if (type != DOOR_TEMPLE_MAIN) {
+            mMtx_c m;
+            mAnmChr.getModel().getNodeWorldMtx(1, m);
+            m.transM(sDoorknobOffset0);
+            mMdl0.setLocalMtx(m);
+            if (isTimeEffected()) {
+                mMdl1.setLocalMtx(m);
+            }
+        }
+
+        dAcOLock_c *pLock = mLock.get();
+        if (pLock == nullptr) {
+            setDoorKnobPosition();
+        } else {
+            mPositionCopy2.set(pLock->mPosition);
+            mPositionCopy3.set(pLock->mPosition);
+        }
+
+        mVec3_c min, max;
+        min.set(999999.f, 999999.f, 999999.f);
+        max.set(-999999.f, -999999.f, -999999.f);
+
+        if (type == DOOR_TEMPLE_MAIN) {
+            mAnmChr.getModel().getBounds(&min, &max);
+        } else {
+            mVec3_c min_l, max_l;
+            mMtx_c local;
+            mMdl0.getBounds(&min_l, &max_l);
+            mMdl0.getLocalMtx(local);
+
+            mMtx_c world = mWorldMtx;
+            world.inverse();
+
+            mVec3_c minPos = min_l;
+            local.multVec(minPos, minPos);
+            world.multVec(minPos, minPos);
+
+            // clang-format off
+            min.set(
+                nw4r::ut::Min(minPos.x, min.x),
+                nw4r::ut::Min(minPos.y, min.y),
+                nw4r::ut::Min(minPos.z, min.z)
+            );
+            max.set(
+                nw4r::ut::Max(minPos.x, max.x),
+                nw4r::ut::Max(minPos.y, max.y),
+                nw4r::ut::Max(minPos.z, max.z)
+            );
+            // clang-format on
+
+            mVec3_c maxPos = max_l;
+            local.multVec(maxPos, maxPos);
+            world.multVec(maxPos, maxPos);
+            // clang-format off
+            min.set(
+                nw4r::ut::Min(maxPos.x, min.x),
+                nw4r::ut::Min(maxPos.y, min.y),
+                nw4r::ut::Min(maxPos.z, min.z)
+            );
+            max.set(
+                nw4r::ut::Max(maxPos.x, max.x),
+                nw4r::ut::Max(maxPos.y, max.y),
+                nw4r::ut::Max(maxPos.z, max.z)
+            );
+            // clang-format on
+
+            mVec3_c vecs[6] = {
+                mVec3_c(min_l.x, min_l.y, max_l.z), mVec3_c(min_l.x, max_l.y, min_l.z),
+                mVec3_c(min_l.x, max_l.y, max_l.z), mVec3_c(max_l.x, min_l.y, min_l.z),
+                mVec3_c(max_l.x, min_l.y, max_l.z), mVec3_c(max_l.x, max_l.y, min_l.z),
+            };
+
+            for (int i = 0, j = 0; i < (int)ARRAY_LENGTH(vecs); i++, j++) {
+                local.multVec(vecs[i], vecs[j]);
+                world.multVec(vecs[i], vecs[j]);
+                // clang-format off
+                min.set(
+                    nw4r::ut::Min(vecs[j].x, min.x),
+                    nw4r::ut::Min(vecs[j].y, min.y),
+                    nw4r::ut::Min(vecs[j].z, min.z)
+                );
+                max.set(
+                    nw4r::ut::Max(vecs[j].x, max.x),
+                    nw4r::ut::Max(vecs[j].y, max.y),
+                    nw4r::ut::Max(vecs[j].z, max.z)
+                );
+                // clang-format on
+            }
+        }
+        mBoundingBox.Set(min, max);
+    }
+
+    if (isTimeEffected()) {
+        fn_80067290(&mTimeBits, mRoomID, mPosition, 200.f);
+    }
+
+    mCullingDistance = EGG::Math<f32>::maxNumber();
+
+    return SUCCEEDED;
+}
+
+int dAcOdoor_c::doDelete() {
+    changeLoadedEntitiesNoSet();
+    return SUCCEEDED;
+}
+
+int dAcOdoor_c::actorExecuteInEvent() {
+    if (isTimeEffected()) {
+        fn_80067290(&mTimeBits, mRoomID, mPosition, 200.f);
+    }
+
+    if (mEventRelated.isAdvance()) {
+        mFramesInEvent = 0;
+    } else if (mFramesInEvent < 0xFF) {
+        mFramesInEvent++;
+    }
+
+    if (isTimeDoorEventActive()) {
+        setObjectProperty(OBJ_PROP_0x200);
+        return SUCCEEDED;
+    }
+
+    switch (mEventCallbackType) {
+        case 0: {
+            bool b;
+            checkRoom(mRoomID, b);
+            if (b) {
+                setObjectProperty(OBJ_PROP_0x200);
+                return SUCCEEDED;
+            }
+        } break;
+        case 1: {
+            bool b;
+            checkRooms(b);
+            if (b) {
+                setObjectProperty(OBJ_PROP_0x200);
+                return SUCCEEDED;
+            }
+        } break;
+    }
+
+    unsetObjectProperty(OBJ_PROP_0x200);
+    s32 type = getType();
+
+    static mVec3_c v1(0.f, 0.f, 70.f);
+    static mVec3_c v2(0.f, 0.f, -70.f);
+
+    f32 frame0 = -1.f;
+    f32 frame1 = -1.f;
+
+    switch (mEventRelated.getCurrentEventCommand()) {
+        case 'pllB': {
+            f32 frame = dAcPy_c::GetLink()->getCurrentAnimFrame();
+            if (mEventRelated.isAdvance()) {
+                mAnmChr.setAnm(DoorAnimPull, m3d::PLAY_MODE_4);
+                mAnmChr.setFrame(frame);
+                mExitTimer = 45;
+
+                frame0 = frame;
+                if (mEventCallbackType == s8(1)) {
+                    transitionPullRoomFlags();
+                }
+            } else {
+                frame0 = mAnmChr.getAnm().getFrame();
+            }
+            mAnmChr.setFrame(frame);
+            frame1 = mAnmChr.getAnm().getFrame();
+            bool old_time = 0 == mExitTimer;
+            bool new_time = 0 == sLib::calcTimer(&mExitTimer);
+            switch (mEventCallbackType) {
+                case 0: {
+                    if (!old_time && new_time) {
+                        triggerExit();
+                    }
+                } break;
+                case 1: {
+                    if (new_time) {
+                        mEventRelated.advanceNext();
+                    }
+                } break;
+            }
+        } break;
+        case 'pllE': {
+            bool isStop;
+            const dAcPy_c *pPlayer = dAcPy_c::GetLink();
+            f32 frame = pPlayer->getCurrentAnimFrame();
+            if (mEventRelated.isAdvance()) {
+                isStop = false;
+                switch (mEventCallbackType) {
+                    case 0: {
+                        frame0 = frame;
+                    } break;
+                    case 1: {
+                        frame0 = mAnmChr.getAnm().getFrame();
+                    } break;
+                }
+                mAnmChr.setAnm(DoorAnimPull, m3d::PLAY_MODE_4);
+                mAnmChr.setFrame(frame);
+            } else {
+                isStop = mAnmChr.getAnm().isStop();
+                frame0 = mAnmChr.getAnm().getFrame();
+
+                if (!isStop) {
+                    mAnmChr.setFrame(frame);
+                }
+            }
+            bool postStop = mAnmChr.getAnm().isStop();
+            frame1 = mAnmChr.getAnm().getFrame();
+            if (!isStop && postStop) {
+                if (mEventCallbackType == 1 && getField_0x5B4() != getField_0x5B5()) {
+                    dRoom_c *pRoom = dStage_c::GetInstance()->getRoom(getField_0x5B4());
+                    if (pRoom != nullptr) {
+                        pRoom->setFlag(0x4);
+                        dStage_c::GetInstance()->fn_801B3C60(getField_0x5B5());
+                    }
+                }
+                mEventRelated.advanceNext();
+
+                bool search = true;
+                dAcOFence_c *pFence =
+                    static_cast<dAcOFence_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_FENCE, nullptr));
+                while (search && pFence != nullptr) {
+                    if (mAng::abs(pPlayer->mRotation.y - pFence->mRotation.y) < 0x4000) {
+                        const mVec3_c &posFence = pFence->mPosition;
+                        const mVec3_c &position = mPosition;
+                        if (posFence.squareDistanceToXZ(position) < 22500.f &&
+                            nw4r::math::FAbs(posFence.y - position.y) < 500.f) {
+                            search = false;
+                            continue;
+                        }
+                    }
+                    pFence = static_cast<dAcOFence_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_FENCE, pFence));
+                }
+
+                if (!search) {
+                    if (pFence->fn_550_11B0()) {
+                        pFence->changeToRequestConfineEvent();
+                    }
+                    pFence->fn_550_12C0();
+                }
+
+                if (mLock.get() != nullptr) {
+                    mLock.get()->deleteRequest();
+                }
+            }
+        } break;
+        case 'pshB': {
+            f32 frame = dAcPy_c::GetLink()->getCurrentAnimFrame();
+            if (mEventRelated.isAdvance()) {
+                if (type == DOOR_TEMPLE_MAIN) {
+                    mAnmChr.setAnm(DoorF_Open, m3d::PLAY_MODE_4);
+                    mExitTimer = 120;
+                } else {
+                    mAnmChr.setAnm(DoorAnimPush, m3d::PLAY_MODE_4);
+                    mExitTimer = 45;
+                }
+                if (mEventCallbackType == s8(1)) {
+                    transitionPushRoomFlags();
+                }
+                frame0 = frame;
+            } else {
+                frame0 = mAnmChr.getAnm().getFrame();
+            }
+            mAnmChr.setFrame(frame);
+            frame1 = mAnmChr.getAnm().getFrame();
+            bool old_time = 0 == mExitTimer;
+            bool new_time = 0 == sLib::calcTimer(&mExitTimer);
+            switch (mEventCallbackType) {
+                case 0: {
+                    if (!old_time && new_time) {
+                        triggerExit();
+                    }
+                } break;
+                case 1: {
+                    if (new_time) {
+                        mEventRelated.advanceNext();
+                    }
+                } break;
+            }
+        } break;
+        case 'pshE': {
+            bool isStop;
+            f32 frame = dAcPy_c::GetLink()->getCurrentAnimFrame();
+            if (mEventRelated.isAdvance()) {
+                isStop = false;
+                switch (mEventCallbackType) {
+                    case 0: {
+                        frame0 = frame;
+                    } break;
+                    case 1: {
+                        frame0 = mAnmChr.getAnm().getFrame();
+                    } break;
+                }
+                if (type == DOOR_TEMPLE_MAIN) {
+                    mAnmChr.setAnm(DoorF_Close, m3d::PLAY_MODE_4);
+                } else {
+                    mAnmChr.setAnm(DoorAnimPush, m3d::PLAY_MODE_4);
+                }
+                mAnmChr.setFrame(frame);
+            } else {
+                isStop = mAnmChr.getAnm().isStop();
+                frame0 = mAnmChr.getAnm().getFrame();
+                if (!isStop) {
+                    mAnmChr.setFrame(frame);
+                }
+            }
+            bool stop = mAnmChr.getAnm().isStop();
+            frame1 = mAnmChr.getAnm().getFrame();
+            if (!isStop && stop) {
+                if (mEventCallbackType == 1 && getField_0x5B4() != getField_0x5B5()) {
+                    dRoom_c *pRoom = dStage_c::GetInstance()->getRoom(getField_0x5B5());
+                    if (pRoom != nullptr) {
+                        pRoom->setFlag(0x4);
+                        dStage_c::GetInstance()->fn_801B3C60(getField_0x5B4());
+                    }
+                }
+                mEventRelated.advanceNext();
+
+                bool search = true;
+                const dAcPy_c *pPlayer = dAcPy_c::GetLink();
+                dAcOFence_c *pFence =
+                    static_cast<dAcOFence_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_FENCE, nullptr));
+                while (search && pFence != nullptr) {
+                    if (mAng::abs(pPlayer->mRotation.y - pFence->mRotation.y) < 0x4000) {
+                        const mVec3_c &posFence = pFence->mPosition;
+                        const mVec3_c &position = mPosition;
+                        if (posFence.squareDistanceToXZ(position) < 22500.f &&
+                            nw4r::math::FAbs(posFence.y - position.y) < 500.f) {
+                            search = false;
+                            continue;
+                        }
+                    }
+                    pFence = static_cast<dAcOFence_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_FENCE, pFence));
+                }
+
+                if (!search) {
+                    if (pFence->fn_550_11B0()) {
+                        pFence->changeToRequestConfineEvent();
+                    }
+                    pFence->fn_550_12C0();
+                }
+
+                if (mLock.get() != nullptr) {
+                    mLock.get()->deleteRequest();
+                }
+            }
+            if (type == DOOR_TEMPLE_MAIN) {
+                bool b;
+                if (frame0 == frame1) {
+                    b = frame0 == 55.f;
+                } else {
+                    b = frame0 < 55.f && 55.f <= frame1;
+                }
+                if (b) {
+                    dRumble_c::start(dRumble_c::sRumblePreset5, dRumble_c::FLAG_SLOT0);
+                }
+            }
+        } break;
+        case 'wait': {
+            mEventRelated.advanceNext();
+        } break;
+        case 'tktn': {
+            mEventRelated.advanceNext();
+        } break;
+        case 'tkwt': {
+            mEventRelated.advanceNext();
+        } break;
+        case 'tked': {
+            mEventRelated.advanceNext();
+        } break;
+        case 'cAna': {
+            mVec3_c pos;
+            mAng rot;
+            if (type == DOOR_TEMPLE_MAIN) {
+                pos.set(0.f, 0.f, 85.f);
+                rot = mAng(0x8000);
+                rot += mRotation.y;
+            } else {
+                int dir;
+                mEventRelated.getSingleShortData(&dir, 'dir ', 0);
+                if (dir == 0) {
+                    pos.set(v1);
+                    rot = mAng(0x8000);
+                    rot += mRotation.y;
+                } else {
+                    pos.set(v2);
+                    rot = mRotation.y;
+                }
+            }
+            stepTowards(pos);
+            dAcPy_c *pPlayer = dAcPy_c::GetLinkM();
+
+            if (mFramesInEvent > 30) {
+                pPlayer->setPosYRot(pos, rot);
+                mEventRelated.advanceNext();
+            } else {
+                mVec3_c tmp = pPlayer->mPosition;
+                cLib::addCalcPos(&tmp, pos, 0.25f, 200.f, 0.f);
+
+                mAng ang = pPlayer->mRotation.y;
+                sLib::addCalcAngle(ang.ref(), rot, 4, 0x7FFF, 0);
+
+                if (pos.squareDistanceToXZ(tmp) < 25.f && mAng::abs(ang - mAng((s32)rot)) < 182) {
+                    pPlayer->setPosYRot(pos, rot);
+                    mEventRelated.advanceNext();
+                } else {
+                    pPlayer->setPosYRot(tmp, ang);
+                }
+            }
+        } break;
+        case 'cDeg': {
+            mVec3_c pos;
+            mAng rot;
+            if (mEventRelated.isAdvance()) {
+                if (type == DOOR_TEMPLE_MAIN) {
+                    pos.set(0.f, 0.f, 90.f);
+                    rot = mRotation.y;
+                } else {
+                    int dir;
+                    mEventRelated.getSingleShortData(&dir, 'dir ', 0);
+                    if (dir == 0) {
+                        pos.set(v1);
+                        rot = mRotation.y - 0x8000;
+                    } else {
+                        pos.set(v2);
+                        rot = mRotation.y;
+                    }
+                }
+                stepTowards(pos);
+                dAcPy_c *pPlayer = dAcPy_c::GetLinkM();
+                pPlayer->setPosYRot(pos, rot);
+                mEventRelated.advanceNext();
+            }
+        } break;
+        case 'talk':
+        case 'lock': {
+            if (mEventRelated.isAdvance()) {
+                // Gets the message to show when the door is locked and is failed to be opened
+                s32 flow = mLock.get() == nullptr ? mParams >> 16 : 4001;
+                s32 part2 = flow < 10000U ? 1000 : 100;
+                s32 truncate = (flow / part2);
+
+                u16 lower = flow - truncate * part2;
+
+                s32 part1 = flow < 10000U ? 1000 : 100;
+                u16 upper = flow / part1;
+                mFlowMgr.triggerEntryPoint(upper, lower, 0, 0);
+            }
+            if (mFlowMgr.checkFinished()) {
+                mEventRelated.advanceNext();
+            }
+        } break;
+        case 'unlk': {
+            dAcOLock_c *pLock = mLock.get();
+            if (pLock == nullptr) {
+                mEventRelated.advanceNext();
+            } else {
+                if (mEventRelated.isAdvance()) {
+                    pLock->setField_0x2090();
+                    setDoorKnobPosition();
+                }
+                if (pLock->checkField_0x2091()) {
+                    mEventRelated.advanceNext();
+                }
+            }
+        } break;
+        default: {
+            mEventRelated.advanceNext();
+        }
+        case '????': {
+        } break;
+    }
+
+    dAcObjBase_c *pObj = mObjRef.get();
+    if (pObj != nullptr) {
+        mMtx_c m = pObj->mWorldMtx;
+        m += mMtx;
+        mWorldMtx = m;
+        mAnmChr.getModel().setLocalMtx(mWorldMtx);
+    }
+
+    mAnmChr.getModel().calc(false);
+
+    if (type != DOOR_TEMPLE_MAIN) {
+        mMtx_c nodeMtx;
+        mAnmChr.getModel().getNodeWorldMtx(1, nodeMtx);
+        nodeMtx.transM(sDoorknobOffset0);
+        mMdl0.setLocalMtx(nodeMtx);
+        if (isTimeEffected()) {
+            mMdl1.setLocalMtx(nodeMtx);
+        }
+    }
+
+    if (pObj != nullptr) {
+        mVec3_c min, max;
+        min.set(999999.f, 999999.f, 999999.f);
+        max.set(-999999.f, -999999.f, -999999.f);
+
+        if (type == DOOR_TEMPLE_MAIN) {
+            mAnmChr.getModel().getBounds(&min, &max);
+        } else {
+            mVec3_c min_l, max_l;
+            mMtx_c local;
+            mMdl0.getBounds(&min_l, &max_l);
+            mMdl0.getLocalMtx(local);
+
+            mMtx_c world = mWorldMtx;
+            world.inverse();
+
+            mVec3_c minPos = min_l;
+            local.multVec(minPos, minPos);
+            world.multVec(minPos, minPos);
+
+            // clang-format off
+            min.set(
+                nw4r::ut::Min(minPos.x, min.x),
+                nw4r::ut::Min(minPos.y, min.y),
+                nw4r::ut::Min(minPos.z, min.z)
+            );
+            max.set(
+                nw4r::ut::Max(minPos.x, max.x),
+                nw4r::ut::Max(minPos.y, max.y),
+                nw4r::ut::Max(minPos.z, max.z)
+            );
+            // clang-format on
+
+            mVec3_c maxPos = max_l;
+            local.multVec(maxPos, maxPos);
+            world.multVec(maxPos, maxPos);
+            // clang-format off
+            min.set(
+                nw4r::ut::Min(maxPos.x, min.x),
+                nw4r::ut::Min(maxPos.y, min.y),
+                nw4r::ut::Min(maxPos.z, min.z)
+            );
+            max.set(
+                nw4r::ut::Max(maxPos.x, max.x),
+                nw4r::ut::Max(maxPos.y, max.y),
+                nw4r::ut::Max(maxPos.z, max.z)
+            );
+            // clang-format on
+
+            mVec3_c vecs[6] = {
+                mVec3_c(min_l.x, min_l.y, max_l.z), mVec3_c(min_l.x, max_l.y, min_l.z),
+                mVec3_c(min_l.x, max_l.y, max_l.z), mVec3_c(max_l.x, min_l.y, min_l.z),
+                mVec3_c(max_l.x, min_l.y, max_l.z), mVec3_c(max_l.x, max_l.y, min_l.z),
+            };
+
+            for (int i = 0, j = 0; i < (int)ARRAY_LENGTH(vecs); j++, i++) {
+                local.multVec(vecs[i], vecs[j]);
+                world.multVec(vecs[i], vecs[j]);
+                // clang-format off
+                min.set(
+                    nw4r::ut::Min(vecs[j].x, min.x),
+                    nw4r::ut::Min(vecs[j].y, min.y),
+                    nw4r::ut::Min(vecs[j].z, min.z)
+                );
+                max.set(
+                    nw4r::ut::Max(vecs[j].x, max.x),
+                    nw4r::ut::Max(vecs[j].y, max.y),
+                    nw4r::ut::Max(vecs[j].z, max.z)
+                );
+                // clang-format on
+            }
+        }
+        mBoundingBox.Set(min, max);
+    }
+
+    if (mEmmiterL.hasEmitters()) {
+        int node = mAnmChr.getModel().getNodeID("DoorF_L");
+        if (node >= 0) {
+            mMtx_c nodeMtx;
+            mAnmChr.getModel().getNodeWorldMtx(node, nodeMtx);
+            mEmmiterL.setTransform(nodeMtx);
+        }
+    }
+    if (mEmmiterR.hasEmitters()) {
+        int node = mAnmChr.getModel().getNodeID("DoorF_R");
+        if (node >= 0) {
+            mMtx_c nodeMtx;
+            mAnmChr.getModel().getNodeWorldMtx(node, nodeMtx);
+            mEmmiterR.setTransform(nodeMtx);
+        }
+    }
+
+    switch (mEventRelated.getCurrentEventCommand()) {
+        case 'pshB': {
+            if (mEventRelated.isAdvance() && type == DOOR_TEMPLE_MAIN) {
+                int node;
+                node = mAnmChr.getModel().getNodeID("DoorF_L");
+                if (node >= 0) {
+                    mMtx_c nodeMtx;
+                    mAnmChr.getModel().getNodeWorldMtx(node, nodeMtx);
+                    mEmmiterL.startEffect(PARTICLE_RESOURCE_ID_MAPPING_935_, nodeMtx, nullptr, nullptr);
+                }
+                node = mAnmChr.getModel().getNodeID("DoorF_R");
+                if (node >= 0) {
+                    mMtx_c nodeMtx;
+                    mAnmChr.getModel().getNodeWorldMtx(node, nodeMtx);
+                    mEmmiterR.startEffect(PARTICLE_RESOURCE_ID_MAPPING_936_, nodeMtx, nullptr, nullptr);
+                }
+            }
+        } break;
+        case 'pshE': {
+            if (mEventRelated.isAdvance() && type == DOOR_TEMPLE_MAIN) {
+                int node;
+                node = mAnmChr.getModel().getNodeID("DoorF_L");
+                if (node >= 0) {
+                    mMtx_c nodeMtx;
+                    mAnmChr.getModel().getNodeWorldMtx(node, nodeMtx);
+                    mEmmiterL.startEffect(PARTICLE_RESOURCE_ID_MAPPING_933_, nodeMtx, nullptr, nullptr);
+                }
+                node = mAnmChr.getModel().getNodeID("DoorF_R");
+                if (node >= 0) {
+                    mMtx_c nodeMtx;
+                    mAnmChr.getModel().getNodeWorldMtx(node, nodeMtx);
+                    mEmmiterR.startEffect(PARTICLE_RESOURCE_ID_MAPPING_934_, nodeMtx, nullptr, nullptr);
+                }
+            }
+        } break;
+    }
+
+    if (type != DOOR_TEMPLE_MAIN) {
+        bool b;
+        if (frame0 == frame1) {
+            b = frame0 == 16.f;
+        } else {
+            b = frame0 < 16.f && 16.f <= frame1;
+        }
+        if (b) {
+            startSound(SE_Door_W_OPEN);
+        }
+    }
+
+    if (type != DOOR_TEMPLE_MAIN) {
+        bool b;
+        if (frame0 == frame1) {
+            b = frame0 == 60.f;
+        } else {
+            b = frame0 < 60.f && 60.f <= frame1;
+        }
+        if (b) {
+            startSound(SE_Door_W_CLOSE);
+        }
+    }
+
+    if (mEventRelated.getCurrentEventCommand() == 'pshB' && type == DOOR_TEMPLE_MAIN) {
+        if (frame0 < 50.f && 50.f <= frame1) {
+            // TODO(Zeldex) - Why is this a check - This seems to indicate it was a getter for a pointer
+            if (&dRumble_c::sRumblePreset3) {
+                mRumbleIdx =
+                    dRumble_c::start(dRumble_c::sRumblePreset3, dRumble_c::FLAG_SLOT0 | dRumble_c::FLAG_INITIALIZE);
+            }
+        }
+        if (frame0 <= 115.f && 115.f < frame1) {
+            dRumble_c::stop(mRumbleIdx);
+        }
+    }
+    return SUCCEEDED;
+}
+
+int dAcOdoor_c::actorExecute() {
+    if (isTimeEffected()) {
+        fn_80067290(&mTimeBits, mRoomID, mPosition, 200.f);
+    }
+    switch (mEventCallbackType) {
+        case 0: {
+            bool b;
+            checkRoom(mRoomID, b);
+            if (b) {
+                setObjectProperty(OBJ_PROP_0x200);
+                return SUCCEEDED;
+            }
+        } break;
+        case 1: {
+            bool b;
+            checkRooms(b);
+            if (b) {
+                setObjectProperty(OBJ_PROP_0x200);
+                return SUCCEEDED;
+            }
+        } break;
+    }
+    unsetObjectProperty(OBJ_PROP_0x200);
+    s32 type = getType();
+
+    if (getLockParameter() == LOCK_KEY) {
+        if (mLock.get() == nullptr) {
+            if (isPlayerInteractable()) {
+                AttentionManager::GetInstance()->addTarget(*this, sOpenInteraction, 0, nullptr);
+            }
+        } else {
+            if (isPlayerInteractableLocked()) {
+                AttentionManager::GetInstance()->addTarget(*this, sOpenInteraction, 0, nullptr);
+            }
+        }
+    } else {
+        switch (mLockBehavior) {
+            case 0: {
+                if (isPlayerInteractable()) {
+                    AttentionManager::GetInstance()->addTarget(*this, sOpenInteraction, 0, nullptr);
+                }
+            } break;
+            case 1:
+            case 4:
+            case 5:
+            case 6: {
+                if (isPlayerInteractable()) {
+                    if (isLocked()) {
+                        AttentionManager::GetInstance()->addTarget(*this, sLockedInteraction, 0, nullptr);
+                    } else {
+                        AttentionManager::GetInstance()->addTarget(*this, sOpenInteraction, 0, nullptr);
+                    }
+                }
+            } break;
+            case 2: {
+                if (isPlayerInteractable()) {
+                    AttentionManager::GetInstance()->addTarget(*this, sOpenInteraction, 0, nullptr);
+                }
+            } break;
+            case 3: {
+                if (!isLocked() && isPlayerInteractable()) {
+                    AttentionManager::GetInstance()->addTarget(*this, sOpenInteraction, 0, nullptr);
+                }
+            } break;
+        }
+    }
+
+    dAcObjBase_c *pObj = mObjRef.get();
+    if (pObj != nullptr) {
+        mMtx_c m = pObj->mWorldMtx;
+        m += mMtx;
+        mWorldMtx = m;
+        mAnmChr.getModel().setLocalMtx(mWorldMtx);
+        mAnmChr.getModel().calc(false);
+
+        if (type != DOOR_TEMPLE_MAIN) {
+            mMtx_c nodeMtx;
+            mAnmChr.getModel().getNodeWorldMtx(1, nodeMtx);
+            nodeMtx.transM(sDoorknobOffset0);
+            mMdl0.setLocalMtx(nodeMtx);
+            if (isTimeEffected()) {
+                mMdl1.setLocalMtx(nodeMtx);
+            }
+        }
+    }
+
+    if (pObj != nullptr) {
+        mVec3_c min, max;
+        min.set(999999.f, 999999.f, 999999.f);
+        max.set(-999999.f, -999999.f, -999999.f);
+
+        if (type == DOOR_TEMPLE_MAIN) {
+            mAnmChr.getModel().getBounds(&min, &max);
+        } else {
+            mVec3_c min_l, max_l;
+            mMtx_c local;
+            mMdl0.getBounds(&min_l, &max_l);
+            mMdl0.getLocalMtx(local);
+
+            mMtx_c world = mWorldMtx;
+            world.inverse();
+
+            mVec3_c minPos = min_l;
+            local.multVec(minPos, minPos);
+            world.multVec(minPos, minPos);
+
+            // clang-format off
+            min.set(
+                nw4r::ut::Min(minPos.x, min.x),
+                nw4r::ut::Min(minPos.y, min.y),
+                nw4r::ut::Min(minPos.z, min.z)
+            );
+            max.set(
+                nw4r::ut::Max(minPos.x, max.x),
+                nw4r::ut::Max(minPos.y, max.y),
+                nw4r::ut::Max(minPos.z, max.z)
+            );
+            // clang-format on
+
+            mVec3_c maxPos = max_l;
+            local.multVec(maxPos, maxPos);
+            world.multVec(maxPos, maxPos);
+            // clang-format off
+            min.set(
+                nw4r::ut::Min(maxPos.x, min.x),
+                nw4r::ut::Min(maxPos.y, min.y),
+                nw4r::ut::Min(maxPos.z, min.z)
+            );
+            max.set(
+                nw4r::ut::Max(maxPos.x, max.x),
+                nw4r::ut::Max(maxPos.y, max.y),
+                nw4r::ut::Max(maxPos.z, max.z)
+            );
+            // clang-format on
+
+            mVec3_c vecs[6] = {
+                mVec3_c(min_l.x, min_l.y, max_l.z), mVec3_c(min_l.x, max_l.y, min_l.z),
+                mVec3_c(min_l.x, max_l.y, max_l.z), mVec3_c(max_l.x, min_l.y, min_l.z),
+                mVec3_c(max_l.x, min_l.y, max_l.z), mVec3_c(max_l.x, max_l.y, min_l.z),
+            };
+
+            for (int i = 0, j = 0; i < (int)ARRAY_LENGTH(vecs); j++, i++) {
+                local.multVec(vecs[i], vecs[j]);
+                world.multVec(vecs[i], vecs[j]);
+                // clang-format off
+                min.set(
+                    nw4r::ut::Min(vecs[j].x, min.x),
+                    nw4r::ut::Min(vecs[j].y, min.y),
+                    nw4r::ut::Min(vecs[j].z, min.z)
+                );
+                max.set(
+                    nw4r::ut::Max(vecs[j].x, max.x),
+                    nw4r::ut::Max(vecs[j].y, max.y),
+                    nw4r::ut::Max(vecs[j].z, max.z)
+                );
+                // clang-format on
+            }
+        }
+        mBoundingBox.Set(min, max);
+    }
+    return SUCCEEDED;
+}
+
+int dAcOdoor_c::draw() {
+    if (isTimeEffected()) {
+        if (!mTimeBits.field_0x00) {
+            drawModelType1(&mMdl1);
+        }
+        if (!mTimeBits.field_0x01) {
+            drawModelType1(&mMdl0);
+        }
+    } else {
+        if (getType() == DOOR_TEMPLE_MAIN) {
+            drawModelType1(&mAnmChr.getModel());
+        } else {
+            drawModelType1(&mMdl0);
+        }
+    }
+    return SUCCEEDED;
+}
+
+bool dAcOdoor_c::isLocked() {
+    if (getLockParameter() == LOCK_KEY) {
+        return mLock.isLinked();
+    }
+
+    switch (mLockBehavior) {
+        case LOCK_NEVER: {
+            return false;
+        }
+        case LOCK_NOT_SET:
+        case LOCK_TIMESHIFT: {
+            return mSceneflag < 0xFF ? !SceneflagManager::sInstance->checkBoolFlag(mRoomID, mSceneflag) : true;
+        }
+        case LOCK_NEVER1: {
+            return false;
+        }
+        case LOCK_SET: {
+            return mSceneflag < 0xFF ? SceneflagManager::sInstance->checkBoolFlag(mRoomID, mSceneflag) : true;
+        }
+        case LOCK_DAY: {
+            return dScGame_c::currentSpawnInfo.getTimeOfDay() == SpawnInfo::DAY;
+        }
+        case LOCK_NIGHT: {
+            return dScGame_c::currentSpawnInfo.getTimeOfDay() == SpawnInfo::NIGHT;
+        }
+        default: {
+            return true;
+        }
+    }
+}
+
+bool dAcOdoor_c::canOpen() {
+    // NONMATCHING
+    // https://decomp.me/scratch/dHRfo
+    // Duplicate load of  dStageMgr_c::sInstance for nullptr check and function call
+    // Happens in d_a_obj_door_boss as well
+    dStageMgr_c *pStageMgr = dStageMgr_c::GetInstance();
+    if (pStageMgr != nullptr && pStageMgr->isAreaTypeDungeonOrBoss()) {
+        return getLockParameter() == LOCK_KEY && mLock.isLinked();
+    }
+    return isLocked();
+}
+
+f32 dAcOdoor_c::fn_572_33E0() {
+    return -80.f;
+}
+
+// HACK
+inline u32 createBits(const u32 &a, const u32 &b) {
+    return a | b;
+}
+
+void dAcOdoor_c::startPullEventWithoutCallback(void *zevData) {
+    Event event(DoorPull, zevData, 100, createBits(0x100001, 0x2), nullptr, nullptr);
+    mEventRelated.scheduleEvent(event, 0);
+}
+
+void dAcOdoor_c::startPullEventWithCallback(void *zevData) {
+    Event event(DoorPull, zevData, 100, createBits(0x100001, 0x2), (void *)doorPullEventCallback, nullptr);
+    mEventRelated.scheduleEvent(event, 0);
+}
+
+void dAcOdoor_c::startPushEventWithoutCallback(void *zevData) {
+    Event event(DoorPush, zevData, 100, createBits(0x100001, 0x2), nullptr, nullptr);
+    mEventRelated.scheduleEvent(event, 0);
+}
+
+void dAcOdoor_c::startPushEventWithCallback(void *zevData) {
+    Event event(DoorPush, zevData, 100, createBits(0x100001, 0x2), (void *)doorPushEventCallback, nullptr);
+    mEventRelated.scheduleEvent(event, 0);
+}
+
+void dAcOdoor_c::startPullEvent(void *zevData) {
+    switch (mEventCallbackType) {
+        case 0: startPullEventWithoutCallback(zevData); break;
+        case 1: startPullEventWithCallback(zevData); break;
+    }
+}
+
+void dAcOdoor_c::startPushEvent(void *zevData) {
+    switch (mEventCallbackType) {
+        case 0: startPushEventWithoutCallback(zevData); break;
+        case 1: startPushEventWithCallback(zevData); break;
+    }
+}
+
+void dAcOdoor_c::startOpenEvent(void *zevData) {
+    if (checkPullDoor()) {
+        startPullEvent(zevData);
+    } else {
+        // Cawlin and Strich's room has an awkward angle when pushing.
+        if (mbKobunDoor) {
+            Event event("KobunDoorPush", zevData, 100, 0x100001, nullptr, nullptr);
+            mEventRelated.scheduleEvent(event, 0);
+        } else {
+            startPushEvent(zevData);
+        }
+    }
+}
+
+void dAcOdoor_c::doorPullEventCallback(void *pDoor) {
+    openCallbackCommon(pDoor);
+}
+
+void dAcOdoor_c::doorPushEventCallback(void *pDoor) {
+    openCallbackCommon(pDoor);
+}
+
+void dAcOdoor_c::startDoorPullLockedEvent(void *zevData) {
+    Event event(DoorPullLock, zevData, 100, 0x100001, (void *)pullLockedEventCallback, nullptr);
+    mEventRelated.scheduleEvent(event, 0);
+}
+
+void dAcOdoor_c::startDoorPushLockedEvent(void *zevData) {
+    Event event(DoorPushLock, zevData, 100, 0x100001, (void *)pushLockedEventCallback, nullptr);
+    mEventRelated.scheduleEvent(event, 0);
+}
+
+void dAcOdoor_c::startLockedEvent(void *zevData) {
+    if (checkPullDoor()) {
+        startDoorPullLockedEvent(zevData);
+    } else {
+        startDoorPushLockedEvent(zevData);
+    }
+}
+
+void dAcOdoor_c::pullLockedEventCallback(void *vDoor) {
+    dAcOdoor_c *pDoor = static_cast<dAcOdoor_c *>(vDoor);
+    if (pDoor->hasFlowEntryPoint()) {
+        pDoor->playInteractionLocked();
+    }
+    u16 flag = pDoor->getFailedToOpenFlag();
+    if (flag < 0xFF) {
+        SceneflagManager::sInstance->setFlag(pDoor->mRoomID, flag);
+    }
+}
+
+void dAcOdoor_c::pushLockedEventCallback(void *vDoor) {
+    dAcOdoor_c *pDoor = static_cast<dAcOdoor_c *>(vDoor);
+    if (pDoor->hasFlowEntryPoint()) {
+        pDoor->playInteractionLocked();
+    }
+    u16 flag = pDoor->getFailedToOpenFlag();
+    if (flag < 0xFF) {
+        SceneflagManager::sInstance->setFlag(pDoor->mRoomID, flag);
+    }
+}
+
+void dAcOdoor_c::startUnlockEvent() {
+    Event event("ShutterUnlock", 100, 0x100001, (void *)unlockEventCallback, nullptr);
+    mEventRelated.scheduleEvent(event, 0);
+}
+
+extern "C" void increaseSmallKeyCounter(int amt);
+
+void dAcOdoor_c::unlockEventCallback(void *vDoor) {
+    dAcOdoor_c *pDoor = static_cast<dAcOdoor_c *>(vDoor);
+    void *zevData = getOarcZev("DoorAnim");
+    if (pDoor->checkPullDoor()) {
+        switch (pDoor->mEventCallbackType) {
+            case 0: {
+                Event event(DoorPull, zevData, 100, createBits(0x100001, 0x2), nullptr, nullptr);
+                EventManager::setEvent(pDoor, &event, nullptr);
+            } break;
+            case 1: {
+                Event event(DoorPull, zevData, 100, createBits(0x100001, 0x2), (void *)doorPullEventCallback, nullptr);
+                EventManager::setEvent(pDoor, &event, nullptr);
+            } break;
+        }
+
+    } else {
+        switch (pDoor->mEventCallbackType) {
+            case 0: {
+                Event event(DoorPull, zevData, 100, createBits(0x100001, 0x2), nullptr, nullptr);
+                EventManager::setEvent(pDoor, &event, nullptr);
+            } break;
+            case 1: {
+                Event event(DoorPull, zevData, 100, createBits(0x100001, 0x2), (void *)doorPullEventCallback, nullptr);
+                EventManager::setEvent(pDoor, &event, nullptr);
+            } break;
+        }
+    }
+
+    if (pDoor->mSceneflag < 0xFF) {
+        SceneflagManager::sInstance->setFlag(pDoor->mRoomID, pDoor->mSceneflag);
+    }
+
+    increaseSmallKeyCounter(-1);
+}
+
+void dAcOdoor_c::openCallbackCommon(void *vDoor) {
+    if (vDoor == nullptr) {
+        return;
+    }
+    dAcOdoor_c *pDoor = static_cast<dAcOdoor_c *>(vDoor);
+
+    bool search = true;
+    dAcOFence_c *pFence = static_cast<dAcOFence_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_FENCE, nullptr));
+    while (search && pFence != nullptr) {
+        if (mAng::abs(dAcPy_c::GetLink()->mRotation.y - pFence->mRotation.y) < 0x4000) {
+            const mVec3_c &posFence = pFence->mPosition;
+            const mVec3_c &position = pDoor->mPosition;
+            if (posFence.squareDistanceToXZ(position) < 22500.f && nw4r::math::FAbs(posFence.y - position.y) < 500.f) {
+                pFence->setObjectProperty(OBJ_PROP_0x200);
+                pFence->fn_550_1250();
+                pFence->fn_550_12B0();
+                search = false;
+                continue;
+            }
+        }
+        pFence = static_cast<dAcOFence_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_FENCE, pFence));
+    }
+}
+
+void dAcOdoor_c::registerInEvent() {
+    if (isInTimeDoorEvent()) {
+        setTimeDoorEventActive();
+    }
+}
+
+void dAcOdoor_c::unkVirtFunc_0x6C() {
+    setTimeDoorEventInactive();
+}
+
+void dAcOdoor_c::doInteraction(s32 interaction) {
+    if (getType() == DOOR_TEMPLE_MAIN) {
+        void *zevData = getOarcZev("DoorF");
+        Event event("FTypeDoorOut", zevData, 100, createBits(0x100001, 0x2), nullptr, nullptr);
+        mEventRelated.scheduleEvent(event, 0);
+        return;
+    }
+
+    void *zevData = getOarcZev("DoorAnim");
+
+    switch (interaction) {
+        case OPEN: {
+            if (getLockParameter() == LOCK_KEY) {
+                if (!mLock.isLinked()) {
+                    startOpenEvent(zevData);
+                } else {
+                    if (dAcItem_c::getSmallKeyCount() != 0) {
+                        if (isConnectedToOtherDoor()) {
+                            if (isPlayerInteractable()) {
+                                startUnlockEvent();
+                            } else {
+                                dAcOdoor_c *pDoor = getConnectedDoorRef().get();
+                                pDoor->mLock.link(mLock.get());
+                                pDoor->startUnlockEvent();
+                            }
+                        } else {
+                            startOpenEvent(zevData);
+                        }
+                    } else {
+                        Event event(getDoorInteractionName(), 100, 0x100001, nullptr, nullptr);
+                        mEventRelated.scheduleEvent(event, 0);
+                    }
+                }
+            } else {
+                startOpenEvent(zevData);
+                if (mLockBehavior == LOCK_NEVER1 && mSceneflag < 0xFF) {
+                    SceneflagManager::sInstance->setFlag(mRoomID, mSceneflag);
+                }
+            }
+        } break;
+        case EXAMINE_TALK: {
+            startLockedEvent(zevData);
+        } break;
+    }
+}
+
+s32 dAcOdoor_c::getLockParameter() {
+    return getFromParams(6, 0x1);
+}
+
+s32 dAcOdoor_c::getLockBehavior() {
+    return (mRotation.x >> 0) & 0xFF;
+}
+
+u8 dAcOdoor_c::getSceneflag() {
+    return (mRotation.x >> 8) & 0xFF;
+}
+
+u8 dAcOdoor_c::getDoorCallbackType() {
+    return (mRotation.z >> 0) & 0xF;
+}
+
+u8 dAcOdoor_c::getFrontRoomParam() {
+    return (mRotation.z >> 4) & 0x3F;
+}
+
+u8 dAcOdoor_c::getBackRoomParam() {
+    return (mRotation.z >> 10) & 0x3F;
+}
+
+u16 dAcOdoor_c::getFailedToOpenFlag() {
+    return getParams2Lower() & 0xFF;
+}
+
+f32 dAcOdoor_c::getInteractionMinX() {
+    return -80.f;
+}
+
+f32 dAcOdoor_c::getInteractionMaxX() {
+    return 80.f;
+}
+
+f32 dAcOdoor_c::getInteractionMinZ() {
+    return -100.f;
+}
+
+f32 dAcOdoor_c::getInteractionMaxZ() {
+    return 100.f;
+}
+
+f32 dAcOdoor_c::getInteractionLockMinX() {
+    return -160.f;
+}
+
+f32 dAcOdoor_c::getInteractionLockMaxX() {
+    return 160.f;
+}
+
+f32 dAcOdoor_c::getInteractionLockMinZ() {
+    return -100.f;
+}
+
+f32 dAcOdoor_c::getInteractionLockMaxZ() {
+    return 100.f;
+}
+
+void dAcOdoor_c::setRoomId(s8 roomId) {
+    mRoomID = roomId;
+}
+
+void dAcOdoor_c::setFlag(u32 flags) {
+    mFlags = flags;
+}
+
+void dAcOdoor_c::setEventCallbackType(u8 in) {
+    mEventCallbackType = in;
+}
+
+void dAcOdoor_c::setFrontRoom(s8 in) {
+    mFrontRoomId = in;
+}
+
+void dAcOdoor_c::setBackRoom(s8 in) {
+    mBackRoomId = in;
+}
+
+void dAcOdoor_c::setDoubleDoor() {
+    mbDoubleDoor = true;
+}
+
+void dAcOdoor_c::setNotDoubleDoor() {
+    mbDoubleDoor = false;
+}
+
+void dAcOdoor_c::setSingleDoor() {
+    mbSingleDoor = true;
+}
+
+void dAcOdoor_c::setNotSingleDoor() {
+    mbSingleDoor = false;
+}
+
+void dAcOdoor_c::setInSandshipBoss() {
+    mbInSandshipBoss = true;
+}
+
+bool dAcOdoor_c::isTimeDoorEventActive() const {
+    return mFlags & 1;
+}
+
+void dAcOdoor_c::setTimeDoorEventActive() {
+    setFlag(mFlags | 1);
+}
+
+void dAcOdoor_c::setTimeDoorEventInactive() {
+    setFlag(mFlags & ~1);
+}
+
+void dAcOdoor_c::setTimeEffected() {
+    setFlag(mFlags | 2);
+}
+
+void dAcOdoor_c::setTimeStatic() {
+    setFlag(mFlags & ~2);
+}
+
+bool dAcOdoor_c::checkFrontRoom(bool &b) const {
+    return checkRoom(mFrontRoomId, b);
+}
+
+bool dAcOdoor_c::checkBackRoom(bool &b) const {
+    return checkRoom(mBackRoomId, b);
+}
+
+bool dAcOdoor_c::checkRooms(bool &b) const {
+    bool b0, b1;
+    if (!checkFrontRoom(b0)) {
+        return false;
+    }
+    if (!checkBackRoom(b1)) {
+        return false;
+    }
+    b = b0 && b1;
+    return true;
+}
+
+void dAcOdoor_c::triggerExit() {
+    if (isLeavingSealedTempleSideDoorPostSkyKeep()) {
+        dScGame_c::GetInstance()->triggerExit(mRoomID, 11, 2, 2);
+    } else {
+        dScGame_c::GetInstance()->triggerExit(mRoomID, getFromParams(8, 0xFF), 2, 2);
+    }
+}
+
+bool dAcOdoor_c::isLeavingSealedTempleSideDoorPostSkyKeep() const {
+    return s32(mParams & 0x3F) == DOOR_TEMPLE_SIDE && mBackRoomId == 1 &&
+           StoryflagManager::sInstance->getFlag(STORYFLAG_342) && dScGame_c::isCurrentStage(sStageF402);
+}
+
+void dAcOdoor_c::transitionPushRoomFlags() const {
+    if (dStage_c::GetInstance() == nullptr) {
+        return;
+    }
+    dStage_c::GetInstance()->updateRoomFlags(getField_0x5B4(), getField_0x5B5());
+}
+
+void dAcOdoor_c::transitionPullRoomFlags() const {
+    if (dStage_c::GetInstance() == nullptr) {
+        return;
+    }
+    dStage_c::GetInstance()->updateRoomFlags(getField_0x5B5(), getField_0x5B4());
+}
+
+bool dAcOdoor_c::isPositionInFrontOfDoor(const mVec3_c &point) const {
+    s32 diff = mRotation.y - (point - mPosition).atan2sX_Z();
+    return mAng::abs(diff) <= 0x4000;
+}
+
+bool dAcOdoor_c::checkPullDoor() const {
+    return isPositionInFrontOfDoor(dAcPy_c::GetLink()->mPosition);
+}
+
+bool dAcOdoor_c::hasFlowEntryPoint() {
+    return getFromParams(16, 0xFFFF);
+}
+
+bool dAcOdoor_c::isTimeEffected() const {
+    return mFlags & 2;
+}
+
+void dAcOdoor_c::setDoorKnobPosition() {
+    mVec3_c pos;
+    if (getType() == DOOR_TEMPLE_MAIN) {
+        pos.set(mPosition);
+        pos.y += 150.f;
+    } else {
+        mMtx_c m;
+        mAnmChr.getModel().getNodeWorldMtx(1, m);
+        m.transM(sDoorknobOffset0);
+        m.multVec(sDoorknobOffset1, pos);
+    }
+    mPositionCopy2.set(pos);
+    mPositionCopy3.set(pos);
+}
+
+bool dAcOdoor_c::isPlayerInteractable() const {
+    mVec3_c v = dAcPy_c::GetLink()->mPosition;
+    v -= mPosition;
+    v.rotY(-mRotation.y);
+
+    if (v.x < getInteractionMinX()) {
+        return false;
+    }
+    if (getInteractionMaxX() < v.x) {
+        return false;
+    }
+    if (v.z < getInteractionMinZ()) {
+        return false;
+    }
+    if (getInteractionMaxZ() < v.z) {
+        return false;
+    }
+    return true;
+}
+
+bool dAcOdoor_c::isPlayerInteractableLocked() const {
+    mVec3_c v = dAcPy_c::GetLink()->mPosition;
+    v -= mPosition;
+    v.rotY(-mRotation.y);
+    v.x += 80.f;
+
+    if (v.x < getInteractionLockMinX()) {
+        return false;
+    }
+    if (getInteractionLockMaxX() < v.x) {
+        return false;
+    }
+    if (v.z < getInteractionLockMinZ()) {
+        return false;
+    }
+    if (getInteractionLockMaxZ() < v.z) {
+        return false;
+    }
+    return true;
+}
+
+void dAcOdoor_c::playInteractionLocked() {
+    Event event(getDoorInteractionName(), 100, 0x100001, nullptr, nullptr);
+    EventManager::setEvent(this, &event, nullptr);
+}
diff --git a/src/REL/d/a/obj/d_a_obj_door_boss.cpp b/src/REL/d/a/obj/d_a_obj_door_boss.cpp
index 3331f488..f218cc76 100644
--- a/src/REL/d/a/obj/d_a_obj_door_boss.cpp
+++ b/src/REL/d/a/obj/d_a_obj_door_boss.cpp
@@ -18,6 +18,10 @@ STATE_DEFINE(dAcOdoorBoss_c, Close);
 STATE_DEFINE(dAcOdoorBoss_c, Idle);
 STATE_DEFINE(dAcOdoorBoss_c, BeforeTimeShift);
 
+bool dAcOdoorBoss_c::canOpen() {
+    // Not implemented - Used to emit dtor
+    return true;
+}
 void dAcOdoorBoss_c::initializeState_UnlockWait() {}
 void dAcOdoorBoss_c::executeState_UnlockWait() {}
 void dAcOdoorBoss_c::finalizeState_UnlockWait() {}
diff --git a/src/REL/d/a/obj/d_a_obj_shutter.cpp b/src/REL/d/a/obj/d_a_obj_shutter.cpp
index 15280653..ca344cf2 100644
--- a/src/REL/d/a/obj/d_a_obj_shutter.cpp
+++ b/src/REL/d/a/obj/d_a_obj_shutter.cpp
@@ -6,6 +6,11 @@ STATE_DEFINE(dAcOShutter_c, Wait);
 STATE_DEFINE(dAcOShutter_c, Open);
 STATE_DEFINE(dAcOShutter_c, Close);
 
+bool dAcOShutter_c::canOpen() {
+    // Not implemented - Used to emit dtor
+    return true;
+}
+
 void dAcOShutter_c::initializeState_Wait() {}
 void dAcOShutter_c::executeState_Wait() {}
 void dAcOShutter_c::finalizeState_Wait() {}
diff --git a/src/REL/d/a/obj/d_a_obj_shutter_change_scene.cpp b/src/REL/d/a/obj/d_a_obj_shutter_change_scene.cpp
index 998f6580..6dfd1877 100644
--- a/src/REL/d/a/obj/d_a_obj_shutter_change_scene.cpp
+++ b/src/REL/d/a/obj/d_a_obj_shutter_change_scene.cpp
@@ -1,9 +1,16 @@
 #include "d/a/obj/d_a_obj_shutter_change_scene.h"
 
+#include "f/f_base.h"
+
 SPECIAL_ACTOR_PROFILE(
     OBJ_SHUTTER_CHANGE_SCENE, dAcOShutterChangeScene_c, fProfile::OBJ_SHUTTER_CHANGE_SCENE, 0x18A, 0, 6
 );
 
+bool dAcOShutterChangeScene_c::canOpen() {
+    // Not implemented - Used to emit dtor
+    return true;
+}
+
 STATE_DEFINE(dAcOShutterChangeScene_c, WaitOpenShutter);
 STATE_DEFINE(dAcOShutterChangeScene_c, WaitOpenShutterForEvent);
 STATE_DEFINE(dAcOShutterChangeScene_c, OpenShutter);
diff --git a/src/REL/d/a/obj/d_a_obj_tr_shutter_cs.cpp b/src/REL/d/a/obj/d_a_obj_tr_shutter_cs.cpp
index 9cfaeb74..d7a0e3c6 100644
--- a/src/REL/d/a/obj/d_a_obj_tr_shutter_cs.cpp
+++ b/src/REL/d/a/obj/d_a_obj_tr_shutter_cs.cpp
@@ -5,6 +5,10 @@ SPECIAL_ACTOR_PROFILE(OBJ_TR_SHUTTER_CS, dAcOTrlyShtrChgScn_c, fProfile::OBJ_TR_
 STATE_DEFINE(dAcOTrlyShtrChgScn_c, Wait);
 STATE_DEFINE(dAcOTrlyShtrChgScn_c, OpenEvent);
 
+bool dAcOTrlyShtrChgScn_c::canOpen() {
+    // Not implemented - Used to emit dtor
+    return true;
+}
 void dAcOTrlyShtrChgScn_c::initializeState_Wait() {}
 void dAcOTrlyShtrChgScn_c::executeState_Wait() {}
 void dAcOTrlyShtrChgScn_c::finalizeState_Wait() {}
diff --git a/src/REL/d/a/obj/d_a_obj_trolley_shutter.cpp b/src/REL/d/a/obj/d_a_obj_trolley_shutter.cpp
index d561937e..fbc33114 100644
--- a/src/REL/d/a/obj/d_a_obj_trolley_shutter.cpp
+++ b/src/REL/d/a/obj/d_a_obj_trolley_shutter.cpp
@@ -5,6 +5,10 @@ SPECIAL_ACTOR_PROFILE(OBJ_TROLLEY_SHUTTER, dAcOTrolleyShutter_c, fProfile::OBJ_T
 STATE_DEFINE(dAcOTrolleyShutter_c, Wait);
 STATE_DEFINE(dAcOTrolleyShutter_c, OpenEvent);
 
+bool dAcOTrolleyShutter_c::canOpen() {
+    // Not implemented - Used to emit dtor
+    return true;
+}
 void dAcOTrolleyShutter_c::initializeState_Wait() {}
 void dAcOTrolleyShutter_c::executeState_Wait() {}
 void dAcOTrolleyShutter_c::finalizeState_Wait() {}
diff --git a/src/REL/d/t/d_t_barrel.cpp b/src/REL/d/t/d_t_barrel.cpp
index 40a232ef..d6d81a89 100644
--- a/src/REL/d/t/d_t_barrel.cpp
+++ b/src/REL/d/t/d_t_barrel.cpp
@@ -1,13 +1,164 @@
 #include "d/t/d_t_barrel.h"
 
+#include "common.h"
+#include "d/a/d_a_base.h"
+#include "d/a/d_a_player.h"
+#include "d/a/obj/d_a_obj_barrel.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/a/obj/d_a_obj_stage_sink.h"
+#include "d/flag/sceneflag_manager.h"
+#include "d/t/d_t_barrel_pos.h"
+#include "f/f_base.h"
+#include "f/f_manager.h"
+#include "f/f_profile_name.h"
+#include "m/m_angle.h"
+#include "m/m_mtx.h"
+#include "m/m_vec.h"
+#include "s/s_Math.h"
+
 SPECIAL_ACTOR_PROFILE(TAG_BARREL, dTgBarrel_c, fProfile::TAG_BARREL, 0x221, 0, 0);
 
 STATE_DEFINE(dTgBarrel_c, Wait);
 STATE_DEFINE(dTgBarrel_c, Stop);
 
+// Weak function ordering issue of the ctor and dtor of the objects
+// for the following in the member arrays
+//   dAcRef_c<dTgBarrelPos_c>
+//   dAcRef_c<dAcOBarrel_c>
+
+int dTgBarrel_c::actorCreate() {
+    mStopFlag = getFromParams(0, 0xFF);
+    mLinkId = getFromParams(16, 0xF);
+    mSpawnInterval = getFromParams(8, 0xFF);
+    mSpawnTimer = 1;
+
+    mStageRef.link(dAcOstageSink_c::GetInstance());
+    mSpawnPosition = mPosition;
+
+    for (int i = 0; i < (int)ARRAY_LENGTH(mBarrelArr); ++i) {
+        mBarrelArr[i].unlink();
+    }
+
+    mStateMgr.changeState(StateID_Wait);
+
+    return SUCCEEDED;
+}
+
+int dTgBarrel_c::actorPostCreate() {
+    dTgBarrelPos_c *pTgBarrelPos = nullptr;
+    do {
+        pTgBarrelPos =
+            static_cast<dTgBarrelPos_c *>(fManager_c::searchBaseByProfName(fProfile::TAG_BARREL_POS, pTgBarrelPos));
+
+        if (pTgBarrelPos != nullptr) {
+            u8 index = pTgBarrelPos->getLinkIndex();
+            if (mLinkId == pTgBarrelPos->getLinkId()) {
+                mTgBarrelPosArr[index].link(pTgBarrelPos);
+                if (index >= mBarrelPosCount) {
+                    mBarrelPosCount = index + 1;
+                }
+            }
+        }
+
+    } while (pTgBarrelPos != nullptr);
+
+    return SUCCEEDED;
+}
+
+int dTgBarrel_c::doDelete() {
+    return SUCCEEDED;
+}
+
+int dTgBarrel_c::actorExecute() {
+    mStateMgr.executeState();
+    return SUCCEEDED;
+}
+
+int dTgBarrel_c::draw() {
+    return SUCCEEDED;
+}
+
 void dTgBarrel_c::initializeState_Wait() {}
-void dTgBarrel_c::executeState_Wait() {}
+void dTgBarrel_c::executeState_Wait() {
+    if (SceneflagManager::sInstance->checkBoolFlag(mRoomID, mStopFlag)) {
+        mStateMgr.changeState(StateID_Stop);
+        return;
+    }
+    dAcOstageSink_c *pStage = mStageRef.get();
+
+    mVec3_c pos = pStage->mPosition;
+    mAng3_c rot = pStage->mRotation;
+
+    mVec3_c stageDist = mSpawnPosition - pos;
+    mMtx_c m;
+    m.transS(pos);
+    m.ZXYrotM(rot);
+    m.multVecSR(stageDist, mPosition);
+
+    mPosition += pos;
+
+    if (checkPlayerPos(dAcPy_c::GetLink()->mPosition)) {
+        if (0 == sLib::calcTimer(&mSpawnTimer)) {
+            mSpawnActive = true;
+
+            u8 idx = 0xFF;
+            for (int i = 0; i < (int)ARRAY_LENGTH(mBarrelArr); ++i) {
+                if (!mBarrelArr[i].isLinked()) {
+                    idx = i;
+                    // I think they forgor a break here
+                }
+            }
+
+            if (idx != 0xFF) {
+                dTgBarrelPos_c *pTgBarrelPos = mTgBarrelPosArr[mBarrelPosIndex].get();
+                if (pTgBarrelPos != nullptr) {
+                    mVec3_c spawnPos = pTgBarrelPos->mPosition;
+                    mAng3_c spawnRot(0, 0x4000, 0);
+                    dAcObjBase_c *pObj = dAcObjBase_c::create(
+                        fProfile::OBJ_BARREL, mRoomID, 0xFF00FF2, &spawnPos, &spawnRot, nullptr, 0xFFFFFFFF
+                    );
+                    mBarrelArr[idx].link(static_cast<dAcOBarrel_c *>(pObj));
+                }
+                if (++mBarrelPosIndex >= mBarrelPosCount) {
+                    mBarrelPosIndex = 0;
+                }
+            }
+            mSpawnTimer = mSpawnInterval * 30;
+        }
+    } else {
+        if (mSpawnActive) {
+            mSpawnTimer = mSpawnInterval * 30;
+        }
+    }
+}
 void dTgBarrel_c::finalizeState_Wait() {}
+
 void dTgBarrel_c::initializeState_Stop() {}
-void dTgBarrel_c::executeState_Stop() {}
+void dTgBarrel_c::executeState_Stop() {
+    if (!SceneflagManager::sInstance->checkBoolFlag(mRoomID, mStopFlag)) {
+        mStateMgr.changeState(StateID_Wait);
+    }
+}
 void dTgBarrel_c::finalizeState_Stop() {}
+
+bool dTgBarrel_c::checkPlayerPos(const mVec3_c &playerPos) {
+    f32 scale = 0.5f;
+
+    mVec3_c pos = playerPos - (mPosition + (mVec3_c::Ey * mScale.y * scale));
+    mAng rot = mStageRef.get()->mRotation.z;
+
+    pos.x = pos.x / mScale.x;
+    pos.y = pos.y / mScale.y;
+    pos.z = pos.z / mScale.z;
+
+    f32 halfCos = rot.cos() * scale;
+    if (rot.cos() != 0.f) {
+        scale = mScale.x * ((pos.x * rot.sin()) / rot.cos()) / mScale.y;
+    }
+
+    return (
+        (pos.x <= halfCos && pos.x >= -halfCos)                            //
+        && pos.y <= scale + 0.5f + 1e-6f && pos.y >= scale + -0.5f - 1e-6f //
+        && pos.z <= 0.5f && pos.z >= -0.5f
+    );
+}
diff --git a/src/REL/d/t/d_t_barrel_pos.cpp b/src/REL/d/t/d_t_barrel_pos.cpp
index 05b28f67..d57a19f4 100644
--- a/src/REL/d/t/d_t_barrel_pos.cpp
+++ b/src/REL/d/t/d_t_barrel_pos.cpp
@@ -1,3 +1,47 @@
 #include "d/t/d_t_barrel_pos.h"
 
+#include "d/a/obj/d_a_obj_stage_sink.h"
+#include "d/t/d_t_barrel.h"
+#include "f/f_base.h"
+
 SPECIAL_ACTOR_PROFILE(TAG_BARREL_POS, dTgBarrelPos_c, fProfile::TAG_BARREL_POS, 0x222, 0, 0);
+
+int dTgBarrelPos_c::create() {
+    mLinkIndex = getFromParams(0, 0xFF);
+    if (mLinkIndex == 0xFF) {
+        mLinkIndex = 0;
+    }
+
+    mLinkId = getFromParams(8, 0xF);
+
+    mStageRef.link(dAcOstageSink_c::GetInstance());
+
+    mSpawnPosition = mPosition;
+
+    return SUCCEEDED;
+}
+
+int dTgBarrelPos_c::doDelete() {
+    return SUCCEEDED;
+}
+
+int dTgBarrelPos_c::actorExecute() {
+    dAcOstageSink_c *pStage = mStageRef.get();
+
+    mVec3_c pos = pStage->mPosition;
+    mAng3_c rot = pStage->mRotation;
+
+    mVec3_c stageDist = mSpawnPosition - pos;
+    mMtx_c m;
+    m.transS(pos);
+    m.ZXYrotM(rot);
+    m.multVecSR(stageDist, mPosition);
+
+    mPosition += pos;
+
+    return SUCCEEDED;
+}
+
+int dTgBarrelPos_c::draw() {
+    return SUCCEEDED;
+}
diff --git a/src/d/lyt/d_lyt_control_game.cpp b/src/d/lyt/d_lyt_control_game.cpp
index 357bc1ee..7d5a0a67 100644
--- a/src/d/lyt/d_lyt_control_game.cpp
+++ b/src/d/lyt/d_lyt_control_game.cpp
@@ -79,7 +79,7 @@ static const char *const sMapSky = "MapSky";
 static const char *const sCommonArrow = "CommonArrow";
 
 void dLytControlGame_c::initializeState_Pause_SetRes() {
-    dLytMeter_c::GetInstance()->setMeterField_0x13750(dLytMeterMain_c::MODE_PAUSE);
+    dLytMeter_c::GetInstance()->setMeterMode(dLytMeterMain_c::MODE_PAUSE_INIT);
     dBase_c::s_NextExecuteControlFlags |= BASE_PROP_0x1;
     static const char *sLytArcs[] = {sMenuPause, sCommonArrow};
     mLytArcControl.set(sLytArcs, ARRAY_LENGTH(sLytArcs));
@@ -132,7 +132,7 @@ void dLytControlGame_c::executeState_Pause_DelRes() {
     mStateMgr.changeState(StateID_Normal);
 }
 void dLytControlGame_c::finalizeState_Pause_DelRes() {
-    dLytMeter_c::GetInstance()->setMeterField_0x13750(dLytMeterMain_c::MODE_NONE);
+    dLytMeter_c::GetInstance()->setMeterMode(dLytMeterMain_c::MODE_NONE);
 }
 
 void dLytControlGame_c::initializeState_Map_SetRes() {
@@ -140,7 +140,7 @@ void dLytControlGame_c::initializeState_Map_SetRes() {
     if (!EventManager::isInEvent() || mMapEvent == dLytMapMain_c::MAP_EVENT_11) {
         dBase_c::s_NextExecuteControlFlags |= BASE_PROP_0x10;
     }
-    dLytMeter_c::GetInstance()->setMeterField_0x13750(dLytMeterMain_c::MODE_MAP_INIT);
+    dLytMeter_c::GetInstance()->setMeterMode(dLytMeterMain_c::MODE_MAP_INIT);
 }
 void dLytControlGame_c::executeState_Map_SetRes() {
     LayoutArcManager::GetInstance()->loadLayoutArcFromDisk(sMap2D, nullptr);
@@ -180,8 +180,8 @@ void dLytControlGame_c::initializeState_Map() {
 }
 void dLytControlGame_c::executeState_Map() {
     if (dLytMap_c::GetInstance()->isOpen()) {
-        if (dLytMeter_c::GetInstance()->getMeterField_0x13750() != dLytMeterMain_c::MODE_MAP) {
-            dLytMeter_c::GetInstance()->setMeterField_0x13750(dLytMeterMain_c::MODE_MAP);
+        if (dLytMeter_c::GetInstance()->getMeterMode() != dLytMeterMain_c::MODE_MAP) {
+            dLytMeter_c::GetInstance()->setMeterMode(dLytMeterMain_c::MODE_MAP);
             if (StoryflagManager::sInstance->getCounterOrFlag(STORYFLAG_PLUS_BTN_NOTICE)) {
                 StoryflagManager::sInstance->unsetFlag(STORYFLAG_PLUS_BTN_NOTICE);
             }
@@ -250,7 +250,7 @@ void dLytControlGame_c::executeState_Map_DelRes() {
     }
 }
 void dLytControlGame_c::finalizeState_Map_DelRes() {
-    dLytMeter_c::GetInstance()->setMeterField_0x13750(dLytMeterMain_c::MODE_NONE);
+    dLytMeter_c::GetInstance()->setMeterMode(dLytMeterMain_c::MODE_NONE);
     dLytMeter_c::GetInstance()->setBasicPosition(dLytMeterMain_c::POSITION_NORMAL);
     dMessage_c::getInstance()->setMapEvent(dLytMapMain_c::MAP_EVENT_MAX);
 }
diff --git a/src/d/lyt/d_lyt_map.cpp b/src/d/lyt/d_lyt_map.cpp
index ef795225..712de322 100644
--- a/src/d/lyt/d_lyt_map.cpp
+++ b/src/d/lyt/d_lyt_map.cpp
@@ -4598,7 +4598,7 @@ void dLytMapMain_c::initializeState_Out() {
     if (mMapEvent == MAP_EVENT_SAVE_OBJ) {
         mPopupInfo.mStateMgr.changeState(StateID_Out);
     }
-    dLytMeter_c::GetInstance()->setMeterField_0x13750(0);
+    dLytMeter_c::GetInstance()->setMeterMode(dLytMeterMain_c::MODE_MAP_INIT);
     if (mDoCameraTransition || mMapEvent == MAP_EVENT_MAP_INTRO) {
         mpInOutAnmGroup = &mAnmGroups[MAP_MAIN_ANIM_OUT];
     } else {
diff --git a/src/d/lyt/d_lyt_pause.cpp b/src/d/lyt/d_lyt_pause.cpp
index 8b11b9a8..9c541073 100644
--- a/src/d/lyt/d_lyt_pause.cpp
+++ b/src/d/lyt/d_lyt_pause.cpp
@@ -581,7 +581,7 @@ void dLytPauseMgr_c::executeState_None() {
         mMain.requestIn();
         mStateMgr.changeState(StateID_In);
         dBase_c::s_NextExecuteControlFlags |= BASE_PROP_0x1;
-        dLytMeter_c::GetInstance()->setMeterField_0x13750(3);
+        dLytMeter_c::GetInstance()->setMeterMode(dLytMeterMain_c::MODE_PAUSE);
         dLytControlGame_c *lytControl = dLytControlGame_c::getInstance();
         if (lytControl->isPauseDemo()) {
             mSavedPauseDisp = lytControl->getCurrentPauseDisp();
diff --git a/src/d/lyt/meter/d_lyt_meter.cpp b/src/d/lyt/meter/d_lyt_meter.cpp
index 8c962391..c8db7a82 100644
--- a/src/d/lyt/meter/d_lyt_meter.cpp
+++ b/src/d/lyt/meter/d_lyt_meter.cpp
@@ -568,21 +568,21 @@ bool dLytMeterMain_c::isNotSilentRealmOrLoftwing() {
 }
 
 bool dLytMeterMain_c::fn_800C9F70() {
-    if ((fn_800D56B0() && !field_0x13775) || fn_800D5650() || fn_800D5680()) {
+    if ((fn_800D56B0() && !field_0x13775) || isInModeMap() || isInModePause()) {
         return true;
     }
     return false;
 }
 
 bool dLytMeterMain_c::fn_800C9FE0() {
-    if (fn_800D56B0() || !field_0x13750 || fn_800D5680()) {
+    if (fn_800D56B0() || mMode == MODE_MAP_INIT || isInModePause()) {
         return true;
     }
     return false;
 }
 
 bool dLytMeterMain_c::fn_800CA040() {
-    if (mHelpOpen || fn_800D5650() || fn_800D5680()) {
+    if (mHelpOpen || isInModeMap() || isInModePause()) {
         return true;
     }
     return false;
@@ -854,7 +854,7 @@ bool dLytMeterMain_c::build(d2d::ResAccIf_c *resAcc) {
 
     mSavedBasicPosition = 0;
     mBasicPosition = POSITION_NORMAL;
-    field_0x13750 = 4;
+    mMode = MODE_NONE;
     field_0x13770 = 3;
     mHelpOpen = false;
     field_0x13775 = 0;
@@ -869,8 +869,8 @@ bool dLytMeterMain_c::build(d2d::ResAccIf_c *resAcc) {
     mBossKeyVisible = false;
     mSmallKeyVisible = false;
     mDrinkVisible = false;
-    field_0x1377E = 0;
-    field_0x1377F = 0;
+    mIsInSwordDrawEvent = false;
+    field_0x1377F = false;
     field_0x13754 = 0;
 
     mAnmGroups[METER_ANIM_POSITION].setFrame(zero);
@@ -993,7 +993,7 @@ bool dLytMeterMain_c::remove() {
     return true;
 }
 
-void dLytMeterMain_c::fn_800D5290() {
+void dLytMeterMain_c::executeMap() {
     dLytMeter_c *meter = dLytMeter_c::GetInstance();
 
     if (dLytMap_c::GetInstance() != nullptr && !dLytMap_c::GetInstance()->isMapEventEq2Or4Or5Or6()) {
@@ -1007,7 +1007,7 @@ void dLytMeterMain_c::fn_800D5290() {
     }
 }
 
-bool dLytMeterMain_c::fn_800D5350() {
+bool dLytMeterMain_c::isInMapEvent() {
     if (mBasicPosition == POSITION_MAP && dMessage_c::getInstance()->getInMapEvent()) {
         return true;
     }
@@ -1023,7 +1023,7 @@ bool dLytMeterMain_c::fn_800D5380(u8 arg) {
     return false;
 }
 
-bool dLytMeterMain_c::fn_800D53D0() {
+bool dLytMeterMain_c::isDoingSkyKeepPuzzle() {
     if (checkIsInSkykeepPuzzle() && !mHelpOpen) {
         return true;
     }
@@ -1031,7 +1031,7 @@ bool dLytMeterMain_c::fn_800D53D0() {
 }
 
 bool dLytMeterMain_c::fn_800D5420() {
-    if (!fn_800D5650()) {
+    if (!isInModeMap()) {
         if (!dStageMgr_c::GetInstance()->isFaderSettled() || !dScGame_c::GetInstance()->isFaderSettled() ||
             !dStageMgr_c::GetInstance()->fn_80199250() || !dStage_c::GetInstance()->fn_801B3EE0()) {
             return true;
@@ -1064,15 +1064,15 @@ void dLytMeterMain_c::fn_800D5630() {
     }
 }
 
-bool dLytMeterMain_c::fn_800D5650() {
-    if (field_0x13750 >= 0 && field_0x13750 <= 1) {
+bool dLytMeterMain_c::isInModeMap() {
+    if (mMode == MODE_MAP_INIT || mMode == MODE_MAP) {
         return true;
     }
     return false;
 }
 
-bool dLytMeterMain_c::fn_800D5680() {
-    if (field_0x13750 >= 2 && field_0x13750 <= 3) {
+bool dLytMeterMain_c::isInModePause() {
+    if (mMode == MODE_PAUSE_INIT || mMode == MODE_PAUSE) {
         return true;
     }
     return false;
@@ -1083,11 +1083,11 @@ bool dLytMeterMain_c::fn_800D56B0() {
         return true;
     }
 
-    if (fn_800D5350()) {
+    if (isInMapEvent()) {
         return true;
     }
 
-    if ((EventManager::isInEvent() && field_0x1377E == 0 && dAcPy_c::GetLink()->getCurrentAction() != 0x8C &&
+    if ((EventManager::isInEvent() && !mIsInSwordDrawEvent && dAcPy_c::GetLink()->getCurrentAction() != 0x8C &&
          dMessage_c::getInstance()->getMapEvent() == dLytMapMain_c::MAP_EVENT_MAX) ||
         mHelpOpen) {
         return true;
@@ -1127,12 +1127,12 @@ void dLytMeterMain_c::checkPaneVisibility() {
     mBossKeyVisible = true;
     mSmallKeyVisible = true;
     mDrinkVisible = true;
-    field_0x1377E = false;
+    mIsInSwordDrawEvent = false;
 
     if (EventManager::getCurrentEventName() != nullptr) {
         const char *name = EventManager::getCurrentEventName();
         if (strequals(name, "SwordDraw") || strequals(name, "SwordDrawDoorNew")) {
-            field_0x1377E = true;
+            mIsInSwordDrawEvent = true;
             if (dLytDobutton_c::getNextActionToShow() != dLytDobutton_c::ACT_DO_DRAW) {
                 dLytDobutton_c::setActionTextStuff(dLytDobutton_c::ICON_NONE, dLytDobutton_c::ACT_DO_INVALID, true);
             }
@@ -1148,7 +1148,7 @@ void dLytMeterMain_c::checkPaneVisibility() {
         mPanesVisible[i] = true;
     }
 
-    if (dAcPy_c::GetLink2()->canDowseProbably() && !fn_800D5650() && !fn_800D5680()) {
+    if (dAcPy_c::GetLink2()->canDowseProbably() && !isInModeMap() && !isInModePause()) {
         if (!field_0x1377F) {
             field_0x1377F = true;
         }
@@ -1179,92 +1179,92 @@ void dLytMeterMain_c::checkPaneVisibility() {
 
         || (MinigameManager::isInMinigameState(MinigameManager::TRIAL_TIME_ATTACK) &&
             LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_B) == LytDoButtonRelated::ACT_IE_NONE) ||
-        (dLytMeter_c::getField_0x13B66() || (fn_800D56B0() && !mItemSelect.fn_800F02F0() && !fn_800D53D0()) ||
-         fn_800D5650() || fn_800D5680())) {
+        (dLytMeter_c::getField_0x13B66() || (fn_800D56B0() && !mItemSelect.fn_800F02F0() && !isDoingSkyKeepPuzzle()) ||
+         isInModeMap() || isInModePause())) {
         mPanesVisible[METER_ANIM_ITEM_SELECT] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0() && !mMinusBtn.fn_800F75E0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle() && !mMinusBtn.fn_800F75E0())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())) {
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())) {
         mPanesVisible[METER_ANIM_MINUS_BTN] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() > 1 && !mPlusBtn.getField_0x1C0() && !mPlusBtn.isCalling())) {
         mPanesVisible[METER_ANIM_PLUS_BTN] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() > 1 && !mCrossBtn.fn_800FA730())) {
         mPanesVisible[METER_ANIM_CROSS_BTN] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() != 0 && !mp1Button->shouldCall())) {
         mPanesVisible[METER_ANIM_1_BTN] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() != 0 && !mp2Button->shouldCall())) {
         mPanesVisible[METER_ANIM_2_BTN] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() > 1)) {
         mPanesVisible[METER_ANIM_A_BTN] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() != 0)) {
         mPanesVisible[METER_ANIM_REMOCON_BG] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0() && !mDowsing.fn_800FE490())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle() && !mDowsing.fn_800FE490())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() != 0 && !fn_800D5380(true) && !mDowsing.shouldCall() && !mDowsing.fn_800FE490())) {
         mPanesVisible[METER_ANIM_DOWSING] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() != 0 && !fn_800D5380(true) && !mZBtn.isCalling())) {
         mPanesVisible[METER_ANIM_Z_BTN] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() != 0)) {
         mPanesVisible[METER_ANIM_NUN_STK] = false;
     }
 
-    if ((fn_800D56B0() && !fn_800D53D0())
+    if ((fn_800D56B0() && !isDoingSkyKeepPuzzle())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())
 
         || (getUiMode() != 0)) {
         mPanesVisible[METER_ANIM_NUN_BG] = false;
@@ -1278,11 +1278,11 @@ void dLytMeterMain_c::checkPaneVisibility() {
          MinigameManager::isInMinigameState(MinigameManager::TRIAL_TIME_ATTACK) ||
          MinigameManager::isInMinigameState(MinigameManager::PUMPKIN_ARCHERY) ||
          MinigameManager::isInMinigameState(MinigameManager::SPIRAL_CHARGE_TUTORIAL) ||
-         MinigameManager::isInMinigameState(MinigameManager::ROLLERCOASTER) || fn_800D56B0() || field_0x1377E)
+         MinigameManager::isInMinigameState(MinigameManager::ROLLERCOASTER) || fn_800D56B0() || mIsInSwordDrawEvent)
 
         || (dLytMeter_c::getField_0x13B66() || fn_800D5420() ||
             (dLytSimpleWindow_c::getInstance() != nullptr && dLytSimpleWindow_c::getInstance()->isOutputText()) ||
-            fn_800D5650() || fn_800D5680())) {
+            isInModeMap() || isInModePause())) {
         mPanesVisible[METER_ANIM_RUPY] = false;
     }
 
@@ -1303,11 +1303,11 @@ void dLytMeterMain_c::checkPaneVisibility() {
 
         || (fn_800D56B0() &&
             (dMessage_c::getInstance()->getField_0x2FC() == 0 || dMessage_c::getInstance()->getField_0x2FC() == -2)) ||
-        field_0x1377E
+        mIsInSwordDrawEvent
 
         || (dLytMeter_c::getField_0x13B66() || fn_800D5420() ||
             (dLytSimpleWindow_c::getInstance() != nullptr && dLytSimpleWindow_c::getInstance()->isOutputText()) ||
-            fn_800D5650() || fn_800D5680())) {
+            isInModeMap() || isInModePause())) {
         mPanesVisible[METER_ANIM_SHIELD] = false;
     }
 
@@ -1330,17 +1330,17 @@ void dLytMeterMain_c::checkPaneVisibility() {
 
         || (dScGame_c::currentSpawnInfo.stageName == "F406" && dScGame_c::currentSpawnInfo.layer == 13)
 
-        || (field_0x1377E != 0)
+        || (mIsInSwordDrawEvent)
 
         || (dLytMeter_c::getField_0x13B66() || fn_800D5420() ||
             (dLytSimpleWindow_c::getInstance() != nullptr && dLytSimpleWindow_c::getInstance()->isOutputText()) ||
-            fn_800D5650() || fn_800D5680())) {
+            isInModeMap() || isInModePause())) {
         mPanesVisible[METER_ANIM_HEART] = false;
     }
 
     if (!isSilentRealm() || (fn_800D56B0() && !fn_800D5590())
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || field_0x13750 == 0 || fn_800D5680())) {
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || mMode == MODE_MAP_INIT || isInModePause())) {
         mTimerVisible = false;
     }
 
@@ -1361,12 +1361,12 @@ void dLytMeterMain_c::checkPaneVisibility() {
          MinigameManager::isInMinigameState(MinigameManager::SPIRAL_CHARGE_TUTORIAL) ||
          MinigameManager::isInMinigameState(MinigameManager::ROLLERCOASTER))
 
-        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || fn_800D5650() || fn_800D5680())) {
+        || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || isInModeMap() || isInModePause())) {
         mPanesVisible[METER_ANIM_GANBARI_GAUGE] = false;
     }
 
     if ((dAcPy_c::GetLink()->getRidingActorType() != dAcPy_c::RIDING_LOFTWING || fn_800D56B0()) ||
-        (dLytMeter_c::getField_0x13B66() || fn_800D5420() || fn_800D5650() || fn_800D5680())) {
+        (dLytMeter_c::getField_0x13B66() || fn_800D5420() || isInModeMap() || isInModePause())) {
         mSkyGaugeVisible = false;
     } else if (bird != nullptr && mpSkyGauge != nullptr) {
         mpSkyGauge->setHeight(dAcPy_c::GetLink()->vt_0x260());
@@ -1383,7 +1383,7 @@ void dLytMeterMain_c::checkPaneVisibility() {
     if (dAcPy_c::GetLink()->getRidingActorType() != dAcPy_c::RIDING_LOFTWING || !field_0x13780 ||
 
         (dLytDobutton_c::getAction() != dLytDobutton_c::ACT_DO_INVALID || fn_800D56B0() ||
-         dLytMeter_c::getField_0x13B66() || fn_800D5420() || fn_800D5650() || fn_800D5680())) {
+         dLytMeter_c::getField_0x13B66() || fn_800D5420() || isInModeMap() || isInModePause())) {
         mBirdGaugeVisible = false;
     }
 
@@ -1410,7 +1410,7 @@ void dLytMeterMain_c::checkPaneVisibility() {
 
     if (!field_0x13781 || fn_800D56B0() ||
 
-        (dLytMeter_c::getField_0x13B66() || fn_800D5420() || fn_800D5650() || fn_800D5680())) {
+        (dLytMeter_c::getField_0x13B66() || fn_800D5420() || isInModeMap() || isInModePause())) {
         mBossGaugeVisible = false;
     }
 
@@ -1436,8 +1436,8 @@ void dLytMeterMain_c::checkPaneVisibility() {
         if (dAcItem_c::getKeyPieceCount() == 0 || dLytAreaCaption_c::getVisible() || fn_800D5380(false) ||
             SceneflagManager::sInstance->checkSceneflagGlobal(4, 0x21) || MinigameManager::isInAnyMinigame()
 
-            || (dLytMeter_c::getField_0x13B66() || fn_800D56B0() || field_0x1377E || fn_800D5420() || fn_800D5650() ||
-                fn_800D5680())) {
+            || (dLytMeter_c::getField_0x13B66() || fn_800D56B0() || mIsInSwordDrawEvent || fn_800D5420() ||
+                isInModeMap() || isInModePause())) {
             mKakeraKeyVisible = false;
         }
         if (mKakeraKeyVisible != oldKakeraKeyVisible) {
@@ -1454,9 +1454,9 @@ void dLytMeterMain_c::checkPaneVisibility() {
 
             || DungeonflagManager::sInstance->getCounterOrFlag(16, 8) != 0 ||
             dAcPy_c::GetLink()->getCurrentAction() == 0x8C || dLytAreaCaption_c::getVisible() || fn_800D5380(false) ||
-            MinigameManager::isInAnyMinigame() || fn_800D56B0() || field_0x1377E
+            MinigameManager::isInAnyMinigame() || fn_800D56B0() || mIsInSwordDrawEvent
 
-            || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || fn_800D5650() || fn_800D5680())) {
+            || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || isInModeMap() || isInModePause())) {
             mBossKeyVisible = false;
         }
 
@@ -1471,9 +1471,9 @@ void dLytMeterMain_c::checkPaneVisibility() {
 
     if (mpSmallKey != nullptr) {
         if (dAcItem_c::getSmallKeyCount() == 0 || dLytAreaCaption_c::getVisible() || fn_800D5380(false) ||
-            MinigameManager::isInAnyMinigame() || fn_800D56B0() || field_0x1377E
+            MinigameManager::isInAnyMinigame() || fn_800D56B0() || mIsInSwordDrawEvent
 
-            || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || fn_800D5650() || fn_800D5680())) {
+            || (dLytMeter_c::getField_0x13B66() || fn_800D5420() || isInModeMap() || isInModePause())) {
             mSmallKeyVisible = false;
         }
 
@@ -1488,9 +1488,9 @@ void dLytMeterMain_c::checkPaneVisibility() {
 
     if (mpDrink != nullptr) {
         if (!field_0x137B2 || dLytAreaCaption_c::getVisible() || fn_800D5380(false) ||
-            MinigameManager::isInAnyMinigame() || field_0x1377E
+            MinigameManager::isInAnyMinigame() || mIsInSwordDrawEvent
 
-            || fn_800D56B0() || dLytMeter_c::getField_0x13B66() || fn_800D5420() || fn_800D5650() || fn_800D5680()) {
+            || fn_800D56B0() || dLytMeter_c::getField_0x13B66() || fn_800D5420() || isInModeMap() || isInModePause()) {
             mDrinkVisible = false;
         }
 
@@ -1522,8 +1522,8 @@ bool dLytMeterMain_c::execute() {
         meter->clearFlags(METER_BTN_PLUS);
     }
 
-    if (field_0x13750 != 0 && mBasicPosition == POSITION_MAP) {
-        fn_800D5290();
+    if (mMode != MODE_MAP_INIT && mBasicPosition == POSITION_MAP) {
+        executeMap();
     }
 
     checkPaneVisibility();
@@ -1866,7 +1866,7 @@ bool dLytMeter_c::execute() {
 bool dLytMeter_c::draw() {
     if (mVisible) {
         mMain.draw();
-        if (mMain.field_0x13750 != 3) {
+        if (mMain.mMode != dLytMeterMain_c::MODE_PAUSE) {
             if (mpEventSkip != nullptr) {
                 mpEventSkip->draw();
             }
@@ -1884,7 +1884,7 @@ bool dLytMeter_c::draw() {
 }
 
 bool dLytMeter_c::fn_800D5670() {
-    return mMain.fn_800D5350();
+    return mMain.isInMapEvent();
 }
 
 void dLytMeter_c::setAreaCaptionOverrideVisibility(bool visible) {
diff --git a/src/d/lyt/meter/d_lyt_meter_a_btn.cpp b/src/d/lyt/meter/d_lyt_meter_a_btn.cpp
index 4eaf009b..0d3fe86d 100644
--- a/src/d/lyt/meter/d_lyt_meter_a_btn.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_a_btn.cpp
@@ -215,7 +215,7 @@ bool dLytMeterABtn_c::execute() {
         return true;
     }
 
-    if (dLytMeter_c::GetInstance()->getMeterField_0x13750() == 0) {
+    if (dLytMeter_c::GetInstance()->getMeterMode() == dLytMeterMain_c::MODE_MAP_INIT) {
         LytDoButtonRelated::set(LytDoButtonRelated::DO_BUTTON_A, LytDoButtonRelated::ACT_IE_NONE);
 
         if (field_0x1BC != LytDoButtonRelated::ACT_IE_NONE) {
@@ -228,7 +228,7 @@ bool dLytMeterABtn_c::execute() {
     bool state = false;
 
     if (EventManager::isInEvent() && !dLytMeter_c::GetInstance()->fn_800D5670() &&
-        dLytMeter_c::GetMain()->getField_0x1377E() == 0 && !checkIsInSkykeepPuzzle() &&
+        !dLytMeter_c::GetMain()->isInSwordDrawEvent() && !checkIsInSkykeepPuzzle() &&
         LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_A) == LytDoButtonRelated::ACT_IE_NONE) {
         field_0x1C9 = 0;
 
diff --git a/src/d/lyt/meter/d_lyt_meter_cross_btn.cpp b/src/d/lyt/meter/d_lyt_meter_cross_btn.cpp
index 4144671b..98ec874a 100644
--- a/src/d/lyt/meter/d_lyt_meter_cross_btn.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_cross_btn.cpp
@@ -34,7 +34,7 @@ void dLytMeterCrossBtnParts_c::initializeState_Wait() {
     mOnDelay = 15;
 }
 void dLytMeterCrossBtnParts_c::executeState_Wait() {
-    if (dLytMeter_c::GetMain()->fn_800D5650()) {
+    if (dLytMeter_c::GetMain()->isInModeMap()) {
         mOnDelay = 0;
     }
 
@@ -150,7 +150,7 @@ void dLytMeterCrossBtnParts_c::execute(bool bIsVisible) {
         return;
     }
 
-    if (dLytMeter_c::GetInstance()->getMeterField_0x13750() == 0) {
+    if (dLytMeter_c::GetInstance()->getMeterMode() == dLytMeterMain_c::MODE_MAP_INIT) {
         if (mIndex == CROSS_BTN_PART_TOP) {
             LytDoButtonRelated::setCrossTop(LytDoButtonRelated::ACT_IE_NONE, true);
         } else if (mIndex == CROSS_BTN_PART_DOWN) {
diff --git a/src/d/lyt/meter/d_lyt_meter_dowsing.cpp b/src/d/lyt/meter/d_lyt_meter_dowsing.cpp
index b8770394..dde6a0b6 100644
--- a/src/d/lyt/meter/d_lyt_meter_dowsing.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_dowsing.cpp
@@ -395,14 +395,14 @@ void dLytMeterDowsing_c::executeState_Wait() {
         mStateMgr.changeState(StateID_DemoMove);
     } else if (field_0x5505 != 0) {
         mStateMgr.changeState(StateID_MenuSelectingIn);
-    } else if (field_0x550A != 0 && (!dLytMeter_c::GetMain()->fn_800D5380(0) || dLytMeter_c::GetMain()->fn_800D5650() ||
-                                     dLytMeter_c::GetMain()->fn_800D5680())) {
+    } else if (field_0x550A != 0 && (!dLytMeter_c::GetMain()->fn_800D5380(0) || dLytMeter_c::GetMain()->isInModeMap() ||
+                                     dLytMeter_c::GetMain()->isInModePause())) {
         mStateMgr.changeState(StateID_Reset);
     } else if (!dLytMeter_c::GetInstance()->checkAllFlags(METER_BTN_C)) {
         mStateMgr.changeState(StateID_ToUnuse);
-    } else if (dLytMeter_c::GetInstance()->getMeterField_0x1377F() != 0 && field_0x550A == 0 &&
-               dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->fn_800D5650() &&
-               !dLytMeter_c::GetMain()->fn_800D5680() && getSelectedDowsingSlot() != DowsingTarget::SLOT_LOOK &&
+    } else if (dLytMeter_c::GetInstance()->getMeterField_0x1377F() && field_0x550A == 0 &&
+               dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->isInModeMap() &&
+               !dLytMeter_c::GetMain()->isInModePause() && getSelectedDowsingSlot() != DowsingTarget::SLOT_LOOK &&
                getSelectedDowsingSlot() != DowsingTarget::SLOT_NONE &&
                LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52) {
         mAnm[DOWSING_ANIM_IN].setBackwardsOnce();
@@ -552,7 +552,7 @@ void dLytMeterDowsing_c::initializeState_ToUse() {
 
     if (FileManager::GetInstance()->getDowsingSlotIdx() != 8 &&
         LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 && dLytMeter_c::GetMain()->fn_800D5380(0) &&
-        !dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680()) {
+        !dLytMeter_c::GetMain()->isInModeMap() && !dLytMeter_c::GetMain()->isInModePause()) {
         mAnm[DOWSING_ANIM_RESET].setAnimEnable(true);
         mAnm[DOWSING_ANIM_RESET].setBackwardsOnce();
         mAnm[DOWSING_ANIM_RESET].setToStart();
@@ -561,7 +561,7 @@ void dLytMeterDowsing_c::initializeState_ToUse() {
 void dLytMeterDowsing_c::executeState_ToUse() {
     if (FileManager::GetInstance()->getDowsingSlotIdx() != 8 &&
         LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 && dLytMeter_c::GetMain()->fn_800D5380(0) &&
-        !dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680()) {
+        !dLytMeter_c::GetMain()->isInModeMap() && !dLytMeter_c::GetMain()->isInModePause()) {
         if (mAnm[DOWSING_ANIM_INPUT_0].isStop2()) {
             if (!mAnm[DOWSING_ANIM_RESET].isEnabled() || mAnm[DOWSING_ANIM_RESET].isStop2()) {
                 mStateMgr.changeState(StateID_Wait);
@@ -586,7 +586,7 @@ void dLytMeterDowsing_c::finalizeState_ToUse() {
 
 void dLytMeterDowsing_c::initializeState_ToUnuse() {
     mAnm[DOWSING_ANIM_INPUT_0].setForwardOnce();
-    if (dLytMeter_c::GetMain()->fn_800D5650()) {
+    if (dLytMeter_c::GetMain()->isInModeMap()) {
         mAnm[DOWSING_ANIM_INPUT_0].setToEnd2();
     } else {
         mAnm[DOWSING_ANIM_INPUT_0].setToStart();
@@ -595,7 +595,7 @@ void dLytMeterDowsing_c::initializeState_ToUnuse() {
 
     if (FileManager::GetInstance()->getDowsingSlotIdx() != 8 &&
         LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 && dLytMeter_c::GetMain()->fn_800D5380(0) &&
-        !dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680()) {
+        !dLytMeter_c::GetMain()->isInModeMap() && !dLytMeter_c::GetMain()->isInModePause()) {
         mAnm[DOWSING_ANIM_RESET].setAnimEnable(true);
         mAnm[DOWSING_ANIM_RESET].setForwardOnce();
         mAnm[DOWSING_ANIM_RESET].setToStart();
@@ -631,7 +631,7 @@ void dLytMeterDowsing_c::executeState_Unuse() {
         mLyt.calc();
         mAnm[DOWSING_ANIM_INPUT_0].setAnimEnable(false);
         mStateMgr.changeState(StateID_DemoMove);
-    } else if (!dLytMeter_c::GetMain()->fn_800D5680() && !dLytMeter_c::GetInstance()->isHelpOpen() &&
+    } else if (!dLytMeter_c::GetMain()->isInModePause() && !dLytMeter_c::GetInstance()->isHelpOpen() &&
                dLytMeter_c::GetInstance()->checkAllFlags(METER_BTN_C)) {
         if (field_0x54D8 <= 0) {
             mStateMgr.changeState(StateID_ToUse);
@@ -1104,7 +1104,7 @@ void dLytMeterDowsing_c::fn_800FE110() {
         mText[0].setShouldBeSelect(false);
     }
 
-    if (dLytMeter_c::GetInstance()->getMeterField_0x1377F() != 0 && field_0x550A == 0) {
+    if (dLytMeter_c::GetInstance()->getMeterField_0x1377F() && field_0x550A == 0) {
         mInput.setShouldBeSelect(true);
     } else {
         mInput.setShouldBeSelect(false);
@@ -1114,8 +1114,8 @@ void dLytMeterDowsing_c::fn_800FE110() {
 void dLytMeterDowsing_c::fn_800FE220() {
     if (getSelectedDowsingSlot() != DowsingTarget::SLOT_NONE &&
         LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == LytDoButtonRelated::ACT_IE_INFO_DOWSE &&
-        dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->fn_800D5650() &&
-        !dLytMeter_c::GetMain()->fn_800D5680()) {
+        dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->isInModeMap() &&
+        !dLytMeter_c::GetMain()->isInModePause()) {
         mAnm[DOWSING_ANIM_RESET].setAnimEnable(true);
         mAnm[DOWSING_ANIM_RESET].setForwardOnce();
         mAnm[DOWSING_ANIM_RESET].setToStart();
@@ -1169,7 +1169,7 @@ bool dLytMeterDowsing_c::fn_800FE4B0() const {
 
 bool dLytMeterDowsing_c::fn_800FE610() {
     if ((!dLytMeter_c::GetMain()->getDowsingNotHiddenByAreaCaption() && !dLytAreaCaption_c::getVisible()) ||
-        !getPane()->IsVisible() || dLytMeter_c::GetMain()->fn_800D5680()) {
+        !getPane()->IsVisible() || dLytMeter_c::GetMain()->isInModePause()) {
         return false;
     }
     return true;
@@ -1196,7 +1196,7 @@ s32 dLytMeterDowsing_c::convertToLytIndex(s32 slot) const {
 }
 
 u8 dLytMeterDowsing_c::getSelectedDowsingSlot() const {
-    if (dLytMeter_c::GetMain()->fn_800D5650()) {
+    if (dLytMeter_c::GetMain()->isInModeMap()) {
         return DowsingTarget::SLOT_NONE;
     } else {
         return FileManager::GetInstance()->getDowsingSlotIdx();
diff --git a/src/d/lyt/meter/d_lyt_meter_item_select.cpp b/src/d/lyt/meter/d_lyt_meter_item_select.cpp
index 3055d073..7ee9987d 100644
--- a/src/d/lyt/meter/d_lyt_meter_item_select.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_item_select.cpp
@@ -688,7 +688,7 @@ void dLytMeterItemSelect_c::executeState_Wait() {
         mStateMgr.changeState(StateID_SetSpecialItemIn);
     } else if (!dLytMeter_c::GetInstance()->checkAllFlags(METER_BTN_B)) {
         mStateMgr.changeState(StateID_ToUnuse);
-    } else if (!dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680() &&
+    } else if (!dLytMeter_c::GetMain()->isInModeMap() && !dLytMeter_c::GetMain()->isInModePause() &&
                LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_B) != LytDoButtonRelated::ACT_IE_ETC_ITEMS &&
                LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_B) != LytDoButtonRelated::ACT_IE_ETC_RETURN &&
                LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_B) != LytDoButtonRelated::ACT_IE_ETC_DONE &&
@@ -2483,8 +2483,8 @@ bool dLytMeterItemSelect_c::fn_800EFDF0(bool b) const {
 bool dLytMeterItemSelect_c::fn_800F0030() const {
     if (!StoryflagManager::sInstance->getCounterOrFlag(STORYFLAG_B_WHEEL_UNLOCKED) &&
             !(EventManager::isInEvent() && EventManager::isCurrentEvent("ItemGetGorgeous")) ||
-        (mpOwnerPane == nullptr || !mpOwnerPane->IsVisible() || dLytMeter_c::GetMain()->fn_800D5650() ||
-         dLytMeter_c::GetMain()->fn_800D5680() || !dLytMeter_c::GetMain()->getItemSelectNotHiddenByAreaCaption())) {
+        (mpOwnerPane == nullptr || !mpOwnerPane->IsVisible() || dLytMeter_c::GetMain()->isInModeMap() ||
+         dLytMeter_c::GetMain()->isInModePause() || !dLytMeter_c::GetMain()->getItemSelectNotHiddenByAreaCaption())) {
         // If we don't have a B-Wheel and we're not currently in the ItemGetGorgeous event,
         // or (random other conditions), return false
         return false;
@@ -2715,7 +2715,7 @@ bool dLytMeterItemSelect_c::isWheelBlockedByCurrentAction() {
         dAcPy_c::LINK->checkActionFlags(dAcPy_c::FLG0_SWING_ROPE) || dAcPy_c::LINK->checkCurrentAction(0x9C) ||
         dAcPy_c::LINK->getRidingActorType() == dAcPy_c::RIDING_TRUCK_MINECART ||
         dAcPy_c::LINK->checkCurrentAction(0x95) || isInSpiralChargeTutorialMinigame() || isInRollercoasterMinigame() ||
-        dAcPy_c::LINK->checkCurrentAction(0x8C) || dLytMeter_c::GetMain()->getField_0x1377E() != 0 ||
+        dAcPy_c::LINK->checkCurrentAction(0x8C) || dLytMeter_c::GetMain()->isInSwordDrawEvent() ||
         checkIsInSkykeepPuzzle() || dLytMeter_c::GetInstance()->getMeterField_0x13770() == 0) {
         return true;
     }
diff --git a/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp b/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp
index 297ff3c1..001b70a0 100644
--- a/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp
@@ -1039,8 +1039,8 @@ bool dLytMeterMinusBtn_c::fn_800F7600() const {
 
 bool dLytMeterMinusBtn_c::fn_800F7760() const {
     if (!StoryflagManager::sInstance->getCounterOrFlag(STORYFLAG_POUCH_UNLOCKED) ||
-        (mpOwnerPane == nullptr || !mpOwnerPane->IsVisible() || dLytMeter_c::GetMain()->fn_800D5650() ||
-         dLytMeter_c::GetMain()->fn_800D5680() || !dLytMeter_c::GetMain()->getMinusBtnNotHiddenByAreaCaption())) {
+        (mpOwnerPane == nullptr || !mpOwnerPane->IsVisible() || dLytMeter_c::GetMain()->isInModeMap() ||
+         dLytMeter_c::GetMain()->isInModePause() || !dLytMeter_c::GetMain()->getMinusBtnNotHiddenByAreaCaption())) {
         return false;
     }
 
diff --git a/src/d/lyt/meter/d_lyt_meter_timer.cpp b/src/d/lyt/meter/d_lyt_meter_timer.cpp
index 31b8eef4..911f2a3e 100644
--- a/src/d/lyt/meter/d_lyt_meter_timer.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_timer.cpp
@@ -201,7 +201,7 @@ void LytMeterTimerPart1_c::initOutAnim() {
 }
 
 void LytMeterTimerPart1_c::startInAnim() {
-    if (dLytMeter_c::GetMain()->fn_800D5650()) {
+    if (dLytMeter_c::GetMain()->isInModeMap()) {
         mAnm[TIMER_01_ANIM_MAP_POSITION].setFrame(1.0f);
     } else {
         mAnm[TIMER_01_ANIM_MAP_POSITION].setFrame(0.0f);
@@ -620,7 +620,7 @@ void LytMeterTimerPart2_c::initChangeFruitAnim() {
 }
 
 void LytMeterTimerPart2_c::startInAnim() {
-    if (dLytMeter_c::GetMain()->fn_800D5650()) {
+    if (dLytMeter_c::GetMain()->isInModeMap()) {
         mAnm[TIMER_02_ANIM_MAP_POSITION].setFrame(1.0f);
     } else {
         mAnm[TIMER_02_ANIM_MAP_POSITION].setFrame(0.0f);
@@ -1365,7 +1365,7 @@ void dLytMeterTimer_c::startIn() {
     mpPart2->stopOutAnim();
     mpPart1->startInAnim();
     mpPart2->startInAnim();
-    if (dLytMeter_c::GetMain()->fn_800D5650()) {
+    if (dLytMeter_c::GetMain()->isInModeMap()) {
         if (mStateMgr.isState(StateID_ChangeSiren)) {
             mpPart2->stopFlowerLoopAnim();
             mpPart2->resetFlowerLoopAnim();