Merge branch 'main' into pr/85

2026-09-12 12:25:34 -04:00 · 2024-11-08 20:28:55 -05:00
parent 95fe4864cc e9ab25fe26
commit 52d7c0ff45
121 changed files with 8404 additions and 2446 deletions
@@ -1,9 +1,226 @@
 #include "d/a/d_a_bombf.h"

+#include "common.h"
+#include "d/a/d_a_player.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_s_lin_chk.h"
+#include "d/flag/sceneflag_manager.h"
+#include "m/m_mtx.h"
+#include "m/m_vec.h"
+#include "toBeSorted/time_area_mgr.h"
+
 SPECIAL_ACTOR_PROFILE(BOMBF, dAcBombf_c, fProfile::BOMBF, 0x129, 0, 4099);

 STATE_DEFINE(dAcBombf_c, Wait);

+bool dAcBombf_c::createHeap() {
+    nw4r::g3d::ResFile resFile = getOarcResFile("FlowerBomb");
+    nw4r::g3d::ResMdl resMdl = resFile.GetResMdl("LeafBomb");
+    return mModel.create(resMdl, &heap_allocator, 0x120, 1, nullptr);
+}
+
+int dAcBombf_c::actorCreate() {
+    mDespawnSceneFlag = (params >> 8) & 0xFF;
+    field_0x3D4 = (params >> 16) & 0xF;
+    if (SceneflagManager::sInstance->checkBoolFlag(roomid, mDespawnSceneFlag)) {
+        return FAILED;
+    }
+
+    CREATE_ALLOCATOR(dAcBombf_c);
+
+    field_0x3D2 = (params >> 4) & 0xF;
+    field_0x3D0 = field_0x3D2 == 1;
+    if (field_0x3D0) {
+        mModel.setPriorityDraw(0x82, 0x7F);
+    }
+
+    mStts.SetDefaultRank();
+    forwardAccel = -2.0f;
+    forwardMaxSpeed = -80.0f;
+    mStateMgr.changeState(StateID_Wait);
+    boundingBox.Set(mVec3_c(-80.0, -50.0f, -80.0f), mVec3_c(80.0, 60.0f, 80.0f));
+    angle = rotation;
+    if (mDespawnSceneFlag < 0xFF) {
+        actor_properties = (actor_properties & ~1) | 4;
+    }
+
+    return SUCCEEDED;
+}
+
+int dAcBombf_c::actorPostCreate() {
+    // Preamble problem
+    mMtx_c mtx;
+    mtx.ZXYrotS(rotation.x, rotation.y, rotation.z);
+    mVec3_c v;
+    PSMTXMultVecSR(mtx, mVec3_c::Ey, v);
+    mVec3_c v3 = position + v * 10.0f;
+    mVec3_c v4 = position - v * 10.0f;
+
+    if (dBgS_ObjLinChk::LineCross(&v3, &v4, this)) {
+        position = dBgS_ObjLinChk::GetInstance().GetLinEnd();
+        if (rotation.x == 0 && rotation.z == 0 && dBgS_ObjLinChk::ChkGround()) {
+            cM3dGPla pla;
+            dBgS::GetInstance()->GetTriPla(dBgS_ObjLinChk::GetInstance(), &pla);
+            rotation.x = pla.GetAngle(rotation.y);
+            rotation.z = pla.GetAngle(rotation.y - 0x4000);
+        }
+
+        if (dBgS::GetInstance()->ChkMoveBG(dBgS_ObjLinChk::GetInstance(), false)) {
+            field_0x398.SetPolyInfo(dBgS_ObjLinChk::GetInstance());
+            actor_properties = (actor_properties & ~1) | 4;
+        }
+        mLightingInfo.mLightingCode = dBgS::GetInstance()->GetLightingCode(dBgS_ObjLinChk::GetInstance());
+    }
+
+    if (field_0x3D2 == 0 || field_0x3D2 == 2) {
+        bool b = dTimeAreaMgr_c::sInstance->fn_800B9B60(roomid, position);
+        if (b) {
+            mTimeAreaStruct.field_0x00 = 1.0f;
+        }
+        if ((b && field_0x3D2 == 2) || (!b && field_0x3D2 == 0)) {
+            mModel.setScale(0.0001f, 0.0001f, 0.0001f);
+            if (mBombRef.get() != nullptr) {
+                mBombRef.get()->mField_0xA50 = 0.0001f;
+            }
+        }
+    }
+
+    updateMatrix();
+    mModel.setLocalMtx(mWorldMtx);
+    regrowBomb();
+    if (mBombRef.get() != nullptr) {
+        mBombRef.get()->mScale.set(0.95f, 0.95f, 0.95f);
+    }
+
+    return SUCCEEDED;
+}
+
+int dAcBombf_c::doDelete() {
+    return SUCCEEDED;
+}
+
+int dAcBombf_c::actorExecute() {
+    if (field_0x3D3 != 0) {
+        mMtx_c &mtx = mWorldMtx;
+        mtx.getTranslation(position);
+        dAcBomb_c *bomb = mBombRef.get();
+        if (bomb != nullptr) {
+            bomb->setTransformFromFlower(mtx);
+        }
+        mModel.setLocalMtx(mWorldMtx);
+        poscopy2 = position;
+        poscopy3 = position;
+        field_0x3D3 = 0;
+    } else {
+        if (dBgS::GetInstance()->ChkMoveBG(field_0x398, true)) {
+            dBgS::GetInstance()->MoveBgTransPos(field_0x398, true, &position, &angle, &rotation);
+            updateMatrix();
+            dAcBomb_c *bomb = mBombRef.get();
+            if (bomb != nullptr) {
+                bomb->setTransformFromFlower(mWorldMtx);
+            }
+            mModel.setLocalMtx(mWorldMtx);
+            poscopy2 = position;
+            poscopy3 = position;
+        }
+    }
+
+    mStateMgr.executeState();
+    return SUCCEEDED;
+}
+
+int dAcBombf_c::draw() {
+    if (field_0x3D0 != 0 && (dAcPy_c::LINK->mActionFlagsCont & 0x400000) == 0) {
+        return SUCCEEDED;
+    }
+    drawModelType1(&mModel);
+    return SUCCEEDED;
+}
+
+void dAcBombf_c::regrowBomb() {
+    // These params are hell
+    s8 viewclip_idx = (actor_properties & 1) != 0 ? viewclip_index : -1;
+    u32 actorParams1;
+    actorParams1 = 1;
+    if (field_0x3D0) {
+        actorParams1 = 2;
+    }
+    dAcObjBase_c *ac = dAcObjBase_c::create(
+        "Bomb", roomid, actorParams1, &position, nullptr, nullptr, 0xFFFFFFFF, 0xFFFF, viewclip_idx
+    );
+    mBombRef.link(static_cast<dAcBomb_c *>(ac));
+    dAcBomb_c *bomb = mBombRef.get();
+    if (bomb != nullptr) {
+        field_0x394 = 0x3C;
+        bomb->setTransformFromFlower(mWorldMtx);
+        if ((actor_properties & 1) != 0) {
+            bomb->actor_properties |= 1;
+        }
+        if (field_0x3D4 == 0) {
+            bomb->mField_0xA44 *= 1.5f;
+        }
+    }
+}
+
 void dAcBombf_c::initializeState_Wait() {}
-void dAcBombf_c::executeState_Wait() {}
+
+extern "C" void fn_800298B0(u16, mVec3_c *, mVec3_c *, u32, u32, u32, u32, u32);
+extern "C" u16 lbl_8057A750;
+
+void dAcBombf_c::executeState_Wait() {
+    // Stack problems
+    if (SceneflagManager::sInstance->checkBoolFlag(roomid, mDespawnSceneFlag)) {
+        deleteRequest();
+        dAcBomb_c *bomb = mBombRef.get();
+        if (bomb != nullptr) {
+            bomb->deleteRequest();
+            bomb->mEffect1.remove(true);
+            bomb->mEffect2.remove(true);
+        }
+        return;
+    }
+
+    f32 scaleFactor = mScale.x;
+    if (field_0x3D2 == 0 || field_0x3D2 == 2) {
+        mVec3_c m;
+        PSMTXMultVecSR(mWorldMtx, mVec3_c::Ey, m);
+
+        mVec3_c m3 = position + (m * 30.0f);
+
+        if (mTimeAreaStruct.check(roomid, m3, 0, 30.0f, 0.1f) && field_0x3D4 != 1) {
+            if (mTimeAreaStruct.field_0x04 == 1) {
+                playSound(0xC0A);
+            } else {
+                playSound(0xC0B);
+            }
+            fn_800298B0(lbl_8057A750, &position, nullptr, 0, 0, 0, 0, 0);
+        }
+
+        scaleFactor *= mTimeAreaStruct.field_0x00;
+        if (field_0x3D2 == 2) {
+            scaleFactor = 1.0f - scaleFactor;
+        }
+        scaleFactor = nw4r::ut::Max(scaleFactor, 0.0001f);
+        mModel.setScale(scaleFactor, scaleFactor, scaleFactor);
+    }
+    dAcBomb_c *bomb = mBombRef.get();
+    if (bomb != nullptr) {
+        if (!bomb->mStateMgr.isState(dAcBomb_c::StateID_FlowerWait) && field_0x3D0 == 0) {
+            mBombRef.unlink();
+            field_0x394 = 0x3C;
+        }
+    } else {
+        if (field_0x394 != 0) {
+            field_0x394--;
+        } else if (field_0x3D0 == 0 || dAcPy_c::LINK->getSquareDistanceTo(position) > 22500.0f) {
+            regrowBomb();
+        }
+    }
+
+    bomb = mBombRef.get();
+    if (bomb != nullptr) {
+        bomb->mField_0xA50 = scaleFactor;
+    }
+}
+
 void dAcBombf_c::finalizeState_Wait() {}
@@ -2,7 +2,6 @@

 #include "s/s_Math.h"

-
 SPECIAL_ACTOR_PROFILE(OBJ_MOLE_SOIL, dAcOmoleSoil_c, fProfile::OBJ_MOLE_SOIL, 0x008B, 0, 6);

 STATE_DEFINE(dAcOmoleSoil_c, Wait);
@@ -24,10 +23,6 @@ bool dAcOmoleSoil_c::createHeap() {
    return true;
 }

-bool intToBool(int a) {
-    return a;
-}
-
 int dAcOmoleSoil_c::create() {
    CREATE_ALLOCATOR(dAcOmoleSoil_c);

@@ -50,7 +50,7 @@ int dAcOPoolCock_c::actorExecute() {
    mStateMgr.executeState();
    calcVelocity();
    position += velocity;
-    position += mCCdStruct.posIncrements;
+    position += mStts.mCcMove;
    updateMatrix();
    mMtx_c mdl1Transform;
    mMtx_c mdl2Transform;
@@ -39,7 +39,7 @@ int dAcOring_c::actorExecute() {
    mStateMgr.executeState();
    calcVelocity();
    position += velocity;
-    position += mCCdStruct.posIncrements;
+    position += mStts.mCcMove;
    updateMatrix();
    mModel.setLocalMtx(mWorldMtx);
    return SUCCEEDED;
@@ -1,14 +1,13 @@
 #include "d/a/obj/d_a_obj_spike.h"

-#include "d/col/cc/d_cc_mgr.h"
-
+#include "d/col/cc/d_cc_s.h"

 SPECIAL_ACTOR_PROFILE(OBJ_SPIKE, dAcOspike_c, fProfile::OBJ_SPIKE, 0x1D9, 0, 2);

 // clang-format off
-dCcD_SrcAabb dAcOspike_c::sCcSrc = {
-    {{{0x400}, 0x2003F, 0, 1, 0, 0, 0, 0, 0}, 
-    {{0xFEB77DFF}, 0x111, 0x06, 0x407, 0, 0}, 
+dCcD_SrcUnk dAcOspike_c::sCcSrc = {
+    {{0x400, 0x2003F, {0, 0, 0}, 1, 0, 0, 0, 0}, 
+    {0xFEB77DFF, 0x111, 0x06, 0x407, 0, }, 
    {0}},
    {-1.0f, -246.0f, -472.0f, 73.0f, 255.0f, 482.0f}};
 // clang-format on
@@ -30,15 +29,15 @@ int dAcOspike_c::create() {
        return FAILED;
    }

-    mCCdStruct.setField0x38ToMagicValue();
-    mCollision.init(sCcSrc);
-    mCollision.initUnk(mCCdStruct);
+    mStts.SetDefaultRank();
+    mCollision.Set(sCcSrc);
+    mCollision.SetStts(mStts);

    updateMatrix();
    mMdl.setLocalMtx(mWorldMtx);
    mVec3_c tmp;
    PSMTXMultVecSR(mWorldMtx.m, mVec3_c::Ex, tmp);
-    mCollision.setAtVec(tmp);
+    mCollision.SetAtVec(tmp);

    mMtx_c mtx;
    mtx.XrotS(rotation.x);
@@ -63,7 +62,7 @@ int dAcOspike_c::create() {
        tmp3.z = copy;
    }

-    mCollision.Set(tmp2, tmp3);
+    mCollision.cM3dGUnk::Set(tmp2, tmp3);
    mStateMgr.changeState(StateID_Wait);
    boundingBox.Set(mVec3_c(-10.0f, -250.0f, -480.0f), mVec3_c(80.0f, 260.0f, 490.0f));
    return SUCCEEDED;
@@ -75,8 +74,8 @@ int dAcOspike_c::doDelete() {

 int dAcOspike_c::actorExecute() {
    mStateMgr.executeState();
-    mCollision.Set(position, rotation.y);
-    ColliderManager::getColliderManager()->addCollider(&mCollision);
+    mCollision.cM3dGUnk::Set(position, rotation.y);
+    dCcS::GetInstance()->Set(&mCollision);
    return 1;
 }

@@ -1,13 +1,13 @@
 #include "d/a/obj/d_a_obj_toD3_stone_figure.h"

-#include "d/col/cc/d_cc_mgr.h"
+#include "d/col/cc/d_cc_s.h"
+#include "d/a/obj/d_a_obj_item.h"
+#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/attention.h"
 #include "toBeSorted/event.h"
 #include "toBeSorted/event_manager.h"
-#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/scgame.h"

-
 SPECIAL_ACTOR_PROFILE(OBJ_TOD3_STONE, dAcOtoD3StoneFigure_c, fProfile::OBJ_TOD3_STONE, 0x1B3, 0, 0);

 STATE_DEFINE(dAcOtoD3StoneFigure_c, OneEye);
@@ -18,10 +18,40 @@ f32 dAcOtoD3StoneFigure_c::sHeight = 290.0f;

 // clang-format off
 dCcD_SrcCyl dAcOtoD3StoneFigure_c::sCcSrc = {
-    {{{0}, 0, 0, 0, 0, 0, 0, 0, 0}, 
-    {{0xFEB77DFF}, 0x1000111, 0x06, 0x407, 0, 0}, 
-    {0xE9}},
-    {dAcOtoD3StoneFigure_c::sRadius, dAcOtoD3StoneFigure_c::sHeight}
+    {
+        {
+            0, 
+            0,
+            {
+                0,  
+                0,  
+                0   
+            },
+            0,
+            0,
+            0,
+            0,
+            0,
+            0
+        }, 
+        {
+            0xFEB77DFF,
+            0x1000111,
+            {
+                0x06,
+                0x407
+            },
+            0,
+            0
+        }, 
+        {
+            0xE9
+        }
+    },
+    {
+        dAcOtoD3StoneFigure_c::sRadius,
+        dAcOtoD3StoneFigure_c::sHeight
+    }
 };
 // clang-format on

@@ -42,16 +72,15 @@ int dAcOtoD3StoneFigure_c::create() {
    }

    mMdl.setLocalMtx(mWorldMtx);
-    mCCdStruct.setField0x38ToMagicValue();
-    mCollision.init(sCcSrc);
-    mCollision.initUnk(mCCdStruct);
+    mStts.SetDefaultRank();
+    mCollision.Set(sCcSrc);
+    mCollision.SetStts(mStts);
    int zero = 0;
    mCollision.SetC(position);
    mCollision.SetR(dAcOtoD3StoneFigure_c::sRadius + zero);
    mCollision.SetH(dAcOtoD3StoneFigure_c::sHeight + zero);
-    ColliderManager::getColliderManager()->addCollider(&mCollision);
-    // mCollision.clearCoFlag();
-    mCollision.setTgCoFlag(1);
+    dCcS::GetInstance()->Set(&mCollision);
+    mCollision.OnTgCoFlag(1);

    // ???
    f32 a, b, c;
@@ -66,7 +95,7 @@ int dAcOtoD3StoneFigure_c::create() {
    poscopy3.y = b;
    poscopy3.z = c;
    // poscopy3 = poscopy2;
-    mCollision.setSomeDefendValue(0x2000);
+    mCollision.SetTg_0x4C(0x2000);

    if (!mIsSkyKeepAlreadyOpen) {
        mStateMgr.changeState(StateID_OneEye);
@@ -83,7 +112,7 @@ int dAcOtoD3StoneFigure_c::doDelete() {

 int dAcOtoD3StoneFigure_c::actorExecute() {
    mStateMgr.executeState();
-    ColliderManager::getColliderManager()->addCollider(&mCollision);
+    dCcS::GetInstance()->Set(&mCollision);
    return SUCCEEDED;
 }

@@ -135,7 +164,6 @@ void dAcOtoD3StoneFigure_c::doInteraction(s32 arg) {
    }
 }

-extern "C" s32 AcItem__checkFlag(s32);
 bool dAcOtoD3StoneFigure_c::hasStoneOfTrials() const {
-    return AcItem__checkFlag(0xB4);
+    return dAcItem_c::checkFlag(0xB4);
 }
@@ -1,17 +1,140 @@
 #include "d/a/obj/d_a_obj_trap_rock_1.h"

+#include "d/col/bg/d_bg_s.h"
+#include "d/flag/sceneflag_manager.h"
+#include "m/m_vec.h"
+#include "nw4r/math/math_arithmetic.h"
+#include "s/s_Math.h"
+
 SPECIAL_ACTOR_PROFILE(OBJ_TRAP_ROCK_1, dAcOtrapRock1_c, fProfile::OBJ_TRAP_ROCK_1, 0x26B, 0, 2);

 STATE_DEFINE(dAcOtrapRock1_c, TrapWait);
 STATE_DEFINE(dAcOtrapRock1_c, TrapAction);
 STATE_DEFINE(dAcOtrapRock1_c, TrapReturn);

+bool dAcOtrapRock1_c::createHeap() {
+    mResFile = getOarcResFile("TrapRockRoll");
+    nw4r::g3d::ResMdl m = mResFile.GetResMdl("TrapRockRoll");
+
+    TRY_CREATE(mMdl.create(m, &heap_allocator, 0x120));
+    mMdl.setPriorityDraw(0x1C, 0x09);
+    void *dzb = getOarcFile("TrapRockRoll", "dzb/TrapRockRoll.dzb");
+    void *plc = getOarcFile("TrapRockRoll", "dat/TrapRockRoll.plc");
+    updateMatrix();
+    return !mBgW.Set((cBgD_t *)dzb, (PLC *)plc, cBgW::MOVE_BG_e, &mWorldMtx, nullptr);
+}
+
+int dAcOtrapRock1_c::create() {
+    mActivationSceneFlag = params & 0xFF;
+    mReturnSceneFlag = (params >> 8) & 0xFF;
+    CREATE_ALLOCATOR(dAcOtrapRock1_c);
+
+    mBgW.SetCrrFunc(dBgS_MoveBGProc_Typical);
+    dBgS::GetInstance()->Regist(&mBgW, this);
+    forwardAccel = 0.0f;
+    forwardMaxSpeed = -40.0f;
+    mStateMgr.changeState(StateID_TrapWait);
+    mVec3_c min, max;
+    mMdl.getBounds(&min, &max);
+    static mVec3_c offset = mVec3_c(50.0f, 50.0f, 50.0f);
+    min -= offset;
+    max += offset;
+    boundingBox.Set(min, max);
+
+    return SUCCEEDED;
+}
+
+int dAcOtrapRock1_c::doDelete() {
+    return SUCCEEDED;
+}
+
+int dAcOtrapRock1_c::actorExecute() {
+    mStateMgr.executeState();
+    updateMatrix();
+    mMdl.setLocalMtx(mWorldMtx);
+    mBgW.Move();
+    return SUCCEEDED;
+}
+
+int dAcOtrapRock1_c::draw() {
+    drawModelType1(&mMdl);
+    return SUCCEEDED;
+}
+
 void dAcOtrapRock1_c::initializeState_TrapWait() {}
-void dAcOtrapRock1_c::executeState_TrapWait() {}
+void dAcOtrapRock1_c::executeState_TrapWait() {
+    if (SceneflagManager::sInstance->checkBoolFlag(roomid, mActivationSceneFlag)) {
+        mStateMgr.changeState(StateID_TrapAction);
+    }
+}
 void dAcOtrapRock1_c::finalizeState_TrapWait() {}
-void dAcOtrapRock1_c::initializeState_TrapAction() {}
-void dAcOtrapRock1_c::executeState_TrapAction() {}
+void dAcOtrapRock1_c::initializeState_TrapAction() {
+    mFrameCounter = 0;
+    field_0x59E = 0x2000;
+    field_0x5A0 = 0x2000;
+    field_0x5A5 = 1;
+    field_0x5A2 = 0x2D8;
+    playSound(0xB0E);
+}
+
+void dAcOtrapRock1_c::executeState_TrapAction() {
+    if (SceneflagManager::sInstance->checkBoolFlag(roomid, mReturnSceneFlag)) {
+        mStateMgr.changeState(StateID_TrapReturn);
+    } else if (field_0x59E == 0 || mFrameCounter > 4) {
+        // After 5 frames, move rotation.x to 0x4000, then stay until return
+        bool reachedPoint = sLib::chaseAngle(&rotation.x.mVal, 0x4000, 0x14);
+        if (reachedPoint) {
+            return;
+        }
+    } else {
+        f32 ratio;
+        if (mFrameCounter == 0 && rotation.x < 0x4000) {
+            ratio = 0.1f;
+        } else {
+            f32 b = field_0x5A0;
+            f32 r = (rotation.x - 0x4000) / b;
+            ratio = nw4r::math::FAbs(r);
+        }
+        if (ratio > 1.0f) {
+            ratio = 1.0f;
+        }
+        else if (ratio < 0.1f) {
+            ratio = 0.1f;
+        }
+        s16 newAng = field_0x5A5 * (1.0f - ratio) * field_0x5A2;
+        static const u16 sSomeValue = 0x3C;
+        if (field_0x5A5 > 0) {
+            if ((u16)newAng <= sSomeValue - 1) {
+                newAng = sSomeValue;
+            }
+        } else if ((u16)(newAng + sSomeValue - 1) <= sSomeValue - 1) {
+            newAng = -sSomeValue;
+        }
+
+        rotation.x += (int)newAng;
+        if (field_0x59E > 0 && rotation.x > field_0x59E + 0x4000 ||
+            field_0x59E < 0 && rotation.x < field_0x59E + 0x4000) {
+            rotation.x = field_0x59E + 0x4000;
+            u8 r6 = field_0x5A5;
+            field_0x5A5 = r6 - (r6 * 2);
+            field_0x5A0 = field_0x59E;
+            field_0x59E = field_0x59E - (field_0x59E * 2);
+            if (mFrameCounter >= 1) {
+                field_0x59E = field_0x59E >> 1;
+                field_0x5A2 = field_0x5A2 >> 2;
+            } else {
+                field_0x5A2 = field_0x5A2 * 2 / 3;
+            }
+            mFrameCounter++;
+        }
+    }
+}
 void dAcOtrapRock1_c::finalizeState_TrapAction() {}
 void dAcOtrapRock1_c::initializeState_TrapReturn() {}
-void dAcOtrapRock1_c::executeState_TrapReturn() {}
+void dAcOtrapRock1_c::executeState_TrapReturn() {
+    bool reachedReturnPoint = sLib::chaseAngle(&rotation.x.mVal, 0, 0x222);
+    if (reachedReturnPoint) {
+        mStateMgr.changeState(StateID_TrapWait);
+    }
+}
 void dAcOtrapRock1_c::finalizeState_TrapReturn() {}
@@ -1,16 +1,15 @@
 #include "d/a/obj/d_a_obj_triforce.h"

 #include "c/c_math.h"
-#include "d/col/cc/d_cc_mgr.h"
+#include "d/col/cc/d_cc_s.h"
 #include "m/m_vec.h"

-
 SPECIAL_ACTOR_PROFILE(OBJ_TRIFORCE, dAcOtriforce_c, fProfile::OBJ_TRIFORCE, 0x15D, 0, 4);

 // clang-format off
 dCcD_SrcSph dAcOtriforce_c::sCcSrc = {
-    {{{0}, 0, 0, 0, 0, 0, 0, 0, 0}, 
-    {{0xFEB77DFF}, 0x111, 0x06, 0x407, 0, 0}, 
+    {{0, 0, 0, 0, 0, 0, 0, 0, 0}, 
+    {0xFEB77DFF, 0x111, 0x06, 0x407, 0, 0}, 
    {0xE9}},
    {150.0f}};
 // clang-format on
@@ -36,13 +35,13 @@ int dAcOtriforce_c::create() {
        return FAILED;
    }

-    mCCdStruct.setField0x38ToMagicValue();
-    mCollision.init(sCcSrc);
-    mCollision.initUnk(mCCdStruct);
-    mCollision.clearCoFlag();
+    mStts.SetDefaultRank();
+    mCollision.Set(sCcSrc);
+    mCollision.SetStts(mStts);
+    mCollision.ClrCoSet();
    mStartingOffset = cM::rndInt(sStartingOffsetRange);
    mEffects.init(this);
-    mCollision.setSomeDefendValue(0x2000);
+    mCollision.SetTg_0x4C(0x2000);
    updateMatrix();
    mScale.x = sScale;
    mScale.y = sScale;
@@ -66,7 +65,7 @@ int dAcOtriforce_c::actorExecute() {

    mCollision.SetC(position.x, position.y + 90.0f + zero, position.z);

-    ColliderManager::getColliderManager()->addCollider(&mCollision);
+    dCcS::GetInstance()->Set(&mCollision);
    updateMatrix();
    Mtx m;
    PSMTXScale(m, mScale.x, mScale.y, mScale.z);
@@ -1,13 +1,403 @@
 #include "d/a/obj/d_a_obj_tumble_weed.h"

+#include "c/c_math.h"
+#include "common.h"
+#include "d/a/d_a_player.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_s_gnd_chk.h"
+#include "d/col/c/c_cc_d.h"
+#include "d/col/c/c_m3d_g_pla.h"
+#include "d/col/cc/d_cc_d.h"
+#include "d/col/cc/d_cc_s.h"
+#include "egg/math/eggMath.h"
+#include "egg/math/eggQuat.h"
+#include "f/f_base.h"
+#include "m/m_angle.h"
+#include "m/m_mtx.h"
+#include "m/m_quat.h"
+#include "m/m_vec.h"
+#include "nw4r/math/math_triangular.h"
+#include "rvl/MTX/mtx.h"
+#include "rvl/MTX/vec.h"
+#include "s/s_Math.h"
+#include "toBeSorted/dowsing_target.h"
+
+void float_ordering() {
+    const f32 arr[] = {5.f, 15.f, 7.f, 0.5f, 0.1f};
+}
+
 SPECIAL_ACTOR_PROFILE(OBJ_TUMBLE_WEED, dAcOTumbleWeed_c, fProfile::OBJ_TUMBLE_WEED, 0x243, 0, 2);

 STATE_DEFINE(dAcOTumbleWeed_c, Wait);
 STATE_DEFINE(dAcOTumbleWeed_c, Slope);

-void dAcOTumbleWeed_c::initializeState_Wait() {}
-void dAcOTumbleWeed_c::executeState_Wait() {}
+dCcD_SrcSph dAcOTumbleWeed_c::sSphSrc = {
+  /* mObjInf */
+    {/* mObjAt */ {0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0},
+     /* mObjTg */ {0xFFB77FFF, 0x111, {8, 0x40F}, 0, 0},
+     /* mObjCo */ {0xE9}},
+ /* mSphInf */
+    {60.f},
+};
+
+bool dAcOTumbleWeed_c::createHeap() {
+    mResFile = getOarcResFile("GrassRollDry");
+    TRY_CREATE(mMdl.create(mResFile.GetResMdl("GrassRollDry"), &heap_allocator, 0x120, 1, nullptr));
+    return true;
+}
+
+int dAcOTumbleWeed_c::actorCreate() {
+    CREATE_ALLOCATOR(dAcOTumbleWeed_c);
+
+    mObjAcch.Set(this, 1, &mAcchCir);
+    mAcchCir.SetWall(20.f, 60.f);
+    mObjAcch.OffClrSpeedY();
+    mObjAcch.SetGndThinCellingOff();
+
+    mStts.SetRank(3);
+
+    mSph.Set(sSphSrc);
+    mSph.SetStts(mStts);
+
+    mDowsingTarget.initialize(DowsingTarget::SLOT_TREASURE, 0, nullptr, 0.0f);
+    mDowsingTarget.doRegister();
+
+    forwardAccel = -2.f;
+    forwardMaxSpeed = -40.f;
+
+    mField_0x974 = 0.0f;
+    mField_0x98B = true;
+
+    mWind = mVec3_c::Zero;
+
+    mSpeedTarget = cM::rndFX(2.5f) + 15.f;
+    mField_0x978 = cM::rndF(40.f);
+    mField_0x97C = cM::rndFX(0.25f) + 1.f;
+    mTumbleTimer = (150);
+
+    mField_0x910.set(1.f, 0.f, 0.f, 0.f);
+    mScale.set(1.f, 1.f, 1.f);
+
+    mStateMgr.changeState(StateID_Wait);
+
+    boundingBox.Set(mVec3_c(-50.f, -20.f, -50.f), mVec3_c(50.f, 60.f, 50.f));
+
+    return SUCCEEDED;
+}
+
+int dAcOTumbleWeed_c::actorPostCreate() {
+    return SUCCEEDED;
+}
+
+int dAcOTumbleWeed_c::doDelete() {
+    return SUCCEEDED;
+}
+
+extern "C" void fn_800247D0(void *, mVec3_c, f32);
+extern "C" UNKWORD BLUR_AND_PALETTE_MGR;
+
+int dAcOTumbleWeed_c::actorExecute() {
+    if (!mField_0x98C && !isStopped()) {
+        mField_0x968 = velocity;
+        mField_0x968.y = 0.0f;
+        mField_0x968.normalize();
+        mField_0x98C = true;
+    }
+
+    mStateMgr.executeState();
+    calcWind();
+
+    sLib::chase(&mField_0x980, 1.f, 0.1f);
+    fn_800247D0(&BLUR_AND_PALETTE_MGR, mField_0x968, mField_0x980);
+
+    calcVelocity();
+    position += velocity;
+    position += mStts.GetCcMove();
+
+    mObjAcch.CrrPos(*dBgS::GetInstance());
+    mField_0x974 += position.y - mOldPosition.y;
+    if (checkCollect()) {
+        dAcPy_c::LINK->bugNetCollectTreasure(0xA3 /* TODO(Item Id) ITEM_TUMBLEWEED */);
+        FUN_8002dcd0();
+        return SUCCEEDED;
+    }
+    if (checkBreak()) {
+        doBreak();
+        return SUCCEEDED;
+    }
+
+    if (mSph.ChkTgHit() && mSph.ChkTgAtHitType(AT_TYPE_0x10000 | AT_TYPE_0x200)) {
+        mField_0x974 = 0.f;
+        adjustTumble(mSph.GetTg_0x2C() * 0.06f);
+    }
+    adjustTimeScale();
+
+    // TODO(mObjectActorFlags)
+    if (mObjectActorFlags & 0x2) {
+        // Weak function not being placed right
+        if (sLib::calcTimer(&mTumbleTimer) == 0) {
+            FUN_8002dcd0();
+            return SUCCEEDED;
+        }
+    } else {
+        mTumbleTimer = 150;
+    }
+    mSph.SetC(getPosition());
+    mSph.SetR(mScale.x * 60.f);
+    dCcS::GetInstance()->Set(&mSph);
+    updateMatrix();
+    calcMatrix();
+    playSoundEffect1(0xC2C); // TODO(Sound Id)
+    mMdl.setLocalMtx(mWorldMtx);
+    mMdl.setScale(mScale);
+    mMdl.calc(false);
+
+    return SUCCEEDED;
+}
+
+int dAcOTumbleWeed_c::draw() {
+    drawModelType1(&mMdl);
+
+    static mQuat_c shadowRot(0.f, 30.f, 0.f, 50.f);
+    if (0.f < mScale.x) {
+        drawShadow(mShdw, nullptr, mShadowMtx, &shadowRot, -1, -1, -1, -1, -1, position.y - mObjAcch.GetGroundH());
+    }
+
+    return SUCCEEDED;
+}
+
+void dAcOTumbleWeed_c::initializeState_Wait() {
+    mbOnGround = false;
+}
+
+void dAcOTumbleWeed_c::executeState_Wait() {
+    if (mObjAcch.ChkGroundLanding() && !mbOnGround) {
+        tumbleBounceMaybe();
+        return;
+    }
+
+    if (!mObjAcch.ChkGndHit()) {
+        return;
+    }
+
+    velocity.y = 0.f;
+    mField_0x974 = 0.f;
+    if (checkSlope()) {
+        mStateMgr.changeState(StateID_Slope);
+    } else {
+        adjustSpeed();
+        if (forwardSpeed < 0.1f) {
+            mField_0x98B = false;
+            sLib::chase(&forwardSpeed, 0.f, 0.05f);
+        }
+    }
+}
+
 void dAcOTumbleWeed_c::finalizeState_Wait() {}
+
 void dAcOTumbleWeed_c::initializeState_Slope() {}
-void dAcOTumbleWeed_c::executeState_Slope() {}
+
+void dAcOTumbleWeed_c::executeState_Slope() {
+    if (mObjAcch.ChkGroundLanding() && !mbOnGround) {
+        tumbleBounceMaybe();
+        return;
+    }
+
+    if (!mObjAcch.ChkGndHit()) {
+        return;
+    }
+
+    velocity.y = 0.f;
+    adjustAngle();
+    adjustSpeed();
+    if (!checkSlope()) {
+        mStateMgr.changeState(StateID_Wait);
+    }
+}
+
 void dAcOTumbleWeed_c::finalizeState_Slope() {}
+
+bool dAcOTumbleWeed_c::checkBreak() {
+    if (mObjAcch.ChkWallHit(nullptr) && forwardSpeed > 5.f) {
+        return true;
+    }
+
+    if (mSph.ChkTgHit() && !mSph.ChkTgAtHitType(AT_TYPE_BUGNET)) {
+        return true;
+    }
+
+    if (mObjAcch.ChkGndHit() && mField_0x974 < -300.f) {
+        return true;
+    }
+
+    if (fn_475_E40()) {
+        return true;
+    }
+
+    if (mObjAcch.ChkGndHit() && checkInvalidGround()) {
+        return true;
+    }
+
+    return false;
+}
+
+bool dAcOTumbleWeed_c::fn_475_E40() const {
+    return mField_0x974 < -10000.f;
+}
+
+bool dAcOTumbleWeed_c::checkSlope() {
+    cM3dGPla pla;
+    dBgS::GetInstance()->GetTriPla(mObjAcch.mGnd, &pla);
+
+    mAng ang = mAng::angle(mVec3_c::Ey, pla.GetN());
+    return sLib::absDiff(ang, 0) > mAng::deg2short(1);
+}
+
+bool dAcOTumbleWeed_c::checkCollect() {
+    return mSph.ChkTgHit() && mSph.ChkTgAtHitType(AT_TYPE_BUGNET) ? true : false;
+}
+
+bool dAcOTumbleWeed_c::checkInvalidGround() const {
+    u32 code = dBgS::GetInstance()->GetSpecialCode(mObjAcch.mGnd);
+
+    return code == POLY_ATTR_LAVA || code == POLY_ATTR_SAND_MED || code == POLY_ATTR_SAND_DEEP_INSTANT ||
+           code == POLY_ATTR_SAND_DEEP_SLOW;
+}
+
+extern "C" u16 PARTICLE_RESOURCE_ID_MAPPING_743_;
+extern "C" void fn_800298B0(u16, mVec3_c *, mAng3_c *, u32, u32, u32, u32, u32);
+
+void dAcOTumbleWeed_c::doBreak() {
+    playSound(0xC2D); // TODO(Sound Id)
+    mVec3_c pos = getPosition();
+    fn_800298B0(PARTICLE_RESOURCE_ID_MAPPING_743_, &pos, nullptr, 0, 0, 0, 0, 0);
+    deleteRequest();
+}
+
+void dAcOTumbleWeed_c::calcMatrix() {
+    if (mField_0x98B) {
+        f32 vel_mag = PSVECMag(velocity);
+        f32 f1 = mAng(vel_mag * (mField_0x978 + 200.f)).radian();
+        f32 f2 = mAng(vel_mag * 182.0f * 0.2f).radian();
+        f32 f0 = mAng(angle.y - rotation.y).radian();
+
+        mQuat_c q0, q1, q2, q3;
+        q1.setAxisRotation(mVec3_c::Ey, f0);
+        q0.setAxisRotation(mVec3_c::Ey, -f0);
+        q3.setAxisRotation(mVec3_c::Ex, f1);
+        q2.setAxisRotation(mVec3_c::Ey, f2);
+
+        mField_0x910 = q1 * q3 * q2 * q0 * mField_0x910;
+    }
+
+    mMtx_c mtx0, mtx1, mtx2;
+    mShadowMtx.copyFrom(mWorldMtx);
+    mtx1.trans(getPosition() - position);
+    mShadowMtx += mtx1;
+    mtx0.fromQuat(mField_0x910);
+    mtx2.trans(0.f, 40.f, 0.f);
+    mWorldMtx += mtx2;
+    mWorldMtx += mtx0;
+}
+
+void dAcOTumbleWeed_c::adjustAngle() {
+    cM3dGPla pla;
+    dBgS::GetInstance()->GetTriPla(mObjAcch.mGnd, &pla);
+    mVec3_c vel = velocity; // ok?
+    angle.y = mAng::fromVec(velocity);
+}
+
+void dAcOTumbleWeed_c::adjustSpeed() {
+    cM3dGPla pla;
+
+    // BUG
+    // the ground angle calculation happens before retrieving the grounds normal
+    // this is probably hard to notice due to the little effect it has.
+    // Effect:
+    //  Tumbleweed slows to the target much quicker than intended
+    //  Tumbleweed speeds to the target + 5.0f much quicker than intended
+    mAng gndAngle = mAng::angle(mVec3_c::Ey, pla.GetN());
+
+    dBgS::GetInstance()->GetTriPla(mObjAcch.mGnd, &pla);
+
+    f32 speedStep = 0.5f;
+    f32 step = gndAngle.cos() * speedStep;
+
+    // Flat Ground or not in the direction of the slope
+    //  Slows down
+    if (gndAngle < mAng::deg2short(1) ||
+        sLib::absDiff(cM::atan2s(pla.GetN().x, pla.GetN().z), GetAngle().y) > mAng::deg2short(90)) {
+        sLib::chase(&forwardSpeed, mSpeedTarget, step);
+    }
+    // Sloped Ground and in the direction of the slope
+    //  Speeds up
+    else {
+        forwardSpeed = cM::minMaxLimit(forwardSpeed + step, mSpeedTarget, mSpeedTarget + 5.0f);
+    }
+}
+
+void dAcOTumbleWeed_c::tumbleBounceMaybe() {
+    velocity.y *= -0.75f;
+    forwardSpeed *= 0.9f;
+
+    if (forwardSpeed < 15.f) {
+        forwardSpeed = mSpeedTarget;
+    }
+
+    mbOnGround = false;
+    if (velocity.y < 5.f) {
+        velocity.y = 0.f;
+        mbOnGround = true;
+    }
+}
+
+void dAcOTumbleWeed_c::adjustTimeScale() {
+    mTimeArea.check(getRoomId(), GetPostion(), 0, 30.f, 0.1f);
+    if (0.f < mTimeArea.getDistMaybe()) {
+        sLib::chase(&mScale.y, 0.f, 0.07f);
+        mScale.z = mScale.y;
+        mScale.x = mScale.y;
+    } else {
+        sLib::chase(&mScale.y, 1.f, 0.07f);
+        mScale.z = mScale.y;
+        mScale.x = mScale.y;
+    }
+}
+
+void dAcOTumbleWeed_c::adjustTumble(const mVec3_c &dir) {
+    mField_0x98B = true;
+
+    velocity.x += dir.x;
+    velocity.z += dir.z;
+
+    forwardSpeed = mField_0x97C * EGG::Math<f32>::sqrt(velocity.x * velocity.x + velocity.z * velocity.z);
+    angle.y = mAng::fromVec(dir);
+}
+
+void dAcOTumbleWeed_c::setWind(const mVec3_c &wind) {
+    mWind = wind;
+    mWindTimer = cM::rndInt(10);
+}
+
+void dAcOTumbleWeed_c::calcWind() {
+    if (!isWindStop() && sLib::calcTimer(&mWindTimer) == 0) {
+        velocity.y = cM::rndFX(3.0f) + 15.f;
+        forwardSpeed = cM::rndFX(5.0f) + 15.f;
+
+        mWind = mVec3_c::Zero;
+        mField_0x980 = 0.f;
+    }
+}
+
+mVec3_c dAcOTumbleWeed_c::getPosition() const {
+    mMtx_c mtx;
+    mVec3_c vec;
+    mtx.ZXYrotS(rotation.x, rotation.y, rotation.z);
+    PSMTXMultVecSR(mtx, mVec3_c::Ey, vec);
+    return position + vec * 40.f;
+}
+
+void float_ordering2() {
+    const f32 arr[] = {30.f, 0.07f, 20.f, -10000.f, 5.f};
+}
@@ -1,13 +1,12 @@
 #include "d/t/d_t_gekotag.h"

-#include "c/c_math.h"
 #include "common.h"
 #include "d/a/d_a_player.h"
 #include "d/a/e/d_a_e_geko.h"
 #include "d/a/obj/d_a_obj_base.h"
-#include "f/f_base.h"
 #include "f/f_profile_name.h"
 #include "m/m_angle.h"
+#include "s/s_Math.h"

 #pragma explicit_zero_data on
 static u32 initialRotX = 0;
@@ -60,8 +59,8 @@ void dTgGekoTag::executeState_Wait() {
 void dTgGekoTag::finalizeState_Wait() {}

 void dTgGekoTag::doExecute() {
-    cM::calcTimer(&mTimer2);
-    if (cM::calcTimer(&mTimer1) != 0) {
+    sLib::calcTimer(&mTimer2);
+    if (sLib::calcTimer(&mTimer1) != 0) {
        return;
    }

@@ -4,10 +4,9 @@
 #include "c/c_math.h"
 #include "d/a/d_a_player.h"
 #include "d/a/obj/d_a_obj_item.h"
-#include "d/col/cc/d_cc_mgr.h"
+#include "d/col/cc/d_cc_s.h"
 #include "d/flag/sceneflag_manager.h"

-
 SPECIAL_ACTOR_PROFILE(TAG_REACTION, dTgReaction_c, fProfile::TAG_REACTION, 0x0151, 0, 0);

 STATE_DEFINE(dTgReaction_c, Wait);
@@ -19,8 +18,8 @@ const f32 dTgReaction_c::sHeight = 100.0f;

 // clang-format off
 dCcD_SrcCyl dTgReaction_c::sCcSrc = {
-    {{{0}, 0, 0, 0, 0, 0, 0, 0, 0}, 
-    {{0x10000}, 0x213, 0, 0x8, 0x8, 0}, 
+    {{0, 0, 0, 0, 0, 0, 0, 0, 0}, 
+    {0x10000, 0x213, 0, 0x8, 0x8,}, 
    {0xE8}},
    {dTgReaction_c::sRadius, dTgReaction_c::sHeight}
 };
@@ -43,7 +42,7 @@ int dTgReaction_c::create() {
        return FAILED;
    }

-    if (getReactType() != REACT_GUST_BELLOWS) {
+    if (getReactType() != REACT_UNDERWATER) {
        if (getSceneFlag() >= 0xFF) {
            return FAILED;
        }
@@ -74,29 +73,31 @@ int dTgReaction_c::create() {
        }
    }

-    mCCdStruct.setField0x38(0);
-    mCollision.init(sCcSrc);
-    mCollision.initUnk(mCCdStruct);
+    mStts.SetRank(0);
+    mCollision.Set(sCcSrc);
+    mCollision.SetStts(mStts);

    switch (getReactType()) {
-        case REACT_BONK:
-            mCollision.setTgFlag(0x80);
-            mCollision.setTgField0x0A(0);
-            mCollision.SetR(sCcSrc.mCylAttr.mRadius * mScale.x);
-            mCollision.SetH(mScale.y * sCcSrc.mCylAttr.mHeight);
-            break;
        case REACT_SLINGSHOT:
-            mCollision.setTgFlag(0x10000);
-            mCollision.setTgField0x0A(8);
-            mCollision.SetR(sCcSrc.mCylAttr.mRadius * mScale.x);
-            mCollision.SetH(mScale.y * sCcSrc.mCylAttr.mHeight);
+            mCollision.SetTgFlag(0x80);
+            mCollision.SetTgFlag_0xA(0);
+            mCollision.SetR(sCcSrc.mCylInf.mRadius * mScale.x);
+            mCollision.SetH(sCcSrc.mCylInf.mHeight * mScale.y);
            break;
        case REACT_GUST_BELLOWS:
-            mCollision.setTgFlag(0x100000);
-            mCollision.setTgField0x0A(0);
-            mCollision.SetR(sCcSrc.mCylAttr.mRadius * mScale.x);
-            mCollision.SetH(mScale.y * sCcSrc.mCylAttr.mHeight);
+            mCollision.SetTgFlag(0x10000);
+            mCollision.SetTgFlag_0xA(8);
+            mCollision.SetR(sCcSrc.mCylInf.mRadius * mScale.x);
+            mCollision.SetH(sCcSrc.mCylInf.mHeight * mScale.y);
            break;
+        case REACT_UNDERWATER:
+            mCollision.SetTgFlag(0x100000);
+            mCollision.SetTgFlag_0xA(0);
+            mCollision.SetR(sCcSrc.mCylInf.mRadius * mScale.x);
+            mCollision.SetH(sCcSrc.mCylInf.mHeight * mScale.y);
+            break;
+        case REACT_BONK:
+        case REACT_4:    break;
    }

    int item = getParam0x10();
@@ -111,8 +112,8 @@ int dTgReaction_c::create() {
        }
        mVec3_c dwsOffset;
        if (!getParam0x14()) {
-            field_0x4E4 = mScale.y * sCcSrc.mCylAttr.mHeight * 0.5f;
-            dwsOffset = mVec3_c(0.0f, 0.5f * sCcSrc.mCylAttr.mHeight, 0.0f);
+            field_0x4E4 = mScale.y * sCcSrc.mCylInf.mHeight * 0.5f;
+            dwsOffset = mVec3_c(0.0f, sCcSrc.mCylInf.mHeight * 0.5f, 0.0f);
        } else {
            dwsOffset = mVec3_c::Zero;
        }
@@ -210,34 +211,27 @@ void dTgReaction_c::checkForBonkItem() {
 }

 void dTgReaction_c::checkForBubble() {
-    if (mCollision.someInteractCheck() && mCollision.CheckCollidedMask(0x100000)) {
+    if (mCollision.ChkTgHit() && mCollision.ChkTgAtHitType(0x100000)) {
        if (dAcPy_c::LINK != nullptr && dAcPy_c::LINK->checkFlags0x350(0x40)) {
            mVec3_c spawnPos = position;
            dAcObjBase_c::create(fProfile::OBJ_BUBBLE, roomid, 0x4, &spawnPos, nullptr, nullptr, 0xFFFFFFFF);
        }
    }
    mCollision.SetC(position);
-    ColliderManager::getColliderManager()->addCollider(&mCollision);
-}
-
-// TODO move this somewhere
-template <typename T>
-T rndRange(T min, T max) {
-    f32 r = cM::rndF(max - min);
-    f32 m = min;
-    m += r;
-    return m;
+    dCcS::GetInstance()->Set(&mCollision);
 }

 void dTgReaction_c::checkForSlingBellowsItem() {
-    if (mCollision.someInteractCheck()) {
+    if (mCollision.ChkTgHit()) {
+        u8 p = getParam0x08();
        u32 uVar3;
-        // mVec3_c pos = position;
-        int p = getParam0x08();
        if (p == 0) {
            uVar3 = 6;
        } else {
-            uVar3 = p == 0xFF ? 5 : 6;
+            uVar3 = 6;
+            if ((int)p == 0xFF) {
+                uVar3 = 5;
+            }
        }
        mVec3_c spawnPos = position;
        spawnPos.y += field_0x4E4;
@@ -248,7 +242,7 @@ void dTgReaction_c::checkForSlingBellowsItem() {
        onDelete();
    }
    mCollision.SetC(position);
-    ColliderManager::getColliderManager()->addCollider(&mCollision);
+    dCcS::GetInstance()->Set(&mCollision);
 }

 void dTgReaction_c::onDelete() {
@@ -285,9 +279,7 @@ bool dTgReaction_c::spawnHearts(s32 params, const mVec3_c &pos, s32 arg, mAng an
    tmp2 = mAng(tmp2 / 2);

    for (int i = 0; i < numHearts; i++) {
-        // Note: This is a (presumably templated) rndRange function
-        // that takes and returns a struct mAng
-        mAng offset = rndRange(-tmp2, tmp2);
+        mAng offset = cM::rndRange(-tmp2, tmp2);
        ang.y = mAng(step) + offset;
        if (arg == 5) {
            dAcItem_c::spawnItem(/* HEART */ 0x6, roomid, pos, ang, 0xFFFFFFFF, 1);
@@ -149,7 +149,7 @@ bool dTgSndAr_c::checkAlg3(const mVec3_c &pos) {

    unk.Set(b, c, mScale.x * 100.0f);
    f32 d;
-    if (cM3d_Len3dSqPntAndSegLine(&unk, &a, &q, &d, nullptr)) {
+    if (cM3d_Len3dSqPntAndSegLine(unk, a, q, &d, nullptr)) {
        // At the cylindrical part of the capsule, just check the distance to
        // the line
        return d < radius;
@@ -1,9 +1,9 @@
 #include "d/t/d_t_touch.h"

 #include "c/c_math.h"
-#include "toBeSorted/area_math.h"
 #include "d/flag/sceneflag_manager.h"
-
+#include "s/s_Math.h"
+#include "toBeSorted/area_math.h"

 SPECIAL_ACTOR_PROFILE(TOUCH_TAG, dTgTouchTag, fProfile::TOUCH_TAG, 0x028E, 0, 0);

@@ -59,7 +59,7 @@ void dTgTouchTag::executeState_Wait() {
        actor = static_cast<dAcBase_c *>(fManager_c::searchBaseByProfName(ACTIVATORS[mActivatorIndex], actor));
    }

-    if (cM::calcTimer(&mFlagTimer) == 0) {
+    if (sLib::calcTimer(&mFlagTimer) == 0) {
        if (mZoneFlag != 0xFF && SceneflagManager::sInstance->checkBoolFlag(roomid, mZoneFlag)) {
            SceneflagManager::sInstance->unsetFlag(roomid, mZoneFlag);
        }
@@ -1,7 +1,7 @@
 #include "d/t/d_t_tumble_weed.h"

-#include "c/c_math.h"
 #include "m/m_vec.h"
+#include "s/s_Math.h"


 SPECIAL_ACTOR_PROFILE(TUMBLE_WEED_TAG, dTgTumbleWeed_c, fProfile::TUMBLE_WEED_TAG, 0x0244, 0, 0);
@@ -17,32 +17,23 @@ int dTgTumbleWeed_c::create() {
    return SUCCEEDED;
 }

-u16 decr(u16 *num);
-
 int dTgTumbleWeed_c::doDelete() {
    return SUCCEEDED;
 }

 int dTgTumbleWeed_c::actorExecute() {
    mStateMgr.executeState();
-    decr(&tumbleweedTimer);
+    sLib::calcTimer(&tumbleweedTimer);
    return SUCCEEDED;
 }

-u16 decr(u16 *num) {
-    if (*num != 0) {
-        (*num)--;
-    }
-    return *num;
-}
-
 int dTgTumbleWeed_c::draw() {
    return SUCCEEDED;
 }

 void dTgTumbleWeed_c::initializeState_AreaOut() {}
 void dTgTumbleWeed_c::executeState_AreaOut() {
-    if (decr(&windTimer) == 0) {
+    if (sLib::calcTimer(&windTimer) == 0) {
        windTimer = 0x96;
        if (shouldDoWind()) {
            mStateMgr.changeState(StateID_Wind);
@@ -63,7 +54,7 @@ void dTgTumbleWeed_c::executeState_AreaIn() {
        }
        tumbleweedTimer = 600;
    }
-    if (decr(&windTimer) == 0) {
+    if (sLib::calcTimer(&windTimer) == 0) {
        windTimer = 0x96;
        if (shouldDoWind()) {
            mStateMgr.changeState(StateID_Wind);
@@ -76,12 +67,11 @@ void dTgTumbleWeed_c::executeState_AreaIn() {
 }
 void dTgTumbleWeed_c::finalizeState_AreaIn() {}

-extern "C" void fn_475_1B00(fBase_c *, mVec3_c &);
 void dTgTumbleWeed_c::initializeState_Wind() {
    mVec3_c vec;
    getWind(&vec);
    if (childTumbleweed.get() != nullptr) {
-        fn_475_1B00(childTumbleweed.get(), vec);
+        childTumbleweed.get()->setWind(vec);
    }
 }

@@ -243,9 +243,8 @@ u32 dAcBase_c::itemDroppingAndGivingRelated(mVec3_c *spawnPos, int subtype) {
    u32 param2Copy = params2;
    params2 = param2Copy | 0xFF000000;
    // mAng3_c rot = {};
-    s16 rot = 0;
-    return SpecialItemDropMgr::giveSpecialDropItem(
-        SpecialItemDropMgr::sInstance, param2Copy >> 0x18, roomid, spawnPos, subtype, &rot, -1
+    return SpecialItemDropMgr::sInstance->giveSpecialDropItem(
+        param2Copy >> 0x18, roomid, spawnPos, subtype, 0, -1
    );
 }

@@ -424,7 +423,7 @@ f32 dAcBase_c::getSquareDistToPlayer() {
 // Some weirdness with the float registers being used
 // 8002d4b0
 void dAcBase_c::updateRoomId(f32 yOffset) {
-    if (getConnectParent()->profile_name != 701 /* fProfile::PROFILE_NAME_e::ROOM */) {
+    if (getConnectParent()->profile_name != fProfile::ROOM) {
        mVec3_c actorPos(position.x, position.y + yOffset, position.z);

        if (checkCollision(&actorPos)) {
@@ -0,0 +1,131 @@
+#include "d/a/obj/d_a_obj_arrow.h"
+
+#include "c/c_math.h"
+#include "d/a/d_a_player.h"
+#include "d/col/c/c_cc_d.h"
+
+SPECIAL_ACTOR_PROFILE(ARROW, dAcArrow_c, fProfile::ARROW, 0x126, 0, 0x80);
+
+STATE_DEFINE(dAcArrow_c, Wait);
+STATE_DEFINE(dAcArrow_c, Move);
+STATE_DEFINE(dAcArrow_c, ActorStop);
+STATE_DEFINE(dAcArrow_c, BgStop);
+STATE_DEFINE(dAcArrow_c, Bound);
+
+// clang-format off
+
+cCcD_SrcGObj dAcArrow_c::sCcSrcInf = {
+
+    {0x2000, 0x8BB, 0x15000000, 0, 0, 0, 0, 0, 0}, 
+    {0xFEB75C7F, 0x210,  0, 0x407, 0, 0}, 
+    {0},
+};
+
+dCcD_SrcCps dAcArrow_c::sCc1 = {
+    dAcArrow_c::sCcSrcInf,
+    {5.0f},
+};
+
+const dCcD_SrcSph dAcArrow_c::sCc2 = {
+    {{0x0, 0x0, 0x0, 0, 0, 0, 0, 0, 0}, 
+    {0x2, 0x211, 0, 0x407, 0, 0}, 
+    {0xC28}},
+    {100.0f},
+};
+
+// clang-format on
+
+bool hitCallback(dAcObjBase_c *i_actorA, cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB) {
+    static_cast<dAcArrow_c *>(i_actorA)->hitCallback(i_objInfA, i_actorB, i_objInfB);
+    return true;
+}
+
+bool dAcArrow_c::createHeap() {
+    mResFile = getOarcResFile("Alink");
+    nw4r::g3d::ResMdl mdl(nullptr);
+    if ((mSubType & 0x10) != 0) {
+        mdl = mResFile.GetResMdl("EquipPachinkoBullet");
+    } else {
+        mdl = mResFile.GetResMdl("EquipArrow");
+    }
+    // ?
+    bool ok = mModel.create(mdl, &heap_allocator, 0x120);
+    if (!ok) {
+        ok = false;
+    }
+    return ok;
+}
+
+extern "C" void fn_8025E5E0(void *);
+
+int dAcArrow_c::create() {
+    mSubType = params & 0xFF;
+    CREATE_ALLOCATOR(dAcArrow_c);
+
+    field_0x67C |= 4;
+    mStts.SetRank(2);
+    mCcCps.Set(sCc1);
+    mCcCps.SetStts(mStts);
+    mCcCps.SetAtFlag(0x2000);
+    mCcCps.SetAtCallback(::hitCallback);
+    mCcSph.Set(sCc2);
+    mCcSph.SetStts(mStts);
+
+    if (mSubType == 0x11) {
+        mStateMgr.changeState(StateID_Move);
+    } else {
+        mStateMgr.changeState(StateID_Wait);
+    }
+
+    boundingBox.Set(mVec3_c(-6.0f, -6.0f, 0.0f), mVec3_c(6.0f, 6.0f, 110.0f));
+    field_0x684 = -1;
+    field_0x68A = 300;
+    f32 rnd = cM::rndF(20.0f);
+    field_0x688 = 50.0f - rnd;
+    field_0x6A8 = 80.0f;
+    mDespawnTimer = 10;
+    fn_8025E5E0(this);
+    return SUCCEEDED;
+}
+
+dAcArrow_c::~dAcArrow_c() {}
+
+void dAcArrow_c::hitCallback(cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB) {}
+
+int dAcArrow_c::doDelete() {
+    // TODO
+
+    return SUCCEEDED;
+}
+
+int dAcArrow_c::actorExecute() {
+    mStateMgr.executeState();
+
+    // TODO
+
+    return SUCCEEDED;
+}
+
+int dAcArrow_c::draw() {
+    return SUCCEEDED;
+}
+
+void dAcArrow_c::initializeState_Wait() {}
+void dAcArrow_c::executeState_Wait() {}
+void dAcArrow_c::finalizeState_Wait() {}
+
+void dAcArrow_c::initializeState_Move() {}
+void dAcArrow_c::executeState_Move() {}
+void dAcArrow_c::finalizeState_Move() {}
+
+void dAcArrow_c::initializeState_ActorStop() {}
+void dAcArrow_c::executeState_ActorStop() {}
+void dAcArrow_c::finalizeState_ActorStop() {}
+
+void dAcArrow_c::initializeState_BgStop() {}
+void dAcArrow_c::executeState_BgStop() {}
+void dAcArrow_c::finalizeState_BgStop() {}
+
+void dAcArrow_c::initializeState_Bound() {}
+void dAcArrow_c::executeState_Bound() {}
+void dAcArrow_c::finalizeState_Bound() {}
@@ -0,0 +1,20 @@
+#include "d/a/obj/d_a_obj_bomb.h"
+
+#include "f/f_base.h"
+#include "f/f_profile.h"
+#include "f/f_profile_name.h"
+#include "s/s_State.hpp"
+
+SPECIAL_ACTOR_PROFILE(BOMB, dAcBomb_c, fProfile::BOMB, 0x128, 0, 2);
+
+STATE_DEFINE(dAcBomb_c, Wait);
+STATE_DEFINE(dAcBomb_c, FlowerWait);
+STATE_DEFINE(dAcBomb_c, Explode);
+STATE_DEFINE(dAcBomb_c, Carry);
+STATE_DEFINE(dAcBomb_c, WindCarry);
+
+bool dAcBomb_c::createHeap() {}
+
+int dAcBomb_c::create() {
+    return SUCCEEDED;
+}
@@ -2,7 +2,6 @@

 #include "d/a/d_a_player.h"

-
 SPECIAL_ACTOR_PROFILE(OBJ_FAIRY, dAcObjFairy_c, fProfile::OBJ_FAIRY, 0x166, 0, 2);

 STATE_DEFINE(dAcObjFairy_c, Wait);
@@ -53,7 +52,8 @@ int dAcObjFairy_c::draw() {

        if (!isCuring()) {
            static mQuat_c rot(0.0f, 0.0f, 0.0f, 10.0f);
-            drawShadow(mShadow, nullptr, mWorldMtx, &rot, -1, -1, -1, -1, -1, position.y - field_0x4B0);
+            f32 f = field_0x4B0;
+            drawShadow(mShadow, nullptr, mWorldMtx, &rot, -1, -1, -1, -1, -1, position.y - f);
        }
    }

@@ -96,14 +96,13 @@ void dAcObjFairy_c::executeState_CatchDemo() {
 }
 void dAcObjFairy_c::finalizeState_CatchDemo() {
    field_0xB89 = 0;
-    // TODO collision
+    mObjectActorFlags &= ~0x00000200;
 }

 bool dAcObjFairy_c::shouldAvoidLink() const {
    // TODO shuffles
    if (dAcPy_c::LINK->isUsingBugnet()) {
-        const mVec3_c &bugNetPos = dAcPy_c::LINK->getBugNetPos();
-        const mVec3_c dist = bugNetPos - position;
+        mVec3_c dist = dAcPy_c::LINK->getBugNetPos() - position;
        bool isClose = false;
        if (dist.mag() < 100.0f && velocity.dot(dist) > 0.0f) {
            isClose = true;
@@ -1,12 +1,11 @@
 #include "d/a/obj/d_a_obj_switch.h"

-#include "c/c_math.h"
 #include "d/a/d_a_player.h"
 #include "d/col/bg/d_bg_s.h"
 #include "d/col/bg/d_bg_w.h"
+#include "d/flag/sceneflag_manager.h"
 #include "nw4r/g3d/g3d_resfile.h"
 #include "s/s_Math.h"
-#include "d/flag/sceneflag_manager.h"

 SPECIAL_ACTOR_PROFILE(OBJ_SW, dAcOsw_c, fProfile::OBJ_SW, 0x12B, 0, 0x1002);

@@ -68,13 +67,13 @@ bool dAcOsw_c::createHeap() {
    nw4r::g3d::ResMdl resMdl = resFile.GetResMdl(SWITCH_TYPES[mSwitchType]);
    TRY_CREATE(mModel.create(resMdl, &heap_allocator, 0x20, 1, nullptr));

-    field_0x5E8 = mScale.x *
-                  (resMdl.GetResNode("base").mNode.ref().VEC3_0x50.x - resMdl.GetResNode("base").mNode.ref().VEC3_0x44.x);
+    field_0x5E8 = mScale.x * (resMdl.GetResNode("base").mNode.ref().VEC3_0x50.x -
+                              resMdl.GetResNode("base").mNode.ref().VEC3_0x44.x);
    cBgD_t *dbzData = (cBgD_t *)getOarcDZB(SWITCH_TYPES[mSwitchType], SWITCH_TYPES[mSwitchType]);
    PLC *plcData = (PLC *)getOarcPLC(SWITCH_TYPES[mSwitchType], SWITCH_TYPES[mSwitchType]);
    mScale.set(1.0f, 0.8f, 1.0f);
    updateMatrix();
-    field_0x5B8.set(mWorldMtx);
+    field_0x5B8.copyFrom(mWorldMtx);
    mModel.setLocalMtx(mWorldMtx);

    bool set = mCollision.Set(dbzData, plcData, cBgW::MOVE_BG_e, &field_0x5B8, &mScale);
@@ -180,7 +179,7 @@ int dAcOsw_c::actorExecute() {
    }

    updateMatrix();
-    field_0x5B8.set(mWorldMtx);
+    field_0x5B8.copyFrom(mWorldMtx);
    mMtx_c tmp;
    PSMTXTrans(tmp, 0.0f, mButtonCtrl.mElevation, 0.0f);
    PSMTXConcat(field_0x5B8, tmp, field_0x5B8);
@@ -269,7 +268,7 @@ void dAcOsw_c::executeState_OffWait() {
    if (field_0x5F1 != 0) {
        field_0x5F3 = 1;
    }
-    if (mSwitchType != 1 && cM::calcTimer(&field_0x5EC) == 0 && field_0x5F3 == 0) {
+    if (mSwitchType != 1 && sLib::calcTimer(&field_0x5EC) == 0 && field_0x5F3 == 0) {
        mStateMgr.changeState(StateID_Off);
    }
 }
@@ -492,8 +492,8 @@ void cBgW::RwgLineCheck(int polyIdx, cBgS_LinChk *pLine) {
        cBgD_Vtx_t *vtxTbl = mpVtxTbl;
        mVec3_c cross_pos;
        if (cM3d_Cross_LinTri(
-                &pLine->mLin, &vtxTbl[triTbl[polyIdx].mVtxIdx0], &vtxTbl[triTbl[polyIdx].mVtxIdx1],
-                &vtxTbl[triTbl[polyIdx].mVtxIdx2], &mpTri[polyIdx], &cross_pos, pLine->ChkFrontFlag(),
+                pLine->mLin, vtxTbl[triTbl[polyIdx].mVtxIdx0], vtxTbl[triTbl[polyIdx].mVtxIdx1],
+                vtxTbl[triTbl[polyIdx].mVtxIdx2], &mpTri[polyIdx], cross_pos, pLine->ChkFrontFlag(),
                pLine->ChkBackFlag()
            )) {
            dBgPc pc = *mpPolyCodes.GetDBgPc(mpBgd->mTriTbl[polyIdx].mId);
@@ -101,7 +101,7 @@ bool dBgWTime::LineCheck(cBgS_LinChk *pLine) {
    lin.Set(linStart, linEnd);
    mVec3_c vec0;
    mVec3_c vec1;
-    if (!cM3d_Cross_CylLin(&mCyl, &lin, vec0, vec1)) {
+    if (!cM3d_Cross_CylLin(mCyl, lin, vec0, vec1)) {
        return false;
    }
    if (!fn_803537a0(&vec0, pLine)) {
@@ -14,6 +14,7 @@
 #include "math.h"
 #include "nw4r/math/math_types.h"
 #include "rvl/MTX.h" // IWYU pragma: export
+#include "rvl/MTX/vec.h"

 using namespace nw4r::math;
 using namespace EGG;
@@ -145,38 +146,40 @@ bool cM3d_Cross_LinSph_CrossPos(const cM3dGSph &, const cM3dGLin &, VEC3 *, VEC3
    // TODO - returns false to satisfy warning
    return false;
 }
-bool cM3d_Cross_CylSph(const cM3dGCyl *, const cM3dGSph *, f32 *) {
+bool cM3d_Cross_CylSph(const cM3dGCyl &, const cM3dGSph &, f32 *) {
    // TODO - returns false to satisfy warning
    return false;
 }
-bool cM3d_Cross_CylSph(const cM3dGCyl *, const cM3dGSph *, VEC3 *, f32 *) {
+bool cM3d_Cross_CylSph(const cM3dGCyl &, const cM3dGSph &, VEC3 *, f32 *) {
    // TODO - returns false to satisfy warning
    return false;
 }
-bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, f32 *) {
+bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, f32 *) {
    // TODO - returns false to satisfy warning
    return false;
 }
-bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, f32 *, f32 *) {
+bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, f32 *, f32 *) {
    // TODO - returns false to satisfy warning
    return false;
 }
-bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, VEC3 *) {
+bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, VEC3 *) {
    // TODO - returns false to satisfy warning
    return false;
 }

-void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph *pSph, const cM3dGTri *pTri, VEC3 *pPnt) {
+void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph &pSph, const cM3dGTri &pTri, VEC3 *pPnt) {
    VEC3 scale, add;
-    PSVECAdd(pTri->mA, pTri->mB, add);
+    PSVECAdd(pTri.mA, pTri.mB, add);
    PSVECScale(add, scale, 0.5f);
-    f32 mag = VEC3DistSq(&scale, &pSph->GetC());
+    const f32 mag = VEC3DistSq(&scale, &pSph.GetC());
    if (cM3d_IsZero(mag)) {
-        *pPnt = pSph->GetC();
+        *pPnt = pSph.GetC();
        return;
    }
-    f32 a = pSph->GetR() / mag;
-    cM3d_InDivPos2(&pSph->GetC(), &scale, a, pPnt);
+    const f32 rad = pSph.GetR();
+    f32 a = rad / mag;
+
+    cM3d_InDivPos2(&pSph.GetC(), &scale, a, pPnt);
 }
 bool cM3d_Cross_SphTri(const cM3dGSph *, const cM3dGTri *, VEC3 *, f32 *, VEC3 *) {
    // TODO - returns false to satisfy warning
@@ -218,7 +221,7 @@ bool cM3d_Cross_TriTri(const cM3dGTri &, const cM3dGTri &, VEC3 *) {
    // TODO - returns false to satisfy warning
    return false;
 }
-bool cM3d_Cross_CpsTri(const cM3dGCps &, cM3dGTri, VEC3 *) {
+bool cM3d_Cross_CpsTri(const cM3dGCps &, const cM3dGTri &, VEC3 *) {
    // TODO - returns false to satisfy warning
    return false;
 }
@@ -232,7 +235,7 @@ bool cM3d_3PlaneCrossPos(const cM3dGPla &, const cM3dGPla &, const cM3dGPla &, V
    // TODO - returns false to satisfy warning
    return false;
 }
-f32 cM3d_lineVsPosSuisenCross(const cM3dGLin *, const VEC3 *, VEC3 *) {
+f32 cM3d_lineVsPosSuisenCross(const cM3dGLin &, const VEC3 &, VEC3 *) {
    // TODO - returns 0.0f to satisfy warning
    return 0.0f;
 }
@@ -240,3 +243,23 @@ f32 cM3d_lineVsPosSuisenCross(const VEC3 &, const VEC3 &, const VEC3 &, VEC3 *)
    // TODO - returns 0.0f to satisfy warning
    return 0.0f;
 }
+
+bool cM3d_Normalize(nw4r::math::VEC3 *pPnt) {
+    f32 mag = PSVECMag(*pPnt);
+    if (cM3d_IsZero(mag)) {
+        return true;
+    }
+    mag = 1.f / mag;
+    pPnt->x *= mag;
+    pPnt->y *= mag;
+    pPnt->z *= mag;
+    return false;
+}
+
+void cM3d_Normalize_Ex(nw4r::math::VEC3 *pPnt) {
+    if (cM3d_Normalize(pPnt)) {
+        pPnt->x = 1.0f;
+        pPnt->y = 0.0f;
+        pPnt->z = 0.0f;
+    }
+}
@@ -26,8 +26,8 @@ void cM3dGCps::Set(const mVec3_c &start, const mVec3_c &end, f32 r) {
    SetR(r);
 }

-bool cM3dGCps::fn_80337f30(cM3dGUnk *unk, mVec3_c *vec) {
-    return fn_80336d90(this, unk, vec);
+bool cM3dGCps::Cross(cM3dGUnk &unk, mVec3_c *vec) {
+    return cM3d_Cross_CpsUnk(*this, unk, vec);
 }

 bool cM3dGCps::fn_80337f40(const mVec3_c &v) const {
@@ -40,7 +40,7 @@ bool cM3dGCps::fn_80337f40(const mVec3_c &v) const {
    }
    f32 tmp;
    mVec3_c tmpv;
-    if (cM3d_Len3dSqPntAndSegLine(this, v, tmpv, &tmp, nullptr) && tmp <= r2) {
+    if (cM3d_Len3dSqPntAndSegLine(*this, v, tmpv, &tmp, nullptr) && tmp <= r2) {
        return true;
    }
    return false;
@@ -27,12 +27,12 @@ void cM3dGCyl::SetR(f32 r) {
    mRadius = r;
 }

-bool cM3dGCyl::fn_803380e0(cM3dGUnk *unk, mVec3_c *vec) {
-    return fn_80336110(this, unk, vec);
+bool cM3dGCyl::Cross(cM3dGUnk &unk, mVec3_c *vec) {
+    return cM3d_Cross_CylUnk(*this, unk, vec);
 }

-bool cM3dGCyl::fn_803380f0(cM3dGUnk *unk, f32 *vec) {
-    return fn_803364e0(this, unk, vec);
+bool cM3dGCyl::Cross(cM3dGUnk &unk, f32 *vec) {
+    return cM3d_Cross_CylUnk(*this, unk, vec);
 }

 bool cM3dGCyl::Cross(const mVec3_c &pnt) const {
@@ -2,6 +2,8 @@
 #include "d/col/c/c_m3d_g_pla.h"

 #include "d/col/c/c_m3d.h"
+#include "m/m_angle.h"
+#include "m/m_vec.h"

 bool cM3dGPla::CrossInfLin(const mVec3_c &start, const mVec3_c &end, mVec3_c &out) const {
    f32 tmp1 = getPlaneFunc(start);
@@ -28,10 +30,10 @@ bool cM3dGPla::getCrossYLessD(const mVec3_c &point, f32 *out) const {

 mAng cM3dGPla::GetAngle(mAng ang) const {
    mAng angleY = GetAngleY();
-    // Regswap
+
    angleY = angleY - ang;
-    f32 dist = GetXZDist() * angleY.cos();
-    return cM::atan2s(dist, mNormal.y);
+
+    return cM::atan2s(GetXZDist() * angleY.cos(), mNormal.y);
 }

 mAng cM3dGPla::GetNegativeAngle(mAng ang) const {
@@ -27,12 +27,12 @@ void cM3dGSph::SetC(f32 x, f32 y, f32 z) {
    SetC(&c);
 }

-bool cM3dGSph::fn_80338750(cM3dGUnk *pUnk, mVec3_c *pOut) {
-    return fn_80337690(pUnk, this, pOut);
+bool cM3dGSph::Cross(cM3dGUnk &pUnk, mVec3_c *pOut) {
+    return cM3d_Cross_UnkSph(pUnk, *this, pOut);
 }

-bool cM3dGSph::fn_80338760(cM3dGUnk *pUnk, f32 *pOut) {
-    return fn_80337780(pUnk, this, pOut);
+bool cM3dGSph::Cross(cM3dGUnk &pUnk, f32 *pOut) {
+    return cM3d_Cross_UnkSph(pUnk, *this, pOut);
 }

 f32 cM3dGSph::GetYDist(f32 r) const {
@@ -44,7 +44,7 @@ f32 cM3dGSph::GetYDist(f32 r) const {
 }

 bool cM3dGSph::Cross(const cM3dGTri *pTri, f32 *p2, mVec3_c *p3) {
-    return cM3d_Cross_SphTri(this, pTri, nullptr, p2, p3);
+    return cM3d_Cross_SphTri(*this, *pTri, nullptr, p2, p3);
 }

 void cM3dGSph::Clamp(const mVec3_c &in, mVec3_c &out) const {
@@ -2,12 +2,14 @@

 #include "d/col/c/c_m3d.h"
 #include "d/col/c/c_m3d_g_aab.h"
+#include "m/m_vec.h"
+#include "nw4r/types_nw4r.h"

 cM3dGUnk::cM3dGUnk() {
    mMin.set(0.0f, 0.0f, 0.0f);
    mMax.set(0.0f, 0.0f, 0.0f);
-    mField_0x78.set(0.0f, 0.0f, 0.0f);
-    mField_0x84.set(0.0f, 0.0f, 0.0f);
+    mLin.GetStart().set(0.0f, 0.0f, 0.0f);
+    mLin.GetEnd().set(0.0f, 0.0f, 0.0f);
    mField_0x90.set(0.0f, 0.0f, 0.0f);
    mField_0x9C.set(0.0f, 0.0f, 0.0f);
    mField_0xA8.set(0.0f, 0.0f, 0.0f);
@@ -22,9 +24,9 @@ void cM3dGUnk::Set(const mVec3_c &vA, const mVec3_c &vB) {
    mMin = vA;
    mMax = vB;

-    mField_0x84 = (mMin + mMax) * 0.5f;
-    mField_0x90 = mMin - mField_0x84;
-    mField_0x9C = mMax - mField_0x84;
+    mLin.GetEnd() = (mMin + mMax) * 0.5f;
+    mField_0x90 = mMin - mLin.GetEnd();
+    mField_0x9C = mMax - mLin.GetEnd();
    mField_0xA8 = (mMax - mMin) * 0.5f;

    Update();
@@ -34,9 +36,9 @@ void cM3dGUnk::Update() {
    mVec3_c a, b;
    PSMTXMultVec(mMtx, mMin, a);
    PSMTXMultVec(mMtx, mMax, b);
-    mField_0x78.x = (a.x + b.x) * 0.5f;
-    mField_0x78.y = (a.y + b.y) * 0.5f;
-    mField_0x78.z = (a.z + b.z) * 0.5f;
+    mLin.GetStart().x = (a.x + b.x) * 0.5f;
+    mLin.GetStart().y = (a.y + b.y) * 0.5f;
+    mLin.GetStart().z = (a.z + b.z) * 0.5f;
    if (!PSMTXInverse(mMtx, mInvMtx)) {
        PSMTXIdentity(mInvMtx);
    }
@@ -47,41 +49,41 @@ void cM3dGUnk::GetStartEnd(mVec3_c &start, mVec3_c &end) {
    end = mMax;
 }

-void cM3dGUnk::fn_80338c30(cM3dGCps *pCps, mVec3_c *pVec) {
-    fn_80336d90(pCps, this, pVec);
+bool cM3dGUnk::Cross(cM3dGCps &pCps, mVec3_c *pVec) {
+    return cM3d_Cross_CpsUnk(pCps, *this, pVec);
 }

-bool cM3dGUnk::fn_80338c40(cM3dGUnk *pUnk, mVec3_c *pVec) {
+bool cM3dGUnk::Cross(cM3dGTri &pUnk, mVec3_c *pVec) {
    nw4r::math::VEC3 tmp;
-    if (fn_803354e0(this, pUnk, &tmp)) {
+    if (cM3d_Cross_UnkTri(*this, pUnk, &tmp)) {
        *pVec = tmp;
        return true;
    }
    return false;
 }

-bool cM3dGUnk::fn_80338ca0() {
+bool cM3dGUnk::Cross(cM3dGUnk &pUnk, mVec3_c *pVec) {
    return false;
 }

-bool cM3dGUnk::fn_80338cb0(cM3dGCyl *pCyl, mVec3_c *pVec) {
-    return fn_80336110(pCyl, this, pVec);
+bool cM3dGUnk::Cross(cM3dGCyl &pCyl, mVec3_c *pVec) {
+    return cM3d_Cross_CylUnk(pCyl, *this, pVec);
 }

-bool cM3dGUnk::fn_80338cc0(cM3dGCyl *pCyl, f32 *pF) {
-    return fn_803364e0(pCyl, this, pF);
+bool cM3dGUnk::Cross(cM3dGCyl &pCyl, f32 *pF) {
+    return cM3d_Cross_CylUnk(pCyl, *this, pF);
 }

-bool cM3dGUnk::fn_80338cd0(cM3dGSph *pSph, mVec3_c *pVec) {
-    return fn_80337690(this, pSph, pVec);
+bool cM3dGUnk::Cross(cM3dGSph &pSph, mVec3_c *pVec) {
+    return cM3d_Cross_UnkSph(*this, pSph, pVec);
 }

-bool cM3dGUnk::fn_80338ce0(cM3dGSph *pSph, f32 *pF) {
-    return fn_80337780(this, pSph, pF);
+bool cM3dGUnk::Cross(cM3dGSph &pSph, f32 *pF) {
+    return cM3d_Cross_UnkSph(*this, pSph, pF);
 }

 void cM3dGUnk::Set(const mMtx_c &mtx) {
-    mMtx.set(mtx);
+    mMtx.copyFrom(mtx);
    Update();
 }

@@ -89,7 +91,7 @@ void cM3dGUnk::Set(const mVec3_c &vec, const mAng &ang) {
    mMtx_c mtx;
    PSMTXIdentity(mtx);
    mtx.YrotS(ang);
-    mtx.SetTranslation(vec);
+    mtx.setTranslation(vec);
    Set(mtx);
 }

@@ -127,7 +129,7 @@ void cM3dGUnk::Clamp(const mVec3_c &in, mVec3_c &out) {
 }

 void cM3dGUnk::fn_80338f30(f32 f0, f32 f1) {
-    mMtx.xw += f0;
-    mMtx.zw += f1;
+    mMtx(0, 3) += f0;
+    mMtx(2, 3) += f1;
    Update();
 }
@@ -1,373 +1,92 @@
 #include "d/col/cc/d_cc_d.h"

-#include "d/a/d_a_base.h"
-#include "f/f_base_id.h"
+#include "d/col/c/c_cc_d.h"
 #include "m/m_vec.h"

+dCcD_Cps::dCcD_Cps() {}
+dCcD_Cps::~dCcD_Cps() {}

-inline bool cM3d_IsZero(f32 f);
-
-mVec3_c dCcD_ShapeAttr::m_virtual_center = mVec3_c::Zero;
-
-dCcD_DivideInfo::dCcD_DivideInfo() {}
-dCcD_DivideInfo::~dCcD_DivideInfo() {}
-
-dCcD_DivideArea::dCcD_DivideArea() {}
-dCcD_DivideArea::~dCcD_DivideArea() {}
-
-void d_cc_d_float_order() {
-    1.0f / 32.0f;
-    1.0f;
-    0.0f;
-    FLT_EPSILON;
-    1.0f / 3.0f;
-    1.0e9f;
-    -1.0e9f;
-    -1.0f;
-    0.5f;
+void dCcD_Cps::Set(const dCcD_SrcCps &src) {
+    cCcD_Obj::Set(src.mObjInf);
+    cCcD_CpsAttr::Set(src.mCpsInf);
 }

-// Very certain
-void dCcD_DivideArea::SetArea(cM3dGAab const &aab) {
-    Set(aab.mMin, aab.mMax);
-
-    mScaledXDiff = 1.0f / 32.0f * (mMax.x - mMin.x);
-    mXDiffIsZero = cM3d_IsZero(mScaledXDiff);
-    if (!mXDiffIsZero) {
-        mInvScaledXDiff = 1.0f / mScaledXDiff;
-    }
-
-    mScaledYDiff = 1.0f / 32.0f * (mMax.y - mMin.y);
-    mYDiffIsZero = cM3d_IsZero(mScaledYDiff);
-    if (!mYDiffIsZero) {
-        mInvScaledYDiff = 1.0f / mScaledYDiff;
-    }
-
-    mScaledZDiff = 1.0f / 32.0f * (mMax.z - mMin.z);
-    mZDiffIsZero = cM3d_IsZero(mScaledZDiff);
-    if (!mZDiffIsZero) {
-        mInvScaledZDiff = 1.0f / mScaledZDiff;
-    }
+cCcD_ShapeAttr *dCcD_Cps::GetShapeAttr() {
+    return this;
 }

-inline bool cM3d_IsZero(f32 f) {
-    return fabsf(f) < FLT_EPSILON;
+void dCcD_Cps::unknownCalc() {
+    PSVECSubtract(mEnd, mStart, mAt.mVec);
 }

-static u32 const l_base[32] = {
-    0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
-    0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
-    0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
-    0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF,
-};
+dCcD_Tri::dCcD_Tri() {}
+dCcD_Tri::~dCcD_Tri() {}

-// TODO
-
-UnkCCDStruct::UnkCCDStruct(dAcBase_c *arg) : field_0x00(0), field_0x04(0), field_0x08(0), field_0x0C(0) {
-    field_0x38 = 0;
-    field_0x34 = arg;
-    reset();
+void dCcD_Tri::Set(const dCcD_SrcTri &src) {
+    cCcD_Obj::Set(src.mObjInf);
 }

-void UnkCCDStruct::postExecute() {
-    field_0x04 = field_0x00;
-    field_0x00 = 0;
-    field_0x0C = field_0x08;
-    field_0x08 = 0;
+cCcD_ShapeAttr *dCcD_Tri::GetShapeAttr() {
+    return this;
 }

-void UnkCCDStruct::reset() {
-    field_0x10 = mVec3_c::Zero;
-    field_0x1C = mVec3_c::Zero;
-    posIncrements = mVec3_c::Zero;
+dCcD_Cyl::dCcD_Cyl() {}
+dCcD_Cyl::~dCcD_Cyl() {}
+
+void dCcD_Cyl::Set(const dCcD_SrcCyl &src) {
+    cCcD_Obj::Set(src.mObjInf);
+    cCcD_CylAttr::Set(src.mCylInf);
 }

-fBaseID_e UnkCCDStruct::getId() {
-    if (field_0x34 != nullptr) {
-        return field_0x34->unique_ID;
-    }
-    return (fBaseID_e)0;
+cCcD_ShapeAttr *dCcD_Cyl::GetShapeAttr() {
+    return this;
 }

-static u32 const sth[] = {0x4B, 0x5A, 0x64, 0x00};
-
-u32 UnkCCDStruct::getSomething(int arg) {
-    if (field_0x38 == 0x0D || arg == 0) {
-        return 0;
-    }
-
-    if (field_0x38 == 0 || arg == 0x0D) {
-        return 100;
-    }
-
-    if (field_0x38 == arg) {
-        return 50;
-    }
-
-    if (field_0x38 == 0x0C || arg == 0x01) {
-        return 0;
-    }
-
-    if (field_0x38 == 1 || arg == 0x0C) {
-        return 100;
-    }
-
-    arg = arg - field_0x38;
-    if (arg > 0) {
-        return sth[(arg <= 3 ? arg : 3) - 1];
-    } else {
-        return 100 - sth[(-arg <= 3 ? -arg : 3) - 1];
-    }
+void dCcD_Cyl::setCenter(const mVec3_c &c) {
+    SetAtVec(mVec3_c::Zero);
+    SetC(c);
 }

-dCcD_GAtTgCoCommonBase::dCcD_GAtTgCoCommonBase() : field_0x00(0), field_0x14(0), mEffCounter(0) {}
-
-dCcD_GAtTgCoCommonBase::~dCcD_GAtTgCoCommonBase() {
-    unlink();
-    field_0x14 = 0;
-    unlink();
-    decreaseCount();
-    field_0x00 = 0;
+void dCcD_Cyl::moveCenter(const mVec3_c &c) {
+    SetAtVec(c - GetC());
+    SetC(c);
 }

-void dCcD_GAtTgCoCommonBase::unlink() {
-    mActor.unlink();
+dCcD_Sph::dCcD_Sph() {}
+dCcD_Sph::~dCcD_Sph() {}
+
+void dCcD_Sph::Set(const dCcD_SrcSph &src) {
+    cCcD_Obj::Set(src.mObjInf);
+    cCcD_SphAttr::Set(src.mSphInf);
 }

-void dCcD_GAtTgCoCommonBase::setActor(dAcBase_c *actor) {
-    field_0x14 |= 1;
-    mActor.link(actor);
+void dCcD_Sph::setCenter(const mVec3_c &c) {
+    SetAtVec(mVec3_c::Zero);
+    SetC(&c);
 }

-dAcBase_c *dCcD_GAtTgCoCommonBase::getActor() {
-    return mActor.get();
+void dCcD_Sph::moveCenter(const mVec3_c &c) {
+    SetAtVec(c - GetC());
+    SetC(&c);
 }

-void dCcD_GAtTgCoCommonBase::decreaseCount() {
-    if (mEffCounter <= 0) {
-        return;
-    }
-    mEffCounter--;
+void dCcD_Sph::setCenterAndAtVec(const mVec3_c &a, const mVec3_c &b) {
+    SetAtVec(b);
+    SetC(&a);
 }

-dCcD_GObjInf::dCcD_GObjInf() {
-    field_0x104 = nullptr;
-    field_0x108 = 0;
+cCcD_ShapeAttr *dCcD_Sph::GetShapeAttr() {
+    return this;
 }

-dCcD_GObjInf::~dCcD_GObjInf() {
-    field_0x104 = nullptr;
+dCcD_Unk::dCcD_Unk() {}
+dCcD_Unk::~dCcD_Unk() {}
+
+void dCcD_Unk::Set(const dCcD_SrcUnk &src) {
+    cCcD_Obj::Set(src.mObjInf);
+    cCcD_UnkAttr::Set(src.mUnkInf);
 }

-bool dCcD_GObjInf::weirdConditionCheck(dAcBase_c *ac, u32 arg) {
-    return ac != nullptr && ac->isActorPlayer() && arg == 2;
+cCcD_ShapeAttr *dCcD_Unk::GetShapeAttr() {
+    return this;
 }
-
-void dCcD_GObjInf::clear() {
-    mGObjAt.clearFlag();
-    mGObjTg.clearFlag();
-    mGObjCo.clearFlag();
-}
-
-void dCcD_GObjInf::init(const dCcD_SrcGObjInf &src) {
-    mGObjAt.init(&src.mGObjAt);
-    mGObjTg.init(&src.mGObjTg);
-    mGObjCo.init(&src.mGObjCo);
-}
-
-void dCcD_GObjInf::ResetAtHit() {
-    mGObjAt.resetField0x14();
-    mGObjAt.unlink();
-    mGObjAt.decreaseCount();
-    mGObjAt.resetEffCounter();
-}
-
-void dCcD_GObjInf::ResetTgHit() {
-    mGObjTg.resetField0x14();
-    mGObjTg.unlink();
-    mGObjTg.decreaseCount();
-    mGObjTg.resetEffCounter();
-}
-
-void dCcD_GObjInf::ResetCoHit() {
-    mGObjCo.resetField0x14();
-    mGObjCo.unlink();
-    mGObjCo.decreaseCount();
-    mGObjCo.resetEffCounter();
-}
-
-mVec3_c *dCcD_GObjInf::GetAtHitPosP() {
-    return mGObjAt.GetHitPosP();
-}
-
-mVec3_c *dCcD_GObjInf::GetAtHitPosP2() {
-    return mGObjAt.GetHitPosP();
-}
-
-void dCcD_GObjInf::dCcD_GObjInf_0x10() {}
-
-dAcBase_c *dCcD_GObjInf::GetAtActor() {
-    return mGObjAt.getActor();
-}
-
-bool dCcD_GObjInf::CheckCollidedMask(u32 mask) {
-    return (mGObjTg.get0x58() & mask);
-}
-
-dAcBase_c *dCcD_GObjInf::GetTgActor() {
-    return mGObjTg.getActor();
-}
-
-dAcBase_c *dCcD_GObjInf::GetCoActor() {
-    return mGObjCo.getActor();
-}
-
-void dCcD_GObjInf::adjustHitPos(f32 dx, f32 dz) {
-    mGObjAt.adjustHitPos(dx, dz);
-    mGObjTg.adjustHitPos(dx, dz);
-    mGObjCo.adjustHitPos(dx, dz);
-}
-
-/**
- *
- * Geometric shape colliders
- *
- */
-
-dCcD_ShapeAttr::dCcD_ShapeAttr() {}
-
-dCcD_ShapeAttr::~dCcD_ShapeAttr() {}
-
-mVec3_c *dCcD_ShapeAttr::getVirtualCenter() {
-    return &m_virtual_center;
-}
-
-dCcD_ShapeAttr2::dCcD_ShapeAttr2() {}
-dCcD_ShapeAttr2::~dCcD_ShapeAttr2() {}
-
-dCcD_ShapeAttr5::dCcD_ShapeAttr5() {}
-dCcD_ShapeAttr5::~dCcD_ShapeAttr5() {}
-
-void dCcD_ShapeAttr5::init(const dCcD_SrcAabbAttr &src) {
-    Set(mVec3_c(src.minX, src.minY, src.minZ), mVec3_c(src.maxX, src.maxY, src.maxZ));
-}
-
-mVec3_c *dCcD_ShapeAttr5::getVirtualCenter() {
-    return &mVirtCenter;
-}
-
-dCcD_ShapeAttr1::dCcD_ShapeAttr1() {}
-dCcD_ShapeAttr1::~dCcD_ShapeAttr1() {}
-
-mVec3_c *dCcD_ShapeAttr1::getVirtualCenter() {
-    return &mVirtualCenter;
-}
-
-dCcD_ShapeAttr3::dCcD_ShapeAttr3() {}
-
-dCcD_ShapeAttr3::~dCcD_ShapeAttr3() {}
-
-void dCcD_ShapeAttr3::init(const dCcD_SrcCylAttr &src) {
-    SetR(src.mRadius);
-    SetH(src.mHeight);
-    mVec3_c v;
-    v.z = 0.0f;
-    v.y = 0.0f;
-    v.x = 0.0f;
-    SetC(v);
-}
-
-mVec3_c *dCcD_ShapeAttr3::getVirtualCenter() {
-    return &mCenter;
-}
-
-dCcD_ShapeAttr4::dCcD_ShapeAttr4() {}
-dCcD_ShapeAttr4::~dCcD_ShapeAttr4() {}
-
-void dCcD_ShapeAttr4::init(const dCcD_SrcSphAttr &src) {
-    SetR(src.mRadius);
-    mVec3_c v;
-    v.z = 0.0f;
-    v.y = 0.0f;
-    v.x = 0.0f;
-    SetC(v);
-}
-
-mVec3_c *dCcD_ShapeAttr4::getVirtualCenter() {
-    return &mCenter;
-}
-
-/**
- *
- * At/Tg/Co collider
- *
- */
-
-dCcD_GObjAt::dCcD_GObjAt() {
-    field_0x58 = 0;
-}
-
-dCcD_GObjAt::~dCcD_GObjAt() {}
-
-void dCcD_GObjAt::init(const dCcD_SrcGObjAt *src) {
-    mEffCounter = 0;
-    mSrc = *src;
-    mHitPos = mVec3_c::Zero;
-}
-
-void dCcD_GObjAt::setSomeAtFlags(u32 flags) {
-    mSrc.field_0x04 = mSrc.field_0x04 & 0xFFFFFFC1 | flags;
-}
-
-void dCcD_GObjAt::adjustHitPos(f32 dx, f32 dz) {
-    mHitPos.x += dx;
-    mHitPos.z += dz;
-}
-
-dCcD_GObjTg::dCcD_GObjTg() {
-    field_0x44 = 0;
-    field_0x4A = 0;
-    field_0x4B = 0;
-    field_0x4C = 0;
-    field_0x50 = 0;
-    field_0x54 = 0;
-    field_0x6C.x = 0.0f;
-    field_0x6C.y = 0.0f;
-    field_0x6C.z = 0.0f;
-    field_0x78 = 0;
-}
-
-dCcD_GObjTg::~dCcD_GObjTg() {}
-
-void dCcD_GObjTg::init(const dCcD_SrcGObjTg *src) {
-    mEffCounter = 0;
-    mSrc = *src;
-    field_0x4C = 0;
-    mHitPos = mVec3_c::Zero;
-    field_0x44 = 0;
-    field_0x48 = 0x4000;
-}
-
-void dCcD_GObjTg::adjustHitPos(f32 dx, f32 dz) {
-    mHitPos.x += dx;
-    mHitPos.z += dz;
-    field_0x6C.x += dx;
-    field_0x6C.z += dz;
-}
-
-dCcD_GObjCo::dCcD_GObjCo() {
-    field_0x20 = 0;
-    field_0x28 = 0;
-}
-
-dCcD_GObjCo::~dCcD_GObjCo() {}
-
-void dCcD_GObjCo::init(const dCcD_SrcGObjCo *src) {
-    mEffCounter = 0;
-    mSrc = *src;
-    setSomeAtFlags(src->mBase.mGFlag & 0x1E0);
-}
-
-void dCcD_GObjCo::setSomeAtFlags(u32 flags) {}
-
-void dCcD_GObjCo::adjustHitPos(f32 dx, f32 dz) {}
@@ -0,0 +1,276 @@
+#include "d/col/cc/d_cc_mass_s.h"
+
+#include "common.h"
+#include "m/m_vec.h"
+#include "rvl/MTX/vec.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Obj
+///////////////////////////////////////////////////////////////////////////////
+
+dCcMassS_Obj::dCcMassS_Obj() {}
+
+dCcMassS_Obj::~dCcMassS_Obj() {}
+
+void dCcMassS_Obj::Set(cCcD_Obj *p_obj, u8 priority, dCcMassS_ObjCallback callback) {
+    mpObj = p_obj;
+    mPriority = priority;
+    mpCallback = callback;
+}
+
+void dCcMassS_Obj::Clear() {
+    mpObj = nullptr;
+    mPriority = 5;
+    mpCallback = nullptr;
+    mDivideInfo.Set(0, 0, 0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Hit Info
+///////////////////////////////////////////////////////////////////////////////
+
+dCcMassS_HitInf::dCcMassS_HitInf() {}
+
+dCcMassS_HitInf::~dCcMassS_HitInf() {}
+
+void dCcMassS_HitInf::ClearPointer() {
+    mpArea = nullptr;
+    mpAtObj = nullptr;
+    mpCoObj = nullptr;
+    mCoHitLen = 0.0f;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Manager
+///////////////////////////////////////////////////////////////////////////////
+
+dCcMassS_Mng::dCcMassS_Mng() {
+    Ct();
+}
+
+dCcMassS_Mng ::~dCcMassS_Mng() {}
+
+void dCcMassS_Mng::Ct() {
+    field_0x3AA = 0;
+    mResultCam = 0;
+    mCamTopPos.x = 0.0f;
+    mCamTopPos.y = -1000000000.0f;
+    mCamTopPos.z = 0.0f;
+
+    mCamBottomPos.x = 0.0f;
+    mCamBottomPos.y = -1000000000.0f;
+    mCamBottomPos.z = 0.0f;
+
+    Clear();
+}
+
+void dCcMassS_Mng::SetAttr(f32 radius, f32 height, u8 param_2, u8 param_3) {
+    mCylAttr.SetR(radius);
+    mCylAttr.SetH(height);
+    field_0x3A8 = param_2;
+    field_0x3A9 = param_3;
+}
+
+void dCcMassS_Mng::Prepare() {
+    cM3dGAab aab;
+    aab.ClearForMinMax();
+
+    for (dCcMassS_Obj *pObj = mMassObjs; pObj < mMassObjs + mMassObjCount; ++pObj) {
+        cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
+        objShape->CalcAabBox();
+        aab.SetMinMax(objShape->GetWorkAab());
+    }
+
+    for (dCcMassS_Obj *pObj = mMassAreas; pObj < mMassAreas + mMassAreaCount; ++pObj) {
+        cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
+        objShape->CalcAabBox();
+        aab.SetMinMax(objShape->GetWorkAab());
+    }
+
+    if (field_0x3AA & 1) {
+        mCpsAttr.CalcAabBox();
+        aab.SetMinMax(mCpsAttr.GetWorkAab());
+    }
+
+    mDivideArea.SetArea(aab);
+    for (dCcMassS_Obj *pObj = mMassObjs; pObj < mMassObjs + mMassObjCount; ++pObj) {
+        cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
+        cCcD_DivideInfo *divideInfo = &pObj->GetDivideInfo();
+        mDivideArea.CalcDivideInfo(divideInfo, objShape->GetWorkAab());
+    }
+
+    for (dCcMassS_Obj *pObj = mMassAreas; pObj < mMassAreas + mMassAreaCount; ++pObj) {
+        cCcD_ShapeAttr *objShape = pObj->GetObj()->GetShapeAttr();
+        cCcD_DivideInfo *divideInfo = &pObj->GetDivideInfo();
+        mDivideArea.CalcDivideInfo(divideInfo, objShape->GetWorkAab());
+    }
+
+    if (field_0x3AA & 1) {
+        mDivideArea.CalcDivideInfo(&mDivideInfo, mCpsAttr.GetWorkAab());
+    }
+
+    mCamTopPos.x = 0.0f;
+    mCamTopPos.y = -1000000000.0f;
+    mCamTopPos.z = 0.0f;
+    mCamTopDist = 1000000000.0f;
+
+    mCamBottomPos.x = 0.0f;
+    mCamBottomPos.y = -1000000000.0f;
+    mCamBottomPos.z = 0.0f;
+    mCamBottomDist = 1000000000.0f;
+}
+
+u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p_hitInf) {
+    cCcD_DivideInfo divideInfo;
+    u32 flagsMaybe = 0;
+    *p_actor = NULL;
+
+    mCylAttr.SetC(*p_xyz);
+    mCylAttr.CalcAabBox();
+
+    mDivideArea.CalcDivideInfoOverArea(&divideInfo, mCylAttr.GetWorkAab());
+    p_hitInf->ClearPointer();
+
+    if (field_0x3A8 & 8) {
+        for (dCcMassS_Obj *massObj = mMassAreas; massObj < mMassAreas + mMassAreaCount; ++massObj) {
+            if (massObj->GetDivideInfo().Chk(divideInfo)) {
+                cCcD_Obj *obj = massObj->GetObj();
+                cCcD_ShapeAttr *objShape = obj->GetShapeAttr();
+                f32 f;
+                if (obj->ChkCoSet() && mCylAttr.CrossCo(*objShape, &f)) {
+                    flagsMaybe |= 4;
+                    *p_actor = obj->GetStts()->GetAc();
+                    if (p_hitInf != NULL) {
+                        p_hitInf->SetAreaHitObj(obj);
+                    }
+
+                    if (massObj->GetCallback() != NULL) {
+                        massObj->GetCallback()(obj->GetStts()->GetAc(), p_xyz, field_0x3A9);
+                    }
+                }
+            }
+        }
+    }
+
+    for (dCcMassS_Obj *massObj = mMassObjs; massObj < mMassObjs + mMassObjCount; ++massObj) {
+        if (massObj->GetDivideInfo().Chk(divideInfo)) {
+            cCcD_Obj *obj = massObj->GetObj();
+            cCcD_ShapeAttr *objShape = obj->GetShapeAttr();
+            mVec3_c unusedVec;
+            if (obj->ChkAtSet() && !obj->ChkAtNoMass() && (field_0x3A8 & 1)) {
+                *p_actor = obj->GetStts()->GetAc();
+            }
+            if (obj->ChkAtSet() && !obj->ChkAtNoMass() && mCylAttr.CrossAtTg(*objShape, &unusedVec) &&
+                (field_0x3A8 & 1)) {
+                flagsMaybe |= 1;
+                *p_actor = obj->GetStts()->GetAc();
+                if (p_hitInf != NULL) {
+                    p_hitInf->SetAtHitObj(obj);
+                }
+            }
+
+            f32 f;
+            if (obj->ChkCoSet() && mCylAttr.CrossCo(*objShape, &f) && (field_0x3A8 & 2)) {
+                flagsMaybe |= 2;
+                *p_actor = obj->GetStts()->GetAc();
+
+                if (field_0x3A8 & 0x10) {
+                    mVec3_c vec;
+                    PSVECSubtract((*p_actor)->GetPostion(), *p_xyz, vec);
+                    vec.y = 0;
+                    f32 vecMag = PSVECMag(vec);
+                    if (cM3d_IsZero(vecMag)) {
+                        vec.x = 1;
+                    } else {
+                        PSVECScale(vec, vec, f / vecMag);
+                    }
+                    obj->GetStts()->PlusCcMove(vec.x, vec.y, vec.z);
+                }
+
+                if (p_hitInf != NULL) {
+                    p_hitInf->SetCoHitObj(obj);
+                    p_hitInf->SetCoHitLen(f);
+                }
+            }
+        }
+    }
+
+    f32 f;
+    if ((field_0x3AA & 1) && mDivideInfo.Chk(divideInfo) && mCylAttr.CrossCo(mCpsAttr, &f)) {
+        mResultCam |= 1;
+        mResultCam |= 1 << (field_0x3A9 + 1);
+
+        if ((mResultCam & 2) || (mResultCam & 8)) {
+            Vec tmpVec;
+            f32 plusH = p_xyz->y + mCylAttr.GetH();
+            tmpVec.x = p_xyz->x;
+            tmpVec.y = plusH;
+            tmpVec.z = p_xyz->z;
+
+            if (mCamTopPos.y < (20.0f + plusH)) {
+                f32 newCamTopDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetStartP());
+                if (mCamTopDist > newCamTopDist) {
+                    mCamTopDist = newCamTopDist;
+                    mCamTopPos = tmpVec;
+                }
+            }
+
+            if (mCamBottomPos.y < (20.0f + plusH)) {
+                f32 newCamBottomDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetEndP());
+                if (mCamBottomDist > newCamBottomDist) {
+                    mCamBottomDist = newCamBottomDist;
+                    mCamBottomPos = tmpVec;
+                }
+            }
+        }
+    }
+
+    return flagsMaybe;
+}
+
+void dCcMassS_Mng::Clear() {
+    mMassObjCount = 0;
+    mMassAreaCount = 0;
+
+    for (int i = 0; i < (s32)ARRAY_LENGTH(mMassObjs); ++i) {
+        mMassObjs[i].Clear();
+    }
+
+    for (int i = 0; i < (s32)ARRAY_LENGTH(mMassAreas); ++i) {
+        mMassAreas[i].Clear();
+    }
+
+    mCylAttr.SetR(0.0f);
+    mCylAttr.SetH(0.0f);
+    field_0x3A8 = 0;
+    field_0x3A9 = 4;
+}
+
+void dCcMassS_Mng::SetObj(cCcD_Obj *p_obj, u8 priority) {
+    if (mMassObjCount >= (s32)ARRAY_LENGTH(mMassObjs)) {
+        for (int i = 0; i < (s32)ARRAY_LENGTH(mMassObjs); ++i) {
+            int prevPrio = mMassObjs[i].GetPriority();
+            if (prevPrio > priority || (prevPrio == priority)) {
+                mMassObjs[i].Set(p_obj, priority, nullptr);
+                break;
+            }
+        }
+    } else {
+        mMassObjs[mMassObjCount].Set(p_obj, priority, nullptr);
+        mMassObjCount++;
+    }
+}
+
+void dCcMassS_Mng::SetArea(cCcD_Obj *p_obj, u8 priority, dCcMassS_ObjCallback callback) {
+    if (mMassAreaCount >= (s32)ARRAY_LENGTH(mMassAreas)) {
+        for (int i = 0; i < (s32)ARRAY_LENGTH(mMassAreas); ++i) {
+            if (mMassAreas[i].GetPriority() > priority) {
+                mMassAreas[i].Set(p_obj, priority, callback);
+                break;
+            }
+        }
+    } else {
+        mMassAreas[mMassAreaCount].Set(p_obj, priority, callback);
+        mMassAreaCount++;
+    }
+}
@@ -0,0 +1,180 @@
+#include "d/col/cc/d_cc_s.h"
+
+#include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/col/c/c_cc_d.h"
+#include "d/col/c/c_m3d_g_aab.h"
+#include "f/f_base.h"
+#include "rvl/MTX/mtx.h"
+
+dCcS *dCcS::sInstance;
+
+dCcS *dCcS::GetInstance() {
+    return sInstance;
+}
+
+void dCcS::Ct_cCcS() {
+    for (cCcD_Obj **end = mpObjAt + ARRAY_LENGTH(mpObjAt), **obj = mpObjAt; obj < end; ++obj) {
+        *obj = nullptr;
+    }
+    mObjAtCount = 0;
+
+    for (cCcD_Obj **end = mpObjTg + ARRAY_LENGTH(mpObjTg), **obj = mpObjTg; obj < end; ++obj) {
+        *obj = nullptr;
+    }
+    mObjTgCount = 0;
+
+    for (cCcD_Obj **end = mpObjCo + ARRAY_LENGTH(mpObjCo), **obj = mpObjCo; obj < end; ++obj) {
+        *obj = nullptr;
+    }
+    mObjCoCount = 0;
+
+    for (cCcD_Obj **end = mpObj + ARRAY_LENGTH(mpObj), **obj = mpObj; obj < end; ++obj) {
+        *obj = nullptr;
+    }
+    mObjCount = 0;
+
+    for (UNKTYPE **end = mpUnk + ARRAY_LENGTH(mpUnk), **obj = mpUnk; obj < end; ++obj) {
+        *obj = nullptr;
+    }
+    mUnkCount = 0;
+}
+
+dCcS::dCcS() {
+    sInstance = this;
+}
+
+dCcS::~dCcS() {
+    sInstance = nullptr;
+}
+
+void dCcS::Ct() {
+    Ct_cCcS();
+    mMassMng.Ct();
+    ClearArea();
+}
+
+void dCcS::Dt() {
+    Ct_cCcS();
+    ClearArea();
+}
+
+bool dCcS::ChkRemoveActor(dAcObjBase_c *pActor) {
+    bool ret = false;
+    if (pActor && (pActor->delete_request || pActor->lifecycle_state == fBase_c::TO_BE_DELETED)) {
+        ret = true;
+    }
+    return ret;
+}
+
+bool dCcS::ChkNoHitAtTg(cCcD_Obj *, cCcD_Obj *) {}
+
+bool dCcS::ChkAtTgCommonHitInf(cCcD_Obj *, cCcD_Obj *) {}
+
+void dCcS::ChkAtTg() {}
+
+bool dCcS::ChkNoHitCo(cCcD_Obj *, cCcD_Obj *) {}
+
+void dCcS::SetCoCommonHitInf(cCcD_Obj *, mVec3_c *, cCcD_Obj *, mVec3_c *, f32) {}
+
+void dCcS::ChkCo() {}
+
+bool dCcS::ChkSheildFrontRange(cCcD_Obj *, cCcD_Obj *) {}
+
+bool dCcS::ChkShield(cCcD_Obj *, cCcD_Obj *, cCcD_ShieldChkCallback *) {}
+
+bool dCcS::ChkAtTgHitAfterCross(bool, bool, cCcD_Obj *, cCcD_Obj *) {}
+
+void dCcS::SetCoObjInf(bool, bool, cCcD_Obj *, cCcD_Obj *) {}
+
+void dCcS::SetPosCorrect(cCcD_Obj *, mVec3_c *, cCcD_Obj *, mVec3_c *, f32) {}
+
+void dCcS::CalcParticleAngle(cCcD_Obj *, cCcD_Obj *, mAng3_c *, bool) {}
+
+void dCcS::fn_80356fd0(mVec3_c *, cCcD_Obj *, cCcD_Obj *) {}
+
+u32 dCcS::ProcAtTgHitmark(cCcD_Obj *, cCcD_Obj *, mVec3_c *, u32, mVec3_c *) {}
+
+void dCcS::SetAtTgObjInf(bool, bool, cCcD_Obj *, cCcD_Obj *, mVec3_c *, bool) {}
+
+bool dCcS::ChkCamera(mVec3_c &, mVec3_c &, dAcObjBase_c *, dAcObjBase_c *, dAcObjBase_c *, f32) {}
+
+bool dCcS::ChkCameraPoint(
+    const mVec3_c &, const mVec3_c &, mVec3_c &, dAcObjBase_c *, dAcObjBase_c *, dAcObjBase_c *, f32
+) {}
+
+bool dCcS::ChkCo(const mVec3_c &, dAcObjBase_c *) {}
+
+bool dCcS::fn_80357c90(const mVec3_c &, const mVec3_c &, u32, UNKTYPE **) {}
+
+void dCcS::Set(cCcD_Obj *) {}
+
+void dCcS::MoveAfterCheck() {}
+
+void dCcS::RemoveDeadObj() {}
+
+void dCcS::CalcArea() {
+    if (mbAreaSet) {
+        return;
+    }
+
+    cM3dGAab aab;
+    aab.ClearForMinMax();
+    for (cCcD_Obj **obj = mpObj; obj < mpObj + mObjCount; ++obj) {
+        cCcD_ShapeAttr *attr = (*obj)->GetShapeAttr();
+        attr->CalcAabBox();
+        aab.SetMinMax(attr->GetWorkAab());
+    }
+    // TODO
+}
+
+void dCcS::Move() {
+    RemoveDeadObj();
+    CalcArea();
+    ChkAtTg();
+    ChkCo();
+    for (int i = 0; i < mObjTgCount; ++i) {
+        mpObjTg[i]->SetTg_0x4B(0);
+    }
+    MoveAfterCheck();
+    AdjustHitPos();
+    mObjAtCount = 0;
+    mObjTgCount = 0;
+    mObjCoCount = 0;
+    mObjCount = 0;
+    mUnkCount = 0;
+    mbAreaSet = false;
+    ClearArea();
+}
+
+void dCcS::MassClear() {
+    mMassMng.Clear();
+}
+
+void dCcS::SetArea(mMtx_c *pMtx) {
+    if (mAreaCount >= 16) {
+        return;
+    }
+
+    // non-match: Huh
+    mAreas[mAreaCount].mInv = mAreas[mAreaCount].mMtx = *pMtx;
+
+    PSMTXInverse(mAreas[mAreaCount].mInv, mAreas[mAreaCount].mInv);
+    mAreaCount++;
+}
+
+void dCcS::ClearArea() {
+    mAreaCount = 0;
+}
+
+extern "C" void *STAGE_MANAGER;
+extern "C" bool fn_8019A7A0(void *stg, f32 *, f32 *);
+void dCcS::AdjustHitPos() {
+    f32 x, z;
+    if (STAGE_MANAGER && fn_8019A7A0(STAGE_MANAGER, &x, &z)) {
+        for (cCcD_Obj **obj = mpObj; obj < mpObj + mObjCount; ++obj) {
+            (*obj)->AdjustHitPos(x, z);
+            (*obj)->GetShapeAttr()->TranslateXZ(x, z);
+        }
+    }
+}
@@ -1,108 +0,0 @@
-#include "d/col/cc/d_cc_shape_colliders.h"
-
-#include "d/col/cc/d_cc_d.h"
-#include "m/m_vec.h"
-
-
-dCcD_Unk1::dCcD_Unk1() {}
-dCcD_Unk1::~dCcD_Unk1() {}
-
-void dCcD_Unk1::init(const dCcD_SrcUnk &src) {
-    dCcD_GObjInf::init(src.mObjInf);
-    dCcD_ShapeAttr1::init(src.mUnk1Inf);
-}
-
-void *dCcD_Unk1::dCcD_GObjInf_0x0C() {
-    if (this != nullptr) {
-        return &UNK_0x00;
-    }
-    return this;
-}
-
-void dCcD_Unk1::unknownCalc() {
-    PSVECSubtract(mCps.mEnd, mCps.mStart, *getAtVec());
-}
-
-dCcD_Empty::dCcD_Empty() {}
-dCcD_Empty::~dCcD_Empty() {}
-
-void dCcD_Empty::init(const dCcD_SrcEmpty &src) {
-    dCcD_GObjInf::init(src.mObjInf);
-}
-
-void *dCcD_Empty::dCcD_GObjInf_0x0C() {
-    if (this != nullptr) {
-        return &UNK_0x00;
-    }
-    return this;
-}
-
-dCcD_Cyl::dCcD_Cyl() {}
-dCcD_Cyl::~dCcD_Cyl() {}
-
-void dCcD_Cyl::init(const dCcD_SrcCyl &src) {
-    dCcD_GObjInf::init(src.mObjInf);
-    dCcD_ShapeAttr3::init(src.mCylAttr);
-}
-
-void *dCcD_Cyl::dCcD_GObjInf_0x0C() {
-    if (this != nullptr) {
-        return &UNK_0x00;
-    }
-    return this;
-}
-
-void dCcD_Cyl::setCenter(const mVec3_c &c) {
-    setAtVec(mVec3_c::Zero);
-    SetC(c);
-}
-
-void dCcD_Cyl::moveCenter(const mVec3_c &c) {
-    setAtVec(c - GetC());
-    SetC(c);
-}
-
-dCcD_Sph::dCcD_Sph() {}
-dCcD_Sph::~dCcD_Sph() {}
-
-void dCcD_Sph::init(const dCcD_SrcSph &src) {
-    dCcD_GObjInf::init(src.mObjInf);
-    dCcD_ShapeAttr4::init(src.mSphAttr);
-}
-
-void dCcD_Sph::setCenter(const mVec3_c &c) {
-    setAtVec(mVec3_c::Zero);
-    SetC(&c);
-}
-
-void dCcD_Sph::moveCenter(const mVec3_c &c) {
-    setAtVec(c - GetC());
-    SetC(&c);
-}
-
-void dCcD_Sph::setCenterAndAtVec(const mVec3_c &a, const mVec3_c &b) {
-    setAtVec(b);
-    SetC(&a);
-}
-
-void *dCcD_Sph::dCcD_GObjInf_0x0C() {
-    if (this != nullptr) {
-        return &UNK_0x00;
-    }
-    return this;
-}
-
-dCcD_Aabb::dCcD_Aabb() {}
-dCcD_Aabb::~dCcD_Aabb() {}
-
-void dCcD_Aabb::init(const dCcD_SrcAabb &src) {
-    dCcD_GObjInf::init(src.mObjInf);
-    dCcD_ShapeAttr5::init(src.mAabbAttr);
-}
-
-void *dCcD_Aabb::dCcD_GObjInf_0x0C() {
-    if (this != nullptr) {
-        return &UNK_0x00;
-    }
-    return this;
-}
@@ -0,0 +1,188 @@
+#include "d/d_textunk.h"
+
+#include "common.h"
+#include "nw4r/ut/ut_Color.h"
+
+UnkTextThing textThing;
+UnkTextThing *UnkTextThing::sInstance;
+
+// UnkTextThing::~UnkTextThing() {}
+UnkTextThing::UnkTextThing() {
+    sInstance = this;
+
+    field_0x754 = 0.0f;
+    field_0x758 = 12.0f;
+    field_0x75C = 0.04f;
+    field_0x760 = 0.22f;
+    field_0x764 = 42.0f;
+    field_0x768 = 0.8f;
+    field_0x76C = 0.3f;
+
+    field_0x7B3 = false;
+    field_0x798 = 0;
+    field_0x79C = 0;
+    field_0x7A0 = 0;
+
+    field_0x770 = 80.0f;
+    field_0x774 = 30.0f;
+    field_0x796 = 3;
+    field_0x778 = 10.0f;
+    field_0x780 = 8.0f;
+    field_0x77C = 8.0f;
+    field_0x784 = 6.0f;
+
+    field_0x7A4 = 0xB6;
+    field_0x7A6 = 0x16C;
+
+    for (int i = 0; i < 82; i++) {
+        field_buf0[i] = 0;
+        field_buf2[i] = 0;
+    }
+
+    for (int i = 0; i < 23; i++) {
+        field_buf4[i] = 0;
+        field_buf5[i] = 0;
+    }
+
+    for (int i = 0; i < 80; i++) {
+        field_buf1[i] = 0;
+        field_buf3[i] = 0;
+    }
+
+    field_0x74C = 0;
+    field_0x750 = 0;
+
+    field_0x7B4 = false;
+    field_0x7B5 = false;
+
+    field_0x004 = "";
+    field_0x084 = "";
+    field_0x104 = "";
+
+    field_0x7B6 = 0;
+
+    field_0x7A8 = 0;
+    field_0x788 = 0.45;
+    field_0x78C = -5.0f;
+    field_0x7AE = 4;
+    field_0x7B7 = 0;
+    field_0x7AA = 5;
+    field_0x7AC = 15;
+    field_0x7B0 = 0;
+    field_0x7B2 = false;
+
+    // Weird init order
+    field_0x7B8.a = 0;
+    field_0x7B8.b = 0;
+    field_0x7B8.g = 0;
+    field_0x7B8.r = 0;
+    field_0x7BC.a = 0;
+    field_0x7BC.b = 0;
+    field_0x7BC.g = 0;
+    field_0x7BC.r = 0;
+
+    field_0x790 = -1.0f;
+    field_0x794 = 100.0f;
+}
+
+void UnkTextThing::destroy() {
+    for (int i = 0; i < 82; i++) {
+        if (field_buf0[i] != nullptr) {
+            destroyUnk(field_buf0[i]);
+            field_buf0[i] = nullptr;
+        }
+
+        if (field_buf2[i] != nullptr) {
+            destroyMsg(field_buf2[i]);
+            field_buf2[i] = nullptr;
+        }
+    }
+
+    for (int i = 0; i < 23; i++) {
+        if (field_buf4[i] != nullptr) {
+            destroyUnk(field_buf4[i]);
+            field_buf4[i] = nullptr;
+        }
+
+        if (field_buf5[i] != nullptr) {
+            destroyMsg(field_buf5[i]);
+            field_buf5[i] = nullptr;
+        }
+    }
+
+    for (int i = 0; i < 80; i++) {
+        if (field_buf1[i] != nullptr) {
+            destroyUnk(field_buf1[i]);
+            field_buf1[i] = nullptr;
+        }
+
+        if (field_buf3[i] != nullptr) {
+            destroyFlow(field_buf3[i]);
+            field_buf3[i] = nullptr;
+        }
+    }
+
+    if (field_0x74C != nullptr) {
+        destroyUnk(field_0x74C);
+        field_0x74C = nullptr;
+    }
+
+    if (field_0x750 != nullptr) {
+        destroyUnk(field_0x750);
+        field_0x750 = nullptr;
+    }
+}
+
+f32 UnkTextThing::fn_800B1F10() {
+    return field_0x794 / 100.0f;
+}
+
+void *UnkTextThing::allocUnk(size_t size, int align) {
+    return nullptr;
+}
+void UnkTextThing::destroyUnk(void *_thing) {}
+
+f32 UnkTextThing::fn_800B1F70() {
+    f32 v = fn_800B1FC0();
+    v *= fn_800B1FE0();
+    return v;
+}
+f32 UnkTextThing::fn_800B1FC0() {
+    return 1.0f;
+}
+f32 UnkTextThing::fn_800B1FD0() {
+    return 0.9f;
+}
+f32 UnkTextThing::fn_800B1FE0() {
+    return 1.0f;
+}
+f32 UnkTextThing::fn_800B1FF0() {
+    return 0.0f;
+}
+f32 UnkTextThing::fn_800B2000() {
+    return 0.0f;
+}
+f32 UnkTextThing::fn_800B2010() {
+    return -1.0f;
+}
+f32 UnkTextThing::fn_800B2020() {
+    return 0.0f;
+}
+f32 UnkTextThing::fn_800B2030() {
+    return 0.0f;
+}
+f32 UnkTextThing::fn_800B2040() {
+    return 0.0f;
+}
+
+void UnkTextThing::destroyMsg(MsbtInfo *msg) {
+    field_0x7B6 = true;
+    LMS_CloseMessage(msg);
+    field_0x7B6 = false;
+}
+
+void UnkTextThing::destroyFlow(MsbfInfo *flow) {
+    field_0x7B6 = true;
+    LMS_CloseFlow(flow);
+    field_0x7B6 = false;
+}
@@ -1,5 +1,11 @@
 #include "d/lyt/meter/d_lyt_meter_drink.h"

+#include "common.h"
+#include "d/lyt/d2d.h"
+#include "m/m_vec.h"
+#include "nw4r/lyt/lyt_pane.h"
+#include "toBeSorted/file_manager.h"
+
 STATE_DEFINE(dLytMeterDrinkParts_c, Invisible);
 STATE_DEFINE(dLytMeterDrinkParts_c, In);
 STATE_DEFINE(dLytMeterDrinkParts_c, Visible);
@@ -10,3 +16,539 @@ STATE_DEFINE(dLytMeterDrink_c, In);
 STATE_DEFINE(dLytMeterDrink_c, Wait);
 STATE_DEFINE(dLytMeterDrink_c, Move);
 STATE_DEFINE(dLytMeterDrink_c, Out);
+
+void dLytMeterDrinkParts_c::initializeState_Invisible() {
+    if (field_0x51) {
+        if (mAnmGroups[2]->isFlag2()) {
+            mAnmGroups[2]->setAnimEnable(false);
+        }
+        if (!mAnmGroups[0]->isFlag2()) {
+            mAnmGroups[0]->setAnimEnable(true);
+        }
+        mAnmGroups[0]->setFrame(0.0f);
+        field_0x48 = 6;
+        mDrinkType = TYPE_NONE;
+        field_0x51 = 0;
+    }
+}
+void dLytMeterDrinkParts_c::executeState_Invisible() {
+    if (mAnmGroups[0]->isFlag2()) {
+        mAnmGroups[0]->setAnimEnable(false);
+    }
+    if (field_0x50) {
+        mStateMgr.changeState(StateID_In);
+    }
+}
+void dLytMeterDrinkParts_c::finalizeState_Invisible() {}
+
+void dLytMeterDrinkParts_c::initializeState_In() {
+    if (field_0x51) {
+        if (mAnmGroups[2]->isFlag2()) {
+            mAnmGroups[2]->setAnimEnable(false);
+        }
+        mAnmGroups[0]->setToEnd();
+        field_0x51 = 0;
+    } else {
+        mAnmGroups[0]->setFrame(0.0f);
+    }
+    mAnmGroups[0]->setAnimEnable(true);
+}
+void dLytMeterDrinkParts_c::executeState_In() {
+    if (mAnmGroups[0]->isEndReached()) {
+        mAnmGroups[0]->setAnimEnable(false);
+        mStateMgr.changeState(StateID_Visible);
+    }
+
+    if (mAnmGroups[0]->isFlag2()) {
+        mAnmGroups[0]->play();
+    }
+}
+void dLytMeterDrinkParts_c::finalizeState_In() {}
+
+void dLytMeterDrinkParts_c::initializeState_Visible() {
+    if (field_0x51) {
+        if (mAnmGroups[2]->isFlag2()) {
+            mAnmGroups[2]->setAnimEnable(false);
+        }
+        mAnmGroups[0]->setAnimEnable(true);
+        mAnmGroups[0]->setToEnd();
+        field_0x51 = 0;
+    }
+}
+
+void dLytMeterDrinkParts_c::executeState_Visible() {
+    if (mAnmGroups[0]->isFlag2()) {
+        mAnmGroups[0]->setAnimEnable(false);
+    }
+
+    if (field_0x48 != getDrinkFrame(mDrinkType)) {
+        mStateMgr.changeState(StateID_Out);
+    }
+}
+void dLytMeterDrinkParts_c::finalizeState_Visible() {}
+
+void dLytMeterDrinkParts_c::initializeState_Out() {
+    if (field_0x51) {
+        if (mAnmGroups[0]->isFlag2()) {
+            mAnmGroups[0]->setAnimEnable(false);
+        }
+        mAnmGroups[2]->setToEnd();
+        field_0x51 = 0;
+    } else {
+        mAnmGroups[2]->setFrame(0.0f);
+    }
+
+    mAnmGroups[2]->setAnimEnable(true);
+}
+void dLytMeterDrinkParts_c::executeState_Out() {
+    if (mAnmGroups[2]->isEndReached()) {
+        mAnmGroups[2]->setAnimEnable(false);
+        field_0x48 = 6;
+        mDrinkType = TYPE_NONE;
+        field_0x50 = 0;
+        mStateMgr.changeState(StateID_Invisible);
+    }
+    if (mAnmGroups[2]->isFlag2()) {
+        mAnmGroups[2]->play();
+    }
+}
+void dLytMeterDrinkParts_c::finalizeState_Out() {}
+
+void dLytMeterDrinkParts_c::init() {
+    field_0x50 = 0;
+    field_0x51 = 0;
+    field_0x48 = 6;
+    mDrinkType = TYPE_NONE;
+    mAnmGroups[1]->setAnimEnable(true);
+    mStateMgr.changeState(StateID_Invisible);
+}
+
+void dLytMeterDrinkParts_c::execute() {
+    mStateMgr.executeState();
+    if (field_0x48 != 6) {
+        mAnmGroups[1]->setFrame(field_0x48);
+    }
+}
+
+dLytMeterDrinkParts_c::DrinkFrame_e dLytMeterDrinkParts_c::getDrinkFrame(dLytMeterDrinkParts_c::DrinkType_e type
+) const {
+    if (type == TYPE_STAMINA) {
+        if (FileManager::sInstance->getStaminaPotionPlusTimer()) {
+            return FRAME_STAMINA_PLUS;
+        }
+        if (FileManager::sInstance->getStaminaPotionTimer()) {
+            return FRAME_STAMINA;
+        }
+    }
+    if (type == TYPE_AIR) {
+        if (FileManager::sInstance->getAirPotionPlusTimer()) {
+            return FRAME_AIR_PLUS;
+        }
+        if (FileManager::sInstance->getAirPotionTimer()) {
+            return FRAME_AIR;
+        }
+    }
+    if (type == TYPE_GUARDIAN) {
+        if (FileManager::sInstance->getGuardianPotionPlusTimer()) {
+            return FRAME_GUARDIAN_PLUS;
+        }
+        if (FileManager::sInstance->getGuardianPotionTimer()) {
+            return FRAME_GUARDIAN;
+        }
+    }
+    return FRAME_NONE;
+}
+
+bool dLytMeterDrinkParts_c::isDrinkAboutToExpire() const {
+    if (field_0x48 == FRAME_STAMINA_PLUS) {
+        return FileManager::sInstance->getStaminaPotionPlusTimer() < 600;
+    } else if (field_0x48 == FRAME_STAMINA) {
+        return FileManager::sInstance->getStaminaPotionTimer() < 600;
+    } else if (field_0x48 == FRAME_AIR_PLUS) {
+        return FileManager::sInstance->getAirPotionPlusTimer() < 600;
+    } else if (field_0x48 == FRAME_AIR) {
+        return FileManager::sInstance->getAirPotionTimer() < 600;
+    } else if (field_0x48 == FRAME_GUARDIAN_PLUS) {
+        return FileManager::sInstance->getGuardianPotionPlusTimer() < 600;
+    } else if (field_0x48 == FRAME_GUARDIAN) {
+        return FileManager::sInstance->getGuardianPotionTimer() < 600;
+    }
+    return false;
+}
+
+void dLytMeterDrinkParts_c::copy(dLytMeterDrinkParts_c *other, dLytMeterDrinkParts_c *third) {
+    field_0x50 = other->field_0x50;
+    field_0x51 = 1;
+    field_0x48 = other->field_0x48;
+    mDrinkType = other->mDrinkType;
+    mStateMgr.changeState(*other->mStateMgr.getStateID());
+    if (third == nullptr) {
+        other->field_0x50 = 0;
+        other->field_0x51 = 1;
+        other->field_0x48 = FRAME_NONE;
+        other->mDrinkType = TYPE_NONE;
+        other->mStateMgr.changeState(StateID_Invisible);
+    } else {
+        other->field_0x50 = third->field_0x50;
+        other->field_0x51 = 1;
+        other->field_0x48 = third->field_0x48;
+        other->mDrinkType = third->mDrinkType;
+        other->mStateMgr.changeState(*third->mStateMgr.getStateID());
+
+        third->field_0x50 = 0;
+        third->field_0x51 = 1;
+        third->field_0x48 = FRAME_NONE;
+        third->mDrinkType = TYPE_NONE;
+        third->mStateMgr.changeState(StateID_Invisible);
+    }
+}
+
+static const char *sPanes[] = {
+    "N_drink_00",
+    "N_drink_01",
+    "N_drink_02",
+};
+
+static const d2d::LytBrlanMapping brlanMap[] = {
+    { "drink_00_demoIn.brlan", "G_demoInOut_00"},
+    {     "drink_00_in.brlan",     "G_inOut_00"},
+    {     "drink_00_in.brlan",     "G_inOut_01"},
+    {     "drink_00_in.brlan",     "G_inOut_02"},
+    {  "drink_00_drink.brlan",     "G_drink_00"},
+    {  "drink_00_drink.brlan",     "G_drink_01"},
+    {  "drink_00_drink.brlan",     "G_drink_02"},
+    {   "drink_00_loop.brlan",      "G_loop_00"},
+    {   "drink_00_loop.brlan",      "G_loop_01"},
+    {   "drink_00_loop.brlan",      "G_loop_02"},
+    {"drink_00_caution.brlan",   "G_caution_00"},
+    {"drink_00_caution.brlan",   "G_caution_01"},
+    {"drink_00_caution.brlan",   "G_caution_02"},
+    {   "drink_00_move.brlan",      "G_move_00"},
+    {   "drink_00_move.brlan",      "G_move_01"},
+    {   "drink_00_move.brlan",      "G_move_02"},
+    {    "drink_00_out.brlan",     "G_inOut_00"},
+    {    "drink_00_out.brlan",     "G_inOut_01"},
+    {    "drink_00_out.brlan",     "G_inOut_02"},
+    {"drink_00_demoOut.brlan", "G_demoInOut_00"},
+};
+
+#define LYT_METER_DRINK_OFFSET_ANIM_LOOP 7
+#define LYT_METER_DRINK_OFFSET_ANIM_CAUTION 10
+#define LYT_METER_DRINK_OFFSET_ANIM_MOVE 13
+
+#define LYT_METER_DRINK_ANIM_DEMO_OUT 19
+
+void dLytMeterDrink_c::initializeState_Invisible() {}
+void dLytMeterDrink_c::executeState_Invisible() {
+    if (field_0x6F4) {
+        mStateMgr.changeState(StateID_In);
+    }
+}
+void dLytMeterDrink_c::finalizeState_Invisible() {}
+
+void dLytMeterDrink_c::initializeState_In() {
+    mAnmGroups[0].setAnimEnable(true);
+    mAnmGroups[0].setFrame(0.0f);
+}
+void dLytMeterDrink_c::executeState_In() {
+    if (mAnmGroups[0].isEndReached()) {
+        mAnmGroups[0].setAnimEnable(false);
+        mStateMgr.changeState(StateID_Wait);
+    }
+    if (mAnmGroups[0].isFlag2()) {
+        mAnmGroups[0].play();
+    }
+}
+void dLytMeterDrink_c::finalizeState_In() {}
+
+void dLytMeterDrink_c::initializeState_Wait() {
+    field_0x6F0 = -1;
+}
+void dLytMeterDrink_c::executeState_Wait() {
+    int i5 = -1;
+    int i7 = -1;
+    for (int i = 0; i < 3; i++) {
+        int a = getPartForDrinkType((dLytMeterDrinkParts_c::DrinkType_e)i);
+        if (fn_800E5C40(i) != 0 && a == 3) {
+            i5 = i;
+        }
+        if (field_0x6F5[i] == 1 && mParts[i].field_0x50 == 0) {
+            i7 = i;
+        }
+    }
+
+    if (i5 >= 0) {
+        for (int i = 0; i < 3; i++) {
+            if (mParts[i].field_0x50 == 0 && i7 != i) {
+                mParts[i].field_0x50 = 1;
+                mParts[i].field_0x51 = 0;
+                mParts[i].field_0x48 = mParts[i].getDrinkFrame((dLytMeterDrinkParts_c::DrinkType_e)i5);
+                mParts[i].mDrinkType = (dLytMeterDrinkParts_c::DrinkType_e)i5;
+                break;
+            }
+        }
+    }
+
+    switch (i7) {
+        case 0:
+            if (mParts[1].field_0x50 != 0) {
+                field_0x6F0 = i7;
+                mStateMgr.changeState(StateID_Move);
+            }
+            break;
+        case 1:
+            if (mParts[2].field_0x50 != 0) {
+                field_0x6F0 = i7;
+                mStateMgr.changeState(StateID_Move);
+            }
+            break;
+    }
+    if (field_0x6F4 == 0) {
+        mStateMgr.changeState(StateID_Out);
+    }
+}
+void dLytMeterDrink_c::finalizeState_Wait() {}
+
+void dLytMeterDrink_c::initializeState_Move() {
+    for (int i = field_0x6F0; i < 3; i++) {
+        mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].setAnimEnable(true);
+        mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].setFrame(0.0f);
+    }
+}
+void dLytMeterDrink_c::executeState_Move() {
+    bool needsCopy = false;
+    for (int i = field_0x6F0; i < 3; i++) {
+        if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].isEndReached()) {
+            mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].setFrame(0.0f);
+            needsCopy = true;
+        }
+    }
+
+    if (needsCopy) {
+        if (field_0x6F0 == 0) {
+            if (mParts[1].field_0x50) {
+                mParts[0].copy(&mParts[1], &mParts[2]);
+            }
+        } else if (field_0x6F0 == 1 && mParts[2].field_0x50) {
+            mParts[1].copy(&mParts[2], nullptr);
+        }
+
+        mLyt.calc();
+
+        for (int i = 0; i < 3; i++) {
+            if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].isFlag2()) {
+                mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].setAnimEnable(false);
+            }
+        }
+        mStateMgr.changeState(StateID_Wait);
+    }
+
+    for (int i = 0; i < 3; i++) {
+        if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].isFlag2()) {
+            mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_MOVE + i].play();
+        }
+    }
+}
+void dLytMeterDrink_c::finalizeState_Move() {}
+
+void dLytMeterDrink_c::initializeState_Out() {
+    mAnmGroups[LYT_METER_DRINK_ANIM_DEMO_OUT].setAnimEnable(true);
+    mAnmGroups[LYT_METER_DRINK_ANIM_DEMO_OUT].setFrame(0.0f);
+}
+void dLytMeterDrink_c::executeState_Out() {
+    if (mAnmGroups[LYT_METER_DRINK_ANIM_DEMO_OUT].isEndReached()) {
+        mAnmGroups[LYT_METER_DRINK_ANIM_DEMO_OUT].setAnimEnable(false);
+        mStateMgr.changeState(StateID_Invisible);
+    }
+    if (mAnmGroups[LYT_METER_DRINK_ANIM_DEMO_OUT].isFlag2()) {
+        mAnmGroups[LYT_METER_DRINK_ANIM_DEMO_OUT].play();
+    }
+}
+void dLytMeterDrink_c::finalizeState_Out() {}
+
+bool dLytMeterDrink_c::build(d2d::ResAccIf_c *resAcc) {
+    mLyt.setResAcc(resAcc);
+    mLyt.build("drink_00.brlyt", nullptr);
+    for (int i = 0; i < 3; i++) {
+        mpPartPanes[i] = mLyt.findPane(sPanes[i]);
+    }
+
+    for (int i = 0; i < 20; i++) {
+        mAnmGroups[i].init(brlanMap[i].mFile, resAcc, mLyt.getLayout(), brlanMap[i].mName);
+        mAnmGroups[i].setDirection(false);
+        mAnmGroups[i].setAnimEnable(false);
+    }
+
+    for (int i = 0; i < 3; i++) {
+        mParts[i].mAnmGroups[0] = &mAnmGroups[1 + i];
+        mParts[i].mAnmGroups[1] = &mAnmGroups[4 + i];
+        mParts[i].mAnmGroups[2] = &mAnmGroups[16 + i];
+        mParts[i].init();
+        field_0x6F5[i] = mParts[i].field_0x50;
+    }
+
+    mpPane = mLyt.getLayout()->GetRootPane();
+
+    field_0x6F0 = -1;
+    field_0x6F4 = 0;
+    field_0x6E0.z = 0.0f;
+    field_0x6E0.y = 0.0f;
+    field_0x6E0.x = 0.0f;
+    mpPane->SetTranslate(field_0x6E0);
+
+    mAnmGroups[0].setFrame(0.0f);
+    mAnmGroups[0].setAnimEnable(true);
+    mLyt.calc();
+    mAnmGroups[0].setAnimEnable(false);
+
+    mStateMgr.changeState(StateID_Invisible);
+
+    return true;
+}
+
+bool dLytMeterDrink_c::execute() {
+    mStateMgr.executeState();
+
+    for (int i = 0; i < 3; i++) {
+        field_0x6F5[i] = mParts[i].field_0x50;
+        mParts[i].execute();
+    }
+
+    executeInternal();
+    mpPane->SetTranslate(field_0x6E0);
+    mLyt.calc();
+    return true;
+}
+
+bool dLytMeterDrink_c::remove() {
+    for (int i = 0; i < 20; i++) {
+        mAnmGroups[i].unbind();
+        mAnmGroups[i].afterUnbind();
+    }
+
+    return true;
+}
+
+bool dLytMeterDrink_c::draw() {
+    mLyt.addToDrawList();
+    return true;
+}
+
+int dLytMeterDrink_c::getPartForDrinkType(dLytMeterDrinkParts_c::DrinkType_e ty) const {
+    for (int i = 0; i < 3; i++) {
+        if (ty == mParts[i].mDrinkType) {
+            return i;
+        }
+    }
+    return 3;
+}
+
+bool dLytMeterDrink_c::fn_800E5C40(int i) {
+    if ((i == 0 || i == 3) && (FileManager::sInstance->getStaminaPotionTimer() != 0 ||
+                               FileManager::sInstance->getStaminaPotionPlusTimer() != 0)) {
+        return true;
+    }
+
+    if ((i == 1 || i == 3) &&
+        (FileManager::sInstance->getAirPotionTimer() != 0 || FileManager::sInstance->getAirPotionPlusTimer() != 0)) {
+        return true;
+    }
+
+    if ((i == 2 || i == 3) && (FileManager::sInstance->getGuardianPotionTimer() != 0 ||
+                               FileManager::sInstance->getGuardianPotionPlusTimer() != 0)) {
+        return true;
+    }
+
+    return false;
+}
+
+void dLytMeterDrink_c::executeInternal() {
+    bool bHasNotSoonExpiringDrink = false;
+    bool bHasSoonExpiringDrink = false;
+    bool drinksLast[3];
+
+    f32 frameLoop = 0.0f;
+    f32 frameCaution = 0.0f;
+
+    for (int i = 0; i < 3; i++) {
+        if (!mParts[i].isDrinkAboutToExpire()) {
+            drinksLast[i] = true;
+            bHasNotSoonExpiringDrink = true;
+            if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].isFlag2()) {
+                frameLoop = mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].getNextFrame();
+            }
+        } else {
+            drinksLast[i] = false;
+            bHasSoonExpiringDrink = true;
+            if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].isFlag2()) {
+                frameCaution = mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].getNextFrame();
+            }
+        }
+    }
+
+    if (bHasNotSoonExpiringDrink) {
+        for (int i = 0; i < 3; i++) {
+            if (drinksLast[i] == true) {
+                if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].isFlag2()) {
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].play();
+                } else {
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].setAnimEnable(true);
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].setFrame(frameLoop);
+                }
+
+                if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].isFlag2()) {
+                    bool oldVisible = mpPartPanes[i]->IsVisible();
+                    mpPartPanes[i]->SetVisible(true);
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].setFrame(0.0f);
+                    mLyt.calc();
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].setAnimEnable(false);
+                    mpPartPanes[i]->SetVisible(oldVisible);
+                }
+            }
+        }
+    } else {
+        for (int i = 0; i < 3; i++) {
+            if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].isFlag2()) {
+                bool oldVisible = mpPartPanes[i]->IsVisible();
+                mpPartPanes[i]->SetVisible(true);
+                mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].setFrame(0.0f);
+                mLyt.calc();
+                mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].setAnimEnable(false);
+                mpPartPanes[i]->SetVisible(oldVisible);
+            }
+        }
+    }
+
+    if (bHasSoonExpiringDrink) {
+        for (int i = 0; i < 3; i++) {
+            if (drinksLast[i] == false) {
+                if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].isFlag2()) {
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].play();
+                } else {
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].setAnimEnable(true);
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].setFrame(frameCaution);
+                }
+
+                if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].isFlag2()) {
+                    bool oldVisible = mpPartPanes[i]->IsVisible();
+                    mpPartPanes[i]->SetVisible(true);
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].setFrame(0.0f);
+                    mLyt.calc();
+                    mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_LOOP + i].setAnimEnable(false);
+                    mpPartPanes[i]->SetVisible(oldVisible);
+                }
+            }
+        }
+    } else {
+        for (int i = 0; i < 3; i++) {
+            if (mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].isFlag2()) {
+                bool oldVisible = mpPartPanes[i]->IsVisible();
+                mpPartPanes[i]->SetVisible(true);
+                mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].setFrame(0.0f);
+                mLyt.calc();
+                mAnmGroups[LYT_METER_DRINK_OFFSET_ANIM_CAUTION + i].setAnimEnable(false);
+                mpPartPanes[i]->SetVisible(oldVisible);
+            }
+        }
+    }
+}
@@ -1,8 +1,8 @@
 #include "d/t/d_t_switch.h"

-#include "c/c_math.h"
-#include "toBeSorted/event.h"
 #include "d/flag/sceneflag_manager.h"
+#include "s/s_Math.h"
+#include "toBeSorted/event.h"
 #include "toBeSorted/scgame.h"


@@ -144,7 +144,7 @@ void dTgSw_c::initializeState_On() {
    mTimer = 4;
 }
 void dTgSw_c::executeState_On() {
-    if (cM::calcTimer(&mTimer) == 0) {
+    if (sLib::calcTimer(&mTimer) == 0) {
        mStateMgr.changeState(StateID_OffWait);
    }
 }
@@ -173,7 +173,7 @@ void dTgSw_c::executeState_Off() {
        mActorEvent.scheduleEvent(event, 0);
        return;
    }
-    if (cM::calcTimer(&mTimer) == 0) {
+    if (sLib::calcTimer(&mTimer) == 0) {
        if (mThird2 == 1) {
            resetAllSwitches();
        } else if (mThird2 != 2) {
@@ -126,15 +126,15 @@ void Matrix34f::makeST(const Vector3f &s, const Vector3f &t) {
 }

 void Matrix34f::makeSQT(const Vector3f &s, const Quatf &q, const Vector3f &t) {
-    f32 yy = 2.0f * q.y * q.y;
-    f32 zz = 2.0f * q.z * q.z;
-    f32 xx = 2.0f * q.x * q.x;
-    f32 xy = 2.0f * q.x * q.y;
-    f32 xz = 2.0f * q.x * q.z;
-    f32 yz = 2.0f * q.y * q.z;
-    f32 wz = 2.0f * q.w * q.z;
-    f32 wx = 2.0f * q.w * q.x;
-    f32 wy = 2.0f * q.w * q.y;
+    f32 yy = 2.0f * q.v.y * q.v.y;
+    f32 zz = 2.0f * q.v.z * q.v.z;
+    f32 xx = 2.0f * q.v.x * q.v.x;
+    f32 xy = 2.0f * q.v.x * q.v.y;
+    f32 xz = 2.0f * q.v.x * q.v.z;
+    f32 yz = 2.0f * q.v.y * q.v.z;
+    f32 wz = 2.0f * q.w * q.v.z;
+    f32 wx = 2.0f * q.w * q.v.x;
+    f32 wy = 2.0f * q.w * q.v.y;

    m[0][0] = s.x * (1.0f - yy - zz);
    m[0][1] = s.y * (xy - wz);
@@ -154,15 +154,15 @@ void Matrix34f::makeSQT(const Vector3f &s, const Quatf &q, const Vector3f &t) {
 }

 void Matrix34f::makeQT(const Quatf &q, const Vector3f &t) {
-    f32 yy = 2.0f * q.y * q.y;
-    f32 zz = 2.0f * q.z * q.z;
-    f32 xx = 2.0f * q.x * q.x;
-    f32 xy = 2.0f * q.x * q.y;
-    f32 xz = 2.0f * q.x * q.z;
-    f32 yz = 2.0f * q.y * q.z;
-    f32 wz = 2.0f * q.w * q.z;
-    f32 wx = 2.0f * q.w * q.x;
-    f32 wy = 2.0f * q.w * q.y;
+    f32 yy = 2.0f * q.v.y * q.v.y;
+    f32 zz = 2.0f * q.v.z * q.v.z;
+    f32 xx = 2.0f * q.v.x * q.v.x;
+    f32 xy = 2.0f * q.v.x * q.v.y;
+    f32 xz = 2.0f * q.v.x * q.v.z;
+    f32 yz = 2.0f * q.v.y * q.v.z;
+    f32 wz = 2.0f * q.w * q.v.z;
+    f32 wx = 2.0f * q.w * q.v.x;
+    f32 wy = 2.0f * q.w * q.v.y;

    m[0][0] = 1.0f - yy - zz;
    m[0][1] = xy - wz;
@@ -182,15 +182,15 @@ void Matrix34f::makeQT(const Quatf &q, const Vector3f &t) {
 }

 void Matrix34f::makeQ(const Quatf &q) {
-    f32 yy = 2.0f * q.y * q.y;
-    f32 zz = 2.0f * q.z * q.z;
-    f32 xx = 2.0f * q.x * q.x;
-    f32 xy = 2.0f * q.x * q.y;
-    f32 xz = 2.0f * q.x * q.z;
-    f32 yz = 2.0f * q.y * q.z;
-    f32 wz = 2.0f * q.w * q.z;
-    f32 wx = 2.0f * q.w * q.x;
-    f32 wy = 2.0f * q.w * q.y;
+    f32 yy = 2.0f * q.v.y * q.v.y;
+    f32 zz = 2.0f * q.v.z * q.v.z;
+    f32 xx = 2.0f * q.v.x * q.v.x;
+    f32 xy = 2.0f * q.v.x * q.v.y;
+    f32 xz = 2.0f * q.v.x * q.v.z;
+    f32 yz = 2.0f * q.v.y * q.v.z;
+    f32 wz = 2.0f * q.w * q.v.z;
+    f32 wx = 2.0f * q.w * q.v.x;
+    f32 wy = 2.0f * q.w * q.v.y;

    m[0][0] = 1.0f - yy - zz;
    m[0][1] = xy - wz;
@@ -240,17 +240,17 @@ void Matrix34f::makeT(const Vector3f &t) {
 }

 void Matrix34f::fromQuat(const Quatf &q) {
-    m[0][0] = 1.0f - (2 * q.y * q.y) - (2.0f * q.z * q.z);
-    m[0][1] = (2.0f * q.x * q.y) - (2.0f * q.w * q.z);
-    m[0][2] = (2.0f * q.x * q.z) + (2.0f * q.w * q.y);
+    m[0][0] = 1.0f - (2 * q.v.y * q.v.y) - (2.0f * q.v.z * q.v.z);
+    m[0][1] = (2.0f * q.v.x * q.v.y) - (2.0f * q.w * q.v.z);
+    m[0][2] = (2.0f * q.v.x * q.v.z) + (2.0f * q.w * q.v.y);

-    m[1][0] = (2.0f * q.x * q.y) + (2.0f * q.w * q.z);
-    m[1][1] = 1.0f - (2.0f * q.x * q.x) - (2.0f * q.z * q.z);
-    m[1][2] = (2.0f * q.y * q.z) - (2.0f * q.w * q.x);
+    m[1][0] = (2.0f * q.v.x * q.v.y) + (2.0f * q.w * q.v.z);
+    m[1][1] = 1.0f - (2.0f * q.v.x * q.v.x) - (2.0f * q.v.z * q.v.z);
+    m[1][2] = (2.0f * q.v.y * q.v.z) - (2.0f * q.w * q.v.x);

-    m[2][0] = (2.0f * q.x * q.z) - (2.0f * q.w * q.y);
-    m[2][1] = (2.0f * q.y * q.z) + (2.0f * q.w * q.x);
-    m[2][2] = 1.0f - (2.0f * q.x * q.x) - (2.0f * q.y * q.y);
+    m[2][0] = (2.0f * q.v.x * q.v.z) - (2.0f * q.w * q.v.y);
+    m[2][1] = (2.0f * q.v.y * q.v.z) + (2.0f * q.w * q.v.x);
+    m[2][2] = 1.0f - (2.0f * q.v.x * q.v.x) - (2.0f * q.v.y * q.v.y);

    m[2][3] = 0.0f;
    m[1][3] = 0.0f;
@@ -298,38 +298,38 @@ void Matrix34f::toQuat(Quatf &q) const {
    switch (tempMax) {
        case 0:
            q.w = Math<f32>::sqrt(temp0);
-            q.x = (0.25f / q.w) * (m[2][1] - m[1][2]);
-            q.y = (0.25f / q.w) * (m[0][2] - m[2][0]);
-            q.z = (0.25f / q.w) * (m[1][0] - m[0][1]);
+            q.v.x = (0.25f / q.w) * (m[2][1] - m[1][2]);
+            q.v.y = (0.25f / q.w) * (m[0][2] - m[2][0]);
+            q.v.z = (0.25f / q.w) * (m[1][0] - m[0][1]);
            break;
        case 1:
-            q.x = Math<f32>::sqrt(temp1);
-            q.w = (0.25f / q.x) * (m[2][1] - m[1][2]);
-            q.y = (0.25f / q.x) * (m[0][1] + m[1][0]);
-            q.z = (0.25f / q.x) * (m[0][2] + m[2][0]);
+            q.v.x = Math<f32>::sqrt(temp1);
+            q.w = (0.25f / q.v.x) * (m[2][1] - m[1][2]);
+            q.v.y = (0.25f / q.v.x) * (m[0][1] + m[1][0]);
+            q.v.z = (0.25f / q.v.x) * (m[0][2] + m[2][0]);
            break;
        case 2:
-            q.y = Math<f32>::sqrt(temp2);
-            q.w = (0.25f / q.y) * (m[0][2] - m[2][0]);
-            q.z = (0.25f / q.y) * (m[1][2] + m[2][1]);
-            q.x = (0.25f / q.y) * (m[1][0] + m[0][1]);
+            q.v.y = Math<f32>::sqrt(temp2);
+            q.w = (0.25f / q.v.y) * (m[0][2] - m[2][0]);
+            q.v.z = (0.25f / q.v.y) * (m[1][2] + m[2][1]);
+            q.v.x = (0.25f / q.v.y) * (m[1][0] + m[0][1]);
            break;
        case 3:
-            q.z = Math<f32>::sqrt(temp3);
-            q.w = (0.25f / q.z) * (m[1][0] - m[0][1]);
-            q.x = (0.25f / q.z) * (m[2][0] + m[0][2]);
-            q.y = (0.25f / q.z) * (m[2][1] + m[1][2]);
+            q.v.z = Math<f32>::sqrt(temp3);
+            q.w = (0.25f / q.v.z) * (m[1][0] - m[0][1]);
+            q.v.x = (0.25f / q.v.z) * (m[2][0] + m[0][2]);
+            q.v.y = (0.25f / q.v.z) * (m[2][1] + m[1][2]);
            break;
        default: break;
    }

    if (q.w < 0.0f) {
        q.w = -q.w;
-        q.x = -q.x;
-        q.y = -q.y;
-        q.z = -q.z;
+        q.v.x = -q.v.x;
+        q.v.y = -q.v.y;
+        q.v.z = -q.v.z;
    }
-    q.multScalar(Math<f32>::inv(q.length()));
+    q.multScalar(Math<f32>::inv(Math<f32>::sqrt(q.w * q.w + q.v.dot(q.v))));
 }

 void Matrix34f::slerpTo(const Matrix34f &m2, Matrix34f &out, f32 t) const {
@@ -5,9 +5,9 @@ namespace EGG {
 /* 8049b390 */
 void Quatf::set(f32 fw, f32 fx, f32 fy, f32 fz) {
    w = fw;
-    x = fx;
-    y = fy;
-    z = fz;
+    v.x = fx;
+    v.y = fy;
+    v.z = fz;
 }

 void Quatf::set(f32 fw, const Vector3f &vec) {
@@ -30,9 +30,9 @@ void Quatf::setRPY(const EGG::Vector3f &rpy) {
    const f32 sy_cp = sy * cp;

    w = (cy_cp * cr) + (sy_sp * sr);
-    x = (cy_cp * sr) - (sy_sp * cr);
-    y = (cy_sp * cr) + (sy_cp * sr);
-    z = (sy_cp * cr) - (cy_sp * sr);
+    v.x = (cy_cp * sr) - (sy_sp * cr);
+    v.y = (cy_sp * cr) + (sy_cp * sr);
+    v.z = (sy_cp * cr) - (cy_sp * sr);
 }

 /* NOT IN SS */
@@ -84,7 +84,7 @@ void Quatf::setAxisRotation(const Vector3f &axis, f32 rot) {

 /* 8049b450 */
 f32 Quatf::norm() {
-    return w * w + Vector3f::dot(*this);
+    return w * w + v.dot(v);
 }

 /* 8049b480 */
@@ -99,7 +99,7 @@ void Quatf::normalise() {
 Quatf Quatf::conjugate() {
    Quatf q;
    q.w = w;
-    (Vector3f &)q = -1.0f * *this;
+    q.v = -1.0f * v;
    return q;
 }

@@ -109,7 +109,7 @@ Vector3f Quatf::rotateVector(const Vector3f &vec) {
    conj = conjugate();
    mult = *this * vec;
    mult = mult * conj;
-    return (mult);
+    return (mult.v);
 }

 // /* NOT IN SS */
@@ -122,7 +122,7 @@ Vector3f Quatf::rotateVector(const Vector3f &vec) {

 /* 8049b800 */
 void Quatf::slerpTo(const Quatf &q2, f32 t, Quatf &out) const {
-    f32 dot = x * q2.x + y * q2.y + z * q2.z + w * q2.w;
+    f32 dot = v.x * q2.v.x + v.y * q2.v.y + v.z * q2.v.z + w * q2.w;

    if (dot > 1.0f) {
        dot = 1.0f;
@@ -156,9 +156,9 @@ void Quatf::slerpTo(const Quatf &q2, f32 t, Quatf &out) const {
        b = -b;
    }

-    out.x = a * x + b * q2.x;
-    out.y = a * y + b * q2.y;
-    out.z = a * z + b * q2.z;
+    out.v.x = a * v.x + b * q2.v.x;
+    out.v.y = a * v.y + b * q2.v.y;
+    out.v.z = a * v.z + b * q2.v.z;
    out.w = a * w + b * q2.w;
 }

@@ -166,7 +166,7 @@ void Quatf::slerpTo(const Quatf &q2, f32 t, Quatf &out) const {
 void Quatf::limitSlerpTo(const Quatf &q2, f32 t, f32 t2, Quatf &out) const {
    t2 *= 0.5f;

-    f32 dot = x * q2.x + y * q2.y + z * q2.z + w * q2.w;
+    f32 dot = v.x * q2.v.x + v.y * q2.v.y + v.z * q2.v.z + w * q2.w;

    if (dot > 1.0f) {
        dot = 1.0f;
@@ -204,9 +204,9 @@ void Quatf::limitSlerpTo(const Quatf &q2, f32 t, f32 t2, Quatf &out) const {
        b = -b;
    }

-    out.x = a * x + b * q2.x;
-    out.y = a * y + b * q2.y;
-    out.z = a * z + b * q2.z;
+    out.v.x = a * v.x + b * q2.v.x;
+    out.v.y = a * v.y + b * q2.v.y;
+    out.v.z = a * v.z + b * q2.v.z;
    out.w = a * w + b * q2.w;
 }

@@ -10,7 +10,6 @@
 #include "nw4r/g3d/g3d_scnmdlsmpl.h"
 #include "nw4r/g3d/g3d_state.h"

-
 // All of this is completely made up, as we don't have symbols for this TU
 // (contrary to the rest of m3d and most of nw4r::g3d)

@@ -362,7 +361,7 @@ void mShadow_c::drawAllShadows() {
        GXSetCullMode(GX_CULL_BACK);
        GXSetDither(0);
        GXSetClipMode(GX_CLIP_DISABLE);
-        GXLoadPosMtxImm(mMtx_c::Identity.m, 0);
+        GXLoadPosMtxImm(mMtx_c::Identity, 0);
        GXSetCurrentMtx(0);
        Mtx44 mtx;
        C_MTXOrtho(mtx, 0.0f, wid, 0.0f, wid, 0.0f, 1.0f);
@@ -484,12 +483,12 @@ bool mShadowChild_c::addMdl(scnLeaf_c &mdl, const mQuat_c &quat) {
    if (mdl.getType() == 0) {
        mdl.getLocalMtx(mtx);
    } else {
-        mtx.set(static_cast<mCustomShadow_c &>(mdl).mMtx);
+        mtx.copyFrom(static_cast<mCustomShadow_c &>(mdl).mMtx);
    }

    // TODO this copy is a bit weird (reads members in a different order)
    mQuat_c q = quat;
-    PSMTXMultVec(mtx.m, q, q);
+    PSMTXMultVec(mtx.m, q.v, q.v);

    if (mNumLeaves == 0) {
        mQuat = q;
@@ -502,7 +501,7 @@ bool mShadowChild_c::addMdl(scnLeaf_c &mdl, const mQuat_c &quat) {

 bool mShadowChild_c::setGeom(const GXTexObj *texObj, const mMtx_c &mtx, const mQuat_c &quat) {
    mQuat = quat;
-    PSMTXMultVec(mtx.m, mQuat, mQuat);
+    PSMTXMultVec(mtx.m, mQuat.v, mQuat.v);
    if (texObj == nullptr) {
        mTexObj = *mShadow_c::sTexObj;
    } else {
@@ -614,7 +613,7 @@ void mCustomShadow_c::calc(mMtx_c mtx, mMtx_c &mtx2) {
    // TODO some shuffles

    mVec3_c trans;
-    mtx2.set(mMtx);
+    mtx2.copyFrom(mMtx);
    mVec3_c offset(0.0f, 0.0f, 0.0f);
    offset.y = field_0x48;
    PSMTXMultVec(mtx2, offset, trans);
@@ -1,4 +1,5 @@
 #include "m/m_angle.h"
+
 #include "math.h"

 /** 80575c08 */
@@ -7,7 +8,7 @@ mAng3_c mAng3_c::Zero = mAng3_c(0, 0, 0);
 const f32 mAng::sHalfCircleDeg = 360.0f / 2;
 const f32 mAng::sAngToDeg = 360.0f / (1 << 16);
 const f32 mAng::sAngToRad = 2 * M_PI / (1 << 16);
-const f32 mAng::NotSure = 2.0f / (1 << 16);
+const f32 mAng::sAngToNorm = 2.0f / (1 << 16);
 const f32 mAng::sDegToRad = M_PI / 180.0f;
 const f32 mAng::sDegToAng = (1 << 16) / 360.0f;
 const f32 mAng::sRadToAng = (1 << 16) / (2 * M_PI);
@@ -72,12 +72,15 @@ bool DowsingTarget::hasDesertNodeDowsing() {
    return StoryflagManager::sInstance->getCounterOrFlag(107) && !StoryflagManager::sInstance->getCounterOrFlag(8);
 }

+inline bool checkTrial(u16 itemflag, u16 storyflag) {
+    return (ItemflagManager::sInstance->getFlagDirect(itemflag) && !StoryflagManager::sInstance->getCounterOrFlag(storyflag)) ? true : false;
+}
+
 bool DowsingTarget::hasAnyTrialDowsing() {
-    // TODO more complicated code
-    return ItemflagManager::sInstance->getFlag(187) && !StoryflagManager::sInstance->getCounterOrFlag(93) ||
-           ItemflagManager::sInstance->getFlag(188) && !StoryflagManager::sInstance->getCounterOrFlag(97) ||
-           ItemflagManager::sInstance->getFlag(189) && !StoryflagManager::sInstance->getCounterOrFlag(98) ||
-           ItemflagManager::sInstance->getFlag(193) && !StoryflagManager::sInstance->getCounterOrFlag(99);
+    return checkTrial(187, 93) ||
+           checkTrial(188, 97) ||
+           checkTrial(189, 98) ||
+           checkTrial(193, 99);
 }

 bool DowsingTarget::hasSacredWaterDowsing() {
@@ -171,18 +171,18 @@ u16 *FileManager::getStoryFlagsMut() {
 /* 8000B670 */ void FileManager::setShieldPouchSlot(u8 slot) {}
 /* 8000B6A0 */ u8 FileManager::getShieldPouchSlot() {}

-/* 8000B6F0 */ void FileManager::setAirPotionTimer(s16 time) {}
-/* 8000B720 */ s16 FileManager::getAirPotionTimer() {}
-/* 8000B770 */ void FileManager::setAirPotionPlusTimer(s16 time) {}
-/* 8000B7A0 */ s16 FileManager::getAirPotionPlusTimer() {}
-/* 8000B7F0 */ void FileManager::setStaminaPotionTimer(s16 time) {}
-/* 8000B820 */ s16 FileManager::getStaminaPotionTimer() {}
-/* 8000B870 */ void FileManager::setStaminaPotionPlusTimer(s16 time) {}
-/* 8000B8A0 */ s16 FileManager::getStaminaPotionPlusTimer() {}
-/* 8000B8F0 */ void FileManager::setGuardianPotionTimer(s16 time) {}
-/* 8000B920 */ s16 FileManager::getGuardianPotionTimer() {}
-/* 8000B970 */ void FileManager::setGuardianPotionPlusTimer(s16 time) {}
-/* 8000B9A0 */ s16 FileManager::getGuardianPotionPlusTimer() {}
+/* 8000B6F0 */ void FileManager::setAirPotionTimer(u16 time) {}
+/* 8000B720 */ u16 FileManager::getAirPotionTimer() {}
+/* 8000B770 */ void FileManager::setAirPotionPlusTimer(u16 time) {}
+/* 8000B7A0 */ u16 FileManager::getAirPotionPlusTimer() {}
+/* 8000B7F0 */ void FileManager::setStaminaPotionTimer(u16 time) {}
+/* 8000B820 */ u16 FileManager::getStaminaPotionTimer() {}
+/* 8000B870 */ void FileManager::setStaminaPotionPlusTimer(u16 time) {}
+/* 8000B8A0 */ u16 FileManager::getStaminaPotionPlusTimer() {}
+/* 8000B8F0 */ void FileManager::setGuardianPotionTimer(u16 time) {}
+/* 8000B920 */ u16 FileManager::getGuardianPotionTimer() {}
+/* 8000B970 */ void FileManager::setGuardianPotionPlusTimer(u16 time) {}
+/* 8000B9A0 */ u16 FileManager::getGuardianPotionPlusTimer() {}

 /* 8000B9F0 */ void FileManager::setDowsingSlotIdx(u8 idx) {}
 /* 8000BA20 */ u8 FileManager::getDowsingSlotIdx() {}
@@ -1,51 +1,514 @@
 #include "toBeSorted/special_item_drop_mgr.h"

+#include "c/c_lib.h"
+#include "c/c_math.h"
+#include "common.h"
 #include "d/a/d_a_player.h"
-#include "m/m_Angle.h"
+#include "d/a/obj/d_a_obj_item.h"
+#include "m/m_angle.h"
 #include "m/m_vec.h"

 SpecialItemDropMgr *SpecialItemDropMgr::sInstance = nullptr;

-extern "C" short targetAngleY(mVec3_c *, mVec3_c *);
-extern "C" int rndInt(int);
-extern "C" void spawnItem1(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem2(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem3(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem4(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem5(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem6(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem7(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem8(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
-extern "C" void spawnItem9(s16 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
+extern "C" void spawnItem1(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
+extern "C" void spawnItem2(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
+extern "C" void spawnItem3(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
+extern "C" void spawnItem4(u32 itemid, u32, u32 param2);
+extern "C" void spawnItem5(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
+extern "C" void spawnItem6(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
+extern "C" void spawnItem7(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, u32 param2, u32 unk);
+extern "C" void spawnItem8(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot, void *, void *, u32 param2, u32 unk);
+extern "C" void spawnItem9(u32 itemid, u32 roomid, mVec3_c *pos, mAng3_c *rot);

 // 800c7b80
 SpecialItemDropMgr::SpecialItemDropMgr() {
    SpecialItemDropMgr::sInstance = this;
 }

+SpecialItemDropMgr *SpecialItemDropMgr::create() {
+    return new SpecialItemDropMgr();
+}
+
+struct DropEntry {
+    /* 0x0 */ u8 mEntryIndex;
+    /* 0x1 */ u8 mDropChance;
+};
+
+struct DropList {
+    /* 0x0 */ u16 mLen;
+    /* 0x2 */ u16 mFlags;
+    /* 0x4 */ const DropEntry *mpEntries;
+};
+
+static const DropEntry e01[] = {
+    {0x01, 20},
+    {0x03, 40},
+    {0x04, 10},
+};
+
+static const DropEntry e02[] = {
+    {0x01, 20},
+    {0x03, 10},
+    {0x04, 40},
+};
+
+static const DropEntry e03[] = {
+    {0x01, 20},
+    {0x04, 25},
+    {0x05, 25},
+};
+
+static const DropEntry e04[] = {
+    {0x01, 100},
+};
+
+static const DropEntry e05[] = {
+    {0x01, 60},
+    {0x02, 10},
+};
+
+static const DropEntry e06[] = {
+    {0x02, 100},
+};
+
+static const DropEntry e07[] = {
+    {0x03, 40},
+    {0x04, 10},
+};
+
+static const DropEntry e08[] = {
+    {0x03, 50},
+    {0x04, 40},
+    {0x05, 10},
+};
+
+static const DropEntry e09[] = {
+    {0x04, 70},
+    {0x05, 30},
+};
+
+static const DropEntry e10[] = {
+    {0x06, 100},
+};
+
+static const DropEntry e11[] = {
+    {0x08, 100},
+};
+
+static const DropEntry e12[] = {
+    {0x0A, 100},
+};
+
+static const DropEntry e13[] = {
+    {0x0B, 100},
+};
+
+static const DropEntry e14[] = {
+    {0x0C, 100},
+};
+
+static const DropEntry e15[] = {
+    {0x0D, 100},
+};
+
+static const DropEntry e16[] = {
+    {0x03, 7},
+    {0x04, 3},
+};
+
+static const DropEntry e17[] = {
+    {0x01, 7},
+    {0x03, 3},
+};
+
+static const DropEntry e18[] = {
+    {0x03, 100},
+};
+
+static const DropEntry e19[] = {
+    {0x04, 100},
+};
+
+static const DropEntry e20[] = {
+    {0x05, 100},
+};
+
+static const DropEntry e21[] = {
+    {0x0E, 100},
+};
+
+static const DropEntry e22[] = {
+    {0x0F, 100},
+};
+
+static const DropEntry e23[] = {
+    {0x03, 60},
+    {0x04, 30},
+    {0x0F, 10},
+};
+
+static const DropEntry e24[] = {
+    {0x03, 30},
+    {0x04, 30},
+    {0x05, 20},
+    {0x0F, 20},
+};
+
+static const DropEntry e25[] = {
+    {0x10, 100},
+};
+
+static const DropEntry e26[] = {
+    {0x12, 100},
+};
+
+static const DropEntry e27[] = {
+    {0x13, 100},
+};
+
+static const DropEntry e28[] = {
+    {0x14, 100},
+};
+
+static const DropEntry e29[] = {
+    {0x10, 10},
+};
+
+static const DropEntry e30[] = {
+    {0x0B, 100},
+};
+
+static const DropEntry e31[] = {
+    {0x01, 100},
+};
+
+static const DropEntry e32[] = {
+    {0x01, 12},
+};
+
+static const DropEntry e33[] = {
+    {0x01, 35},
+};
+
+static const DropEntry e34[] = {
+    {0x16, 30},
+    {0x15, 10},
+    {0x02, 20},
+    {0x01, 20},
+};
+
+static const DropEntry e35[] = {
+    {0x15, 100},
+};
+
+static const DropEntry e36[] = {
+    {0x16, 100},
+};
+
+static const DropEntry e37[] = {
+    {0x01, 20},
+    {0x03, 30},
+    {0x04, 15},
+};
+
+static const DropEntry e38[] = {
+    {0x04, 30},
+    {0x05,  5},
+    {0x03, 45},
+};
+
+static const DropEntry e39[] = {
+    {0x01, 10},
+};
+
+static const DropEntry e40[] = {
+    {0x03, 10},
+    {0x04,  5},
+};
+
+static const DropEntry e41[] = {
+    {0x17, 100},
+};
+
+static const DropEntry e42[] = {
+    {0x01, 20},
+};
+
+static const DropEntry e44[] = {
+    {0x01, 7},
+};
+
+static const DropEntry e45[] = {
+    {0x03, 14},
+    {0x04,  6},
+};
+
+static const DropEntry e46[] = {
+    {0x01,  7},
+    {0x03, 13},
+};
+
+static const DropEntry e47[] = {
+    {0x18, 100},
+};
+
+static const DropEntry e48[] = {
+    {0x01, 7},
+};
+
+static const DropEntry e49[] = {
+    {0x01, 14},
+};
+
+static const DropEntry e50[] = {
+    {0x01, 50},
+};
+
+static const DropEntry e51[] = {
+    {0x0B, 20},
+    {0x03, 20},
+    {0x04, 10},
+};
+
+static const DropEntry e52[] = {
+    {0x0A, 60},
+    {0x01, 20},
+    {0x04, 20},
+};
+
+static const DropEntry e53[] = {
+    {0x08, 20},
+    {0x0A, 20},
+    {0x0B, 20},
+    {0x03, 10},
+    {0x04,  5},
+};
+
+#define FLAG_EXTRA_HEARTS 1
+#define FLAG_EXTRA_RUPEES 2
+
+#define FLAG_EXTRA_ALL (FLAG_EXTRA_HEARTS | FLAG_EXTRA_RUPEES)
+
+static const DropList sList[] = {
+    {0,                 0, nullptr},
+    {3,    FLAG_EXTRA_ALL,     e01},
+    {3,    FLAG_EXTRA_ALL,     e02},
+    {3,    FLAG_EXTRA_ALL,     e03},
+    {1,    FLAG_EXTRA_ALL,     e04},
+    {2,    FLAG_EXTRA_ALL,     e05},
+    {1,    FLAG_EXTRA_ALL,     e06},
+    {2,    FLAG_EXTRA_ALL,     e07},
+    {3,    FLAG_EXTRA_ALL,     e08},
+    {2,    FLAG_EXTRA_ALL,     e09},
+    {1,                 0,     e10},
+    {1,                 0,     e11},
+    {1,                 0,     e12},
+    {1,                 0,     e13},
+    {1,                 0,     e14},
+    {1,                 0,     e15},
+    {2,    FLAG_EXTRA_ALL,     e16},
+    {2,    FLAG_EXTRA_ALL,     e17},
+    {1,                 0,     e18},
+    {1,                 0,     e19},
+    {1,                 0,     e20},
+    {1,                 0,     e21},
+    {1,                 0,     e22},
+    {3,    FLAG_EXTRA_ALL,     e23},
+    {4,    FLAG_EXTRA_ALL,     e24},
+    {1,                 0,     e25},
+    {1,                 0,     e26},
+    {1,                 0,     e27},
+    {1,                 0,     e28},
+    {1,                 0,     e29},
+    {1,                 0,     e30},
+    {1,    FLAG_EXTRA_ALL,     e31},
+    {1,    FLAG_EXTRA_ALL,     e32},
+    {1,    FLAG_EXTRA_ALL,     e33},
+    {4,    FLAG_EXTRA_ALL,     e34},
+    {1,                 0,     e35},
+    {1,                 0,     e36},
+    {3,    FLAG_EXTRA_ALL,     e37},
+    {3,    FLAG_EXTRA_ALL,     e38},
+    {1,                 0,     e39},
+    {2,                 0,     e40},
+    {1,                 0,     e41},
+    {1, FLAG_EXTRA_HEARTS,     e42},
+    {0,                 0, nullptr},
+    {1, FLAG_EXTRA_HEARTS,     e44},
+    {2,    FLAG_EXTRA_ALL,     e45},
+    {2,    FLAG_EXTRA_ALL,     e46},
+    {1,                 0,     e47},
+    {1, FLAG_EXTRA_HEARTS,     e48},
+    {1, FLAG_EXTRA_HEARTS,     e49},
+    {1,                 0,     e50},
+    {3,    FLAG_EXTRA_ALL,     e51},
+    {3,                 0,     e52},
+    {5, FLAG_EXTRA_RUPEES,     e53},
+};
+
+struct LowHealthReplacement {
+    s32 mOriginalIdx;
+    s32 mReplacementIndex;
+};
+
+const LowHealthReplacement LOW_HEALTH_REPLACEMENTS[] = {
+    {
+     0x10, 0x11,
+     },
+    {
+     0x1E, 0x1F,
+     },
+    {
+     0x2B, 0x2C,
+     },
+    {
+     0x2D, 0x2E,
+     },
+};
+
 // TODO: Convert to enum once work on items has started
-int SPECIAL_ITEM_ARRAY[28] = {0,    6,    6,  2,  3,   4,   0x2b, 0x28, 0x29, 7, 8,  0x39, 0, 0,
-                              0x1c, 0xa5, 58, 59, 183, 184, 185,  72,   72,   1, 34, 0,    0, 0};
-int RAND_RUPEE_ARRAY[4] = {2, 3, 4, 0};
+static const u16 SPECIAL_ITEM_ARRAY[] = {
+    0,    // None
+    6,    // Heart
+    6,    // Heart
+    2,    // Green Rupee
+    3,    // Blue Rupee
+    4,    // Red Rupee
+    0x2b, // Farore Tear
+    0x28, // 5 Bombs
+    0x29, // 10 Bombs
+    7,    // Single Arrow
+    8,    // Bundle Arrows
+    0x39, // 5 Deku Seeds
+    0,    // None
+    0,    // None
+    0x1c, // ET Key Piece
+    0xa5, // Eldin Ore
+    58,   // ???
+    59,   // ???
+    183,  // ???
+    184,  // ???
+    185,  // ???
+    72,   // Fairy
+    72,   // Fairy
+    1,    // Small Key
+    34,   // Rupoor
+};
+
+static const u32 sNumDropEntries = 0x36;
+static const struct {
+    u16 mNumEntries;
+    const DropList *mList;
+} sDropTable = {
+    0x36,
+    sList,
+};
+
+static const u16 RAND_RUPEE_ARRAY[] = {2, 3, 4};
+
+extern "C" int getCurrentBowType();
+extern "C" int getCurrentSlingshotType();
+extern "C" bool isHeroMode();

 // 800c7bb0
-int fn_800C7BB0(SpecialItemDropMgr *mgr, int specialItemId) {}
+int SpecialItemDropMgr::fn_800C7BB0(int specialItemId) {
+    const DropList *list = &sDropTable.mList[specialItemId];
+    const DropEntry *e = list->mpEntries;
+    int random = cM::rndInt(100);

-// 800c7d00
-short fn_800C7D00(SpecialItemDropMgr *mgr, int specialItemId) {}
+    int acc = 0;

-// 800c7d20
-short fn_800C7D20(SpecialItemDropMgr *mgr, int specialItemId) {}
+    for (int i = 0; i < list->mLen; i++) {
+        int entryIdx = e->mEntryIndex;
+        int weight = e->mDropChance;
+
+        if (entryIdx == 9 || entryIdx == 10) {
+            if (getCurrentBowType() == 0) {
+                // No arrows until you get the Bow
+                weight = 0;
+            }
+        } else if (entryIdx == 11) {
+            if (getCurrentSlingshotType() == 0) {
+                // No seeds until you get the Slingshot
+                weight = 0;
+            }
+        } else if (specialItemId != 0x27 && (entryIdx == 1 || entryIdx == 2) && isHeroMode()) {
+            // Hearts generally don't drop on Hero Mode unless it's a special kind of heart (which?)
+            weight = 0;
+        } else if ((entryIdx == 7 || entryIdx == 8) && !dAcItem_c::checkFlag(/* Bomb Bag */ 92)) {
+            // Bombs won't drop until you get the Bomb Bag
+            weight = 0;
+        }
+
+        if (weight != 0) {
+            int x = 0x1E / weight;
+            acc += weight;
+            if (x != 0) {
+                int tmp = x <= 3 ? x : 3;
+                if (random % tmp != 0) {
+                    return 0;
+                }
+            }
+
+            if (random < acc) {
+                return entryIdx;
+            }
+        }
+        e++;
+    }
+
+    return 0;
+}
+
+bool SpecialItemDropMgr::shouldTryExtraHearts(int specialItemId) {
+    return sDropTable.mList[specialItemId].mFlags & FLAG_EXTRA_HEARTS;
+}
+bool SpecialItemDropMgr::shouldTryExtraRupees(int specialItemId) {
+    return sDropTable.mList[specialItemId].mFlags & FLAG_EXTRA_RUPEES;
+}
+
+extern "C" bool adventurePouchCountItem(u32 itemId);

 // 800c7d40
-int giveSpecialDropItem(
-    SpecialItemDropMgr *mgr, int specialItemId, int roomid, mVec3_c *pos, int subtype, s16 *rot, s32 unused
-) {}
+int SpecialItemDropMgr::giveSpecialDropItem(
+    int specialItemId, int roomid, mVec3_c *pos, int subtype, mAng rot, s32 unused
+) {
+    if (specialItemId == 0xFF) {
+        return 0;
+    }
+
+    for (u32 i = 0; i < 4; i++) {
+        const LowHealthReplacement &entry = LOW_HEALTH_REPLACEMENTS[i];
+        if (specialItemId == entry.mOriginalIdx && dAcPy_c::LINK->hasLessThanQuarterHealth(false)) {
+            specialItemId = entry.mReplacementIndex;
+            break;
+        }
+    }
+
+    bool ret = spawnSpecialDropItem(specialItemId, roomid, pos, subtype, rot);
+    if (shouldTryExtraHearts(specialItemId)) {
+        for (u32 i = 0; i < adventurePouchCountItem(/* HEART_MEDAL */ 100); i++) {
+            bool ok = spawnSpecialDropItem(0x27, roomid, pos, subtype, rot);
+            ret |= ok;
+        }
+    }
+
+    if (shouldTryExtraRupees(specialItemId)) {
+        for (u32 i = 0;
+             i < adventurePouchCountItem(/* RUPEE_MEDAL */ 101) + adventurePouchCountItem(/* CURSED_MEDAL */ 104);
+             i++) {
+            bool ok = spawnSpecialDropItem(0x28, roomid, pos, subtype, rot);
+            ret |= ok;
+        }
+    }
+
+    return ret;
+}

 // 800c7ef0
 // Very unmatching. Just here as a starting point
-bool spawnSpecialDropItem(SpecialItemDropMgr *mgr, int specialItemId, int roomid, mVec3_c *pos, int subtype, s16 *rot) {
-    u32 unk = fn_800C7BB0(mgr, specialItemId);
+bool SpecialItemDropMgr::spawnSpecialDropItem(int specialItemId, int roomid, mVec3_c *pos, int subtype, mAng rot) {
+    s32 unk = fn_800C7BB0(specialItemId);
    if (unk == 0) {
        return false;
    }
@@ -61,31 +524,31 @@ bool spawnSpecialDropItem(SpecialItemDropMgr *mgr, int specialItemId, int roomid
        itemCount = 2;
    }

-    s16 currentRot;
-    s16 tempOther;
-    u16 itemid = SPECIAL_ITEM_ARRAY[unk];
+    mAng currentRot;
+    mAng tempOther;
+    u32 itemid = SPECIAL_ITEM_ARRAY[unk];
    mAng3_c itemRot(0, 0, 0);

    if (subtype == 2 || subtype == 6) {
-        currentRot = *rot;
+        currentRot = rot;
        tempOther = -0xe39;
    } else {
-        currentRot = targetAngleY(&(dAcPy_c::LINK->position), pos);
+        currentRot = cLib::targetAngleY(dAcPy_c::LINK->position, *pos);
        tempOther = -0x8000;
        currentRot += 0x4000;
    }
-    s16 angleDecrement = tempOther / itemCount;
+    // This angle code is annoying. d_t_reaction has similar code
+    s32 angleDecrement = tempOther / itemCount;
    tempOther = angleDecrement / 2;
    currentRot += tempOther;
-    tempOther /= 2;
+    tempOther = tempOther / 2;

-    for (s8 currentItemIndex = 0; currentItemIndex < itemCount; currentItemIndex++) {
-        s16 out;
-        SpecialItemDropMgr::fn_800C81D0(out, tempOther, -tempOther);
+    for (int currentItemIndex = 0; currentItemIndex < itemCount; currentItemIndex++) {
+        mAng out = cM::rndRange(tempOther, -tempOther);

        itemRot.y = currentRot + out;
-        if (unk < 15) {
-            itemid = RAND_RUPEE_ARRAY[rndInt(3)];
+        if (unk >= 12 && unk < 14) {
+            itemid = RAND_RUPEE_ARRAY[cM::rndInt(3)];
            spawnItem1(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
        } else if (subtype == 2) {
            spawnItem2(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
@@ -93,7 +556,7 @@ bool spawnSpecialDropItem(SpecialItemDropMgr *mgr, int specialItemId, int roomid
            if (subtype == 1) {
                spawnItem3(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
            } else if (subtype == 4) {
-                spawnItem4(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
+                spawnItem4(itemid, 0, 0xFFFFFFFF);
            } else if (subtype == 3) {
                spawnItem5(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
            } else if (subtype == 5) {
@@ -101,18 +564,15 @@ bool spawnSpecialDropItem(SpecialItemDropMgr *mgr, int specialItemId, int roomid
            } else if (subtype == 6) {
                spawnItem7(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
            } else if (subtype == 7) {
-                spawnItem8(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
+                spawnItem8(itemid, roomid, pos, &itemRot, nullptr, nullptr, 0xFFFFFFFF, 0);
            } else {
-                spawnItem9(itemid, roomid, pos, &itemRot, 0xFFFFFFFF, 0);
+                spawnItem9(itemid, roomid, pos, &itemRot);
            }
        }
-        currentRot -= angleDecrement;
+        currentRot.mVal -= angleDecrement;
    }
    return true;
 }

-// 800c81d0
-void fn_800C81D0(s16, s16, s16){};
-
 // 800c8270
-SpecialItemDropMgr::~SpecialItemDropMgr() {}
+// SpecialItemDropMgr::~SpecialItemDropMgr() {}