Rough dynamic collision setup (#24)

* Rough collider shape setup

* d_a_obj_toD3_stone_figure OK

* Cleanup

* Cleanup 2

14 files changed, 914 insertions, 17 deletions

diff --git a/src/REL/d/a/obj/d_a_obj_pool_cock.cpp b/src/REL/d/a/obj/d_a_obj_pool_cock.cpp
index 9f674a22..b632301e 100644
--- a/src/REL/d/a/obj/d_a_obj_pool_cock.cpp
+++ b/src/REL/d/a/obj/d_a_obj_pool_cock.cpp
@@ -48,7 +48,7 @@ int dAcOPoolCock_c::actorExecute() {
     mStateMgr.executeState();
     calcVelocity();
     position += velocity;
-    position += posIncrements;
+    position += mCCdStruct.posIncrements;
     updateMatrix();
     mMtx_c mdl1Transform;
     mMtx_c mdl2Transform;
diff --git a/src/REL/d/a/obj/d_a_obj_ring.cpp b/src/REL/d/a/obj/d_a_obj_ring.cpp
index 6d153ac3..9bc13a04 100644
--- a/src/REL/d/a/obj/d_a_obj_ring.cpp
+++ b/src/REL/d/a/obj/d_a_obj_ring.cpp
@@ -37,7 +37,7 @@ int dAcOring_c::actorExecute() {
     mStateMgr.executeState();
     calcVelocity();
     position += velocity;
-    position += posIncrements;
+    position += mCCdStruct.posIncrements;
     updateMatrix();
     mModel.setLocalMtx(worldMatrix);
     return SUCCEEDED;
diff --git a/src/REL/d/a/obj/d_a_obj_spike.cpp b/src/REL/d/a/obj/d_a_obj_spike.cpp
index e69de29b..baabdf99 100644
--- a/src/REL/d/a/obj/d_a_obj_spike.cpp
+++ b/src/REL/d/a/obj/d_a_obj_spike.cpp
@@ -0,0 +1,88 @@
+#include <d/a/obj/d_a_obj_spike.h>
+#include <toBeSorted/cc/d_cc_mgr.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, 0x60407, 0, 0}, 
+    {0}},
+    {-1.0f, -246.0f, -472.0f, 73.0f, 255.0f, 482.0f}};
+// clang-format on
+
+const mVec3_c dAcOspike_c::sVec1 = mVec3_c(-1.0f, -246.0f, -472.0f);
+const mVec3_c dAcOspike_c::sVec2 = mVec3_c(73.0f, 255.0f, 482.0f);
+
+STATE_DEFINE(dAcOspike_c, Wait);
+
+bool dAcOspike_c::createHeap() {
+    mResFile = getOarcResFile("SpikeD101");
+    nw4r::g3d::ResMdl mdl = mResFile.GetResMdl("SpikeD101");
+    TRY_CREATE(mMdl.create(mdl, &heap_allocator, 0x120));
+    return true;
+}
+
+int dAcOspike_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcOspike_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    mCCdStruct.setField0x38ToMagicValue();
+    mCollision.init(sCcSrc);
+    mCollision.initUnk(mCCdStruct);
+
+    updateMatrix();
+    mMdl.setLocalMtx(worldMatrix);
+    mVec3_c tmp;
+    PSMTXMultVecSR(worldMatrix.m, mVec3_c::Ex, tmp);
+    mCollision.setAtVec(tmp);
+
+    mMtx_c mtx;
+    mtx.XrotS(rotation.x);
+    mtx.ZrotM(rotation.z);
+    mVec3_c tmp2, tmp3;
+    PSMTXMultVecSR(mtx.m, sVec1, tmp2);
+    PSMTXMultVecSR(mtx.m, sVec2, tmp3);
+
+    if (tmp2.x > tmp3.x) {
+        f32 copy = tmp2.x;
+        tmp2.x = tmp3.x;
+        tmp3.x = copy;
+    }
+    if (tmp2.y > tmp3.y) {
+        f32 copy = tmp2.y;
+        tmp2.y = tmp3.y;
+        tmp3.y = copy;
+    }
+    if (tmp2.z > tmp3.z) {
+        f32 copy = tmp2.z;
+        tmp2.z = tmp3.z;
+        tmp3.z = copy;
+    }
+
+    mCollision.setMinMax(tmp2, tmp3);
+    mStateMgr.changeState(StateID_Wait);
+    setBoundingBox(mVec3_c(-10.0f, -250.0f, -480.0f), mVec3_c(80.0f, 260.0f, 490.0f));
+    return SUCCEEDED;
+}
+
+int dAcOspike_c::doDelete() {
+    return 1;
+}
+
+int dAcOspike_c::actorExecute() {
+    mStateMgr.executeState();
+    mCollision.setWithYRot(position, rotation.y);
+    ColliderManager::getColliderManager()->addCollider(&mCollision);
+    return 1;
+}
+
+int dAcOspike_c::draw() {
+    drawModelType1(&mMdl);
+    return 1;
+}
+
+void dAcOspike_c::initializeState_Wait() {}
+void dAcOspike_c::executeState_Wait() {}
+void dAcOspike_c::finalizeState_Wait() {}
diff --git a/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp b/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp
index e69de29b..898286d6 100644
--- a/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp
+++ b/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp
@@ -0,0 +1,139 @@
+#include <d/a/obj/d_a_obj_toD3_stone_figure.h>
+#include <toBeSorted/attention.h>
+#include <toBeSorted/cc/d_cc_mgr.h>
+#include <toBeSorted/event.h>
+#include <toBeSorted/event_manager.h>
+#include <toBeSorted/scgame.h>
+#include <toBeSorted/item_story_flag_manager.h>
+
+SPECIAL_ACTOR_PROFILE(OBJ_TOD3_STONE, dAcOtoD3StoneFigure_c, fProfile::OBJ_TOD3_STONE, 0x1B3, 0, 0);
+
+STATE_DEFINE(dAcOtoD3StoneFigure_c, OneEye);
+STATE_DEFINE(dAcOtoD3StoneFigure_c, Eyes);
+
+f32 dAcOtoD3StoneFigure_c::sRadius = 85.0f;
+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, 0x60407, 0, 0}, 
+    {0xE9}},
+    {dAcOtoD3StoneFigure_c::sRadius, dAcOtoD3StoneFigure_c::sHeight}
+};
+// clang-format on
+
+bool dAcOtoD3StoneFigure_c::createHeap() {
+    const char *modelName = getModelName();
+    mResFile = getOarcResFile("BirdObjD3");
+    nw4r::g3d::ResMdl mdl = mResFile.GetResMdl(modelName);
+    TRY_CREATE(mMdl.create(mdl, &heap_allocator, 0x120));
+    return true;
+}
+
+int dAcOtoD3StoneFigure_c::create() {
+    mIsSkyKeepAlreadyOpen = isStoneOfTrialsPlaced();
+    mExitId = params & 0xFF;
+    updateMatrix();
+    if (!initAllocatorWork1Heap(-1, "dAcOtoD3StoneFigure_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    mMdl.setLocalMtx(worldMatrix);
+    mCCdStruct.setField0x38ToMagicValue();
+    mCollision.init(sCcSrc);
+    mCollision.initUnk(mCCdStruct);
+    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);
+
+    // ???
+    f32 a, b, c;
+    c = position.z;
+    b = getYPos();
+    b += zero;
+    a = position.x;
+    poscopy2.x = a;
+    poscopy2.y = b;
+    poscopy2.z = c;
+    poscopy3.x = a;
+    poscopy3.y = b;
+    poscopy3.z = c;
+    // poscopy3 = poscopy2;
+    mCollision.setSomeDefendValue(0x2000);
+
+    if (!mIsSkyKeepAlreadyOpen) {
+        mStateMgr.changeState(StateID_OneEye);
+    } else {
+        mStateMgr.changeState(StateID_Eyes);
+    }
+
+    return SUCCEEDED;
+}
+
+int dAcOtoD3StoneFigure_c::doDelete() {
+    return 1;
+}
+
+int dAcOtoD3StoneFigure_c::actorExecute() {
+    mStateMgr.executeState();
+    ColliderManager::getColliderManager()->addCollider(&mCollision);
+    return 1;
+}
+
+int dAcOtoD3StoneFigure_c::draw() {
+    if (ScGame::currentSpawnInfo.layer != 0x12) {
+        drawModelType1(&mMdl);
+    }
+    return 1;
+}
+
+void dAcOtoD3StoneFigure_c::initializeState_OneEye() {
+    if (ScGame::currentSpawnInfo.night == 1) {
+        rotation.y.mVal += -0x8000;
+        updateMatrix();
+        mMdl.setLocalMtx(worldMatrix);
+    }
+}
+
+void dAcOtoD3StoneFigure_c::executeState_OneEye() {
+    if (EventManager::isInEvent(this, "D3OpenStart")) {
+        ScGame::sInstance->triggerExit(roomid, mExitId);
+    } else {
+        if (hasStoneOfTrials() && ScGame::currentSpawnInfo.night != 1) {
+            // These are interaction related
+            -0.0f;
+            dAttention_c::sInstance->addTarget(this, 1, 300.0f, 50.0f, -100.0f, 100.0f);
+            dAttention_c::sInstance->addTarget(this, 1, 200.0f, -100.0f, 100.0f);
+        }
+    }
+}
+void dAcOtoD3StoneFigure_c::finalizeState_OneEye() {}
+
+void dAcOtoD3StoneFigure_c::initializeState_Eyes() {}
+void dAcOtoD3StoneFigure_c::executeState_Eyes() {}
+void dAcOtoD3StoneFigure_c::finalizeState_Eyes() {}
+
+const char *dAcOtoD3StoneFigure_c::getModelName() const {
+    return mIsSkyKeepAlreadyOpen ? "BirdObjD3B" : "BirdObjD3A";
+}
+
+bool dAcOtoD3StoneFigure_c::isStoneOfTrialsPlaced() const {
+    return StoryFlagManager::sInstance->getCounterOrFlag(22);
+}
+
+void dAcOtoD3StoneFigure_c::doInteraction(s32 arg) {
+    if (arg == 5) {
+        Event event = Event("D3OpenStart", 100, 0x100001, nullptr, nullptr);
+        EventManager::alsoSetAsCurrentEvent(this, &event, nullptr);
+    }
+}
+
+extern "C" s32 fn_80251B70(s32);
+bool dAcOtoD3StoneFigure_c::hasStoneOfTrials() const {
+    return fn_80251B70(0xB4);
+}
diff --git a/src/REL/d/a/obj/d_a_obj_triforce.cpp b/src/REL/d/a/obj/d_a_obj_triforce.cpp
index e69de29b..23506d57 100644
--- a/src/REL/d/a/obj/d_a_obj_triforce.cpp
+++ b/src/REL/d/a/obj/d_a_obj_triforce.cpp
@@ -0,0 +1,81 @@
+#include <c/c_math.h>
+#include <d/a/obj/d_a_obj_triforce.h>
+#include <m/m_vec.h>
+#include <toBeSorted/cc/d_cc_mgr.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, 0x60407, 0, 0}, 
+    {0xE9}},
+    {150.0f}};
+// clang-format on
+
+const f32 dAcOtriforce_c::sScale = 6.5f;
+const f32 dAcOtriforce_c::sAmpNeg = -3.0f;
+const u32 dAcOtriforce_c::sStartingOffsetRange = 0x10000;
+
+// const f32 dAcOtriforce_c::sAmpPos = 23.0f;
+
+bool dAcOtriforce_c::createHeap() {
+    mResFile = getOarcResFile("TriForce");
+    nw4r::g3d::ResMdl mdl = mResFile.GetResMdl("TriForce");
+    TRY_CREATE(mMdl.create(mdl, &heap_allocator, 0x324));
+    nw4r::g3d::ResAnmTexSrt anm = mResFile.GetResAnmTexSrt("TriForce");
+    TRY_CREATE(mAnm.create(mdl, anm, &heap_allocator, nullptr, 1));
+    mMdl.setAnm(mAnm);
+    return true;
+}
+
+int dAcOtriforce_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcOtriforce_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    mCCdStruct.setField0x38ToMagicValue();
+    mCollision.init(sCcSrc);
+    mCollision.initUnk(mCCdStruct);
+    mCollision.clearCoFlag();
+    mStartingOffset = cM::rndInt(sStartingOffsetRange);
+    mEffects.init(this);
+    mCollision.setSomeDefendValue(0x2000);
+    updateMatrix();
+    scale.x = sScale;
+    scale.y = sScale;
+    scale.z = sScale;
+    mMdl.setLocalMtx(worldMatrix);
+    return SUCCEEDED;
+}
+
+int dAcOtriforce_c::doDelete() {
+    return 1;
+}
+
+extern const u16 lbl_8057AB3E;
+extern "C" void fn_80029AE0(EffectsStruct *, u16, mMtx_c *, void *, void *);
+
+int dAcOtriforce_c::actorExecute() {
+    int zero = 0;
+    mVec3_c offset = mVec3_c::Ey * (mStartingOffset.sin() * getBounceScalar());
+    position = mStartingPos + offset;
+    mStartingOffset.mVal += 0x16C;
+
+    mCollision.setC(position.x, position.y + 90.0f + zero, position.z);
+
+    ColliderManager::getColliderManager()->addCollider(&mCollision);
+    updateMatrix();
+    Mtx m;
+    PSMTXScale(m, scale.x, scale.y, scale.z);
+    PSMTXConcat(worldMatrix.m, m, worldMatrix.m);
+    mMdl.setLocalMtx(worldMatrix);
+    mAnm.play();
+    fn_80029AE0(&mEffects, lbl_8057AB3E, &worldMatrix, nullptr, nullptr);
+    return 1;
+}
+
+int dAcOtriforce_c::draw() {
+    drawModelType1(&mMdl);
+    return 1;
+}
diff --git a/src/REL/d/t/d_t_sound_area.cpp b/src/REL/d/t/d_t_sound_area.cpp
index ccdba2c2..a484171d 100644
--- a/src/REL/d/t/d_t_sound_area.cpp
+++ b/src/REL/d/t/d_t_sound_area.cpp
@@ -11,7 +11,6 @@ void float_ordering() {
     0.01f;
 }
 
-
 int dTgSndAr_c::create() {
     scale *= 0.01f;
     if (dTgSndMg_c::sInstance == nullptr) {
@@ -34,9 +33,8 @@ int dTgSndAr_c::create() {
         if ((base = fManager_c::searchBaseByGroupType(ACTOR, base)) == nullptr) {
             break;
         }
-        // This has got to be just a member function
         dAcBase_c *ac = static_cast<dAcBase_c *>(base);
-        if (!dBase_c::isActorPlayer(*ac) && checkPosInArea(ac->position)) {
+        if (!ac->isActorPlayer() && checkPosInArea(ac->position)) {
             ac->setBit_field_0xE8(params & 0xFF);
         }
     }
@@ -142,26 +140,31 @@ struct UnkStruct {
 
 extern "C" void fn_80337EA0(UnkStruct *);
 extern "C" void fn_80337EF0(UnkStruct *, mVec3_c &, mVec3_c &, f32);
-extern "C" int fn_8032BFB0(UnkStruct *, EGG::Vector3f &, f32 *, f32 &, int);
+extern "C" int cM3d_Len3dSqPntAndSegLine(UnkStruct *, Vec &, Vec *, f32 *, f32 *);
 
-// ???
+// Capsule
 bool dTgSndAr_c::checkAlg3(const mVec3_c &pos) {
-    f32 q[4];
-    UnkStruct unk;
+    Vec q;
 
     f32 radius = scale.x * 100.0f;
     radius = radius * radius;
-    EGG::Vector3f a = pos;
+    Vec a = pos;
+
+    UnkStruct unk;
     fn_80337EA0(&unk);
 
+    // Line between b and c
     mVec3_c b = *mRail.getPntPosForIndex(0);
     mVec3_c c = *mRail.getPntPosForIndex(1);
 
     fn_80337EF0(&unk, b, c, scale.x * 100.0f);
     f32 d;
-    if (fn_8032BFB0(&unk, a, q, d, 0)) {
+    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;
     } else {
+        // Otherwise check if we are within the spheres around the endpoints
         f32 distSq = PSVECSquareDistance(unk.vec, pos);
         if (distSq < radius) {
             return true;
diff --git a/src/d/a/d_a_base.cpp b/src/d/a/d_a_base.cpp
index 3c4c247d..41584bfa 100644
--- a/src/d/a/d_a_base.cpp
+++ b/src/d/a/d_a_base.cpp
@@ -4,6 +4,7 @@
 #include "f/f_list_nd.h"
 #include "m/m_vec.h"
 #include "toBeSorted/event.h"
+#include "toBeSorted/event_manager.h"
 #include "toBeSorted/file_manager.h"
 #include "toBeSorted/misc_flag_managers.h"
 #include "toBeSorted/scgame.h"
@@ -32,7 +33,6 @@ extern "C" s16 targetAngleX(mVec3_c *, mVec3_c *);
 extern "C" bool checkCollision(mVec3_c *pos);
 extern "C" s8 collisionCheckGetRoom();
 extern "C" dRoom *getRoomByIndex(RoomManager *mgr, s8 roomid);
-extern "C" bool alsoSetAsCurrentEvent(dAcBase_c *, Event *, void *);
 
 bool dAcBase_c::createHeap() {
     return true;
@@ -547,7 +547,7 @@ void dAcBase_c::unkVirtFunc_0x6C() {}
 void dAcBase_c::doInteraction(s32 param) {
     if (param == 4 || param == 5 || param == 12) {
         Event event = Event("DefaultTalk", 400, 0x100001, nullptr, nullptr);
-        alsoSetAsCurrentEvent(this, &event, nullptr);
+        EventManager::alsoSetAsCurrentEvent(this, &event, nullptr);
     }
 }
 
diff --git a/src/d/a/obj/d_a_obj_switch.cpp b/src/d/a/obj/d_a_obj_switch.cpp
index 9bbce3d6..6dfb1e94 100644
--- a/src/d/a/obj/d_a_obj_switch.cpp
+++ b/src/d/a/obj/d_a_obj_switch.cpp
@@ -26,7 +26,7 @@ void dAcOswMdlCallback_c::timingB(u32 nodeId, nw4r::g3d::WorldMtxManip *manip, n
 }
 
 static bool isPushableBlock(dAcBase_c *actor) {
-    return dBase_c::isActorPlayer(*actor) || actor->profile_name == fProfile::OBJ_PUSH_BLOCK ||
+    return actor->isActorPlayer() || actor->profile_name == fProfile::OBJ_PUSH_BLOCK ||
             actor->profile_name == fProfile::OBJ_KIBAKO;
 }
 
@@ -34,7 +34,7 @@ void dAcOsw_c::interactCallback(void *unknown, dAcBase_c *actor, dAcObjBase_c *i
     if (!isPushableBlock(interactor)) {
         return;
     }
-    dAcPy_c *link = dBase_c::isActorPlayer(*interactor) ? static_cast<dAcPy_c *>(interactor) : nullptr;
+    dAcPy_c *link = interactor->isActorPlayer() ? static_cast<dAcPy_c *>(interactor) : nullptr;
     dAcOsw_c *sw = static_cast<dAcOsw_c *>(actor);
 
     // halp
diff --git a/src/d/d_base.cpp b/src/d/d_base.cpp
index 41c03e5a..2e1701b4 100644
--- a/src/d/d_base.cpp
+++ b/src/d/d_base.cpp
@@ -53,8 +53,8 @@ void dBase_c::resetFlags() {
     s_NextExecuteControlFlags = 0;
 }
 
-bool dBase_c::isActorPlayer(dBase_c &base) {
-    return base.profile_name == fProfile::PLAYER;
+bool dBase_c::isActorPlayer() {
+    return profile_name == fProfile::PLAYER;
 }
 
 int dBase_c::loadAsyncCallback() {
diff --git a/src/toBeSorted/cc/d_cc_d.cpp b/src/toBeSorted/cc/d_cc_d.cpp
new file mode 100644
index 00000000..5a894ad0
--- /dev/null
+++ b/src/toBeSorted/cc/d_cc_d.cpp
@@ -0,0 +1,395 @@
+#include <d/a/d_a_base.h>
+#include <f/f_base_id.h>
+#include <m/m_vec.h>
+#include <toBeSorted/cc/d_cc_d.h>
+
+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;
+}
+
+// Very certain
+void dCcD_DivideArea::SetArea(Aabb 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;
+    }
+}
+
+inline bool cM3d_IsZero(f32 f) {
+    return fabsf(f) < FLT_EPSILON;
+}
+
+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,
+};
+
+// 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 UnkCCDStruct::postExecute() {
+    field_0x04 = field_0x00;
+    field_0x00 = 0;
+    field_0x0C = field_0x08;
+    field_0x08 = 0;
+}
+
+void UnkCCDStruct::reset() {
+    field_0x10 = mVec3_c::Zero;
+    field_0x1C = mVec3_c::Zero;
+    posIncrements = mVec3_c::Zero;
+}
+
+fBaseID_e UnkCCDStruct::getId() {
+    if (field_0x34 != nullptr) {
+        return field_0x34->unique_ID;
+    }
+    return (fBaseID_e)0;
+}
+
+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];
+    }
+}
+
+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_GAtTgCoCommonBase::unlink() {
+    mActor.unlink();
+}
+
+void dCcD_GAtTgCoCommonBase::setActor(dAcBase_c *actor) {
+    field_0x14 |= 1;
+    mActor.link(actor);
+}
+
+dAcBase_c *dCcD_GAtTgCoCommonBase::getActor() {
+    return mActor.get();
+}
+
+void dCcD_GAtTgCoCommonBase::decreaseCount() {
+    if (mEffCounter <= 0) {
+        return;
+    }
+    mEffCounter--;
+}
+
+dCcD_GObjInf::dCcD_GObjInf() {
+    field_0x104 = nullptr;
+    field_0x108 = 0;
+}
+
+dCcD_GObjInf::~dCcD_GObjInf() {
+    field_0x104 = nullptr;
+}
+
+bool dCcD_GObjInf::weirdConditionCheck(dAcBase_c *ac, u32 arg) {
+    return ac != nullptr && ac->isActorPlayer() && arg == 2;
+}
+
+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();
+}
+
+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) {
+    setMinMax(mVec3_c(src.minX, src.minY, src.minZ), mVec3_c(src.maxX, src.maxY, src.maxZ));
+}
+
+mVec3_c *dCcD_ShapeAttr5::getVirtualCenter() {
+    return &mVirtualCenter;
+}
+
+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) {}
diff --git a/src/toBeSorted/cc/d_cc_m3d.cpp b/src/toBeSorted/cc/d_cc_m3d.cpp
new file mode 100644
index 00000000..1f2ab896
--- /dev/null
+++ b/src/toBeSorted/cc/d_cc_m3d.cpp
@@ -0,0 +1,33 @@
+#include <math.h>
+#include <nw4r/math/math_types.h>
+#include <rvl/MTX.h>
+
+
+using namespace nw4r::math;
+
+inline VEC3 cM3d_Cross(const VEC3 *pVecA, const VEC3 *pVecB, const VEC3 *pVecC, VEC3 *pVecOut) {
+    VEC3 tmp1;
+    VEC3 tmp2;
+    VEC3Sub(&tmp1, pVecB, pVecA);
+    VEC3Sub(&tmp2, pVecC, pVecA);
+
+    VEC3Cross(pVecOut, &tmp1, &tmp2);
+}
+
+inline f32 cM3d_Dot(const VEC3 *pVecA, const VEC3 *pVecB) {
+    return VEC3Dot(pVecA, pVecB);
+}
+
+void cM3d_CalcPla(const VEC3 *pVecA, const VEC3 *pVecB, const VEC3 *pVecC, VEC3 *pVecOut, f32 *pD) {
+    cM3d_Cross(pVecA, pVecB, pVecC, pVecOut);
+    f32 mag = VEC3Len(pVecOut);
+    if (fabsf(mag) > 0.05f) {
+        VEC3Scale(pVecOut, pVecOut, 1.0f / mag);
+        *pD = -cM3d_Dot(pVecOut, pVecA);
+    } else {
+        pVecOut->y = 0.0f;
+        *pD = 0.0f;
+        pVecOut->z = 0.0f;
+        pVecOut->x = 0.0f;
+    }
+}
diff --git a/src/toBeSorted/cc/d_cc_m3d_g_cyl.cpp b/src/toBeSorted/cc/d_cc_m3d_g_cyl.cpp
new file mode 100644
index 00000000..f166c335
--- /dev/null
+++ b/src/toBeSorted/cc/d_cc_m3d_g_cyl.cpp
@@ -0,0 +1,26 @@
+#include <m/m_vec.h>
+#include <toBeSorted/cc/d_cc_m3d_g_cyl.h>
+
+void cM3dGCyl::setC(const mVec3_c &c, f32 radius, f32 height) {
+    setC(c);
+    setR(radius);
+    setH(height);
+}
+
+void cM3dGCyl::setC(const mVec3_c &c) {
+    mCenter = c;
+}
+
+void cM3dGCyl::setH(f32 h) {
+    if (h < 0.0f) {
+        h = 0.0f;
+    }
+    mHeight = h;
+}
+
+void cM3dGCyl::setR(f32 r) {
+    if (r < 0.0f) {
+        r = 0.0f;
+    }
+    mRadius = r;
+}
diff --git a/src/toBeSorted/cc/d_cc_m3d_g_sph.cpp b/src/toBeSorted/cc/d_cc_m3d_g_sph.cpp
new file mode 100644
index 00000000..b4f12a06
--- /dev/null
+++ b/src/toBeSorted/cc/d_cc_m3d_g_sph.cpp
@@ -0,0 +1,26 @@
+#include <m/m_vec.h>
+#include <toBeSorted/cc/d_cc_m3d_g_sph.h>
+
+cM3dGSph::cM3dGSph() {
+    field_0x10 = 1.0f;
+}
+
+void cM3dGSph::setC(const mVec3_c &c) {
+    mCenter = c;
+}
+
+void cM3dGSph::set(const mVec3_c &c, f32 r) {
+    setC(c);
+    setR(r);
+}
+
+void cM3dGSph::setR(f32 r) {
+    if (r < 0.0f) {
+        r = 0.0f;
+    }
+    mRadius = r;
+}
+
+void cM3dGSph::setC(f32 x, f32 y, f32 z) {
+    setC(mVec3_c(x, y, z));
+}
diff --git a/src/toBeSorted/cc/d_cc_shape_colliders.cpp b/src/toBeSorted/cc/d_cc_shape_colliders.cpp
new file mode 100644
index 00000000..3d9ddfe5
--- /dev/null
+++ b/src/toBeSorted/cc/d_cc_shape_colliders.cpp
@@ -0,0 +1,106 @@
+#include <m/m_vec.h>
+#include <toBeSorted/cc/d_cc_d.h>
+#include <toBeSorted/cc/d_cc_shape_colliders.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(*&field_0x0C, *&field_0x00, *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;
+}