Rough dynamic collision setup (#24)

* Rough collider shape setup

* d_a_obj_toD3_stone_figure OK

* Cleanup

* Cleanup 2

20 files changed, 892 insertions, 7 deletions

diff --git a/include/d/a/obj/d_a_obj_base.h b/include/d/a/obj/d_a_obj_base.h
index a5a8666c..09467d6b 100644
--- a/include/d/a/obj/d_a_obj_base.h
+++ b/include/d/a/obj/d_a_obj_base.h
@@ -2,11 +2,14 @@
 #define D_A_OBJ_BASE_H
 
 #include "d/a/d_a_base.h"
+#include "m/m_angle.h"
 #include "m/m_mtx.h"
 #include "m/m3d/m_smdl.h"
 #include "m/m3d/m_shadow.h"
+#include "m/m_vec.h"
 #include "m/types_m.h"
 #include "nw4r/g3d/g3d_resfile.h"
+#include "toBeSorted/cc/d_cc_d.h"
 
 // Size: 0xA8
 struct ActorCarryStruct {
@@ -21,7 +24,7 @@ struct ActorCarryStruct {
     /* 0x58 */ mMtx_c field_0x58;
     /* 0x88 */ s32 isCarried;
     /* 0x8C */ u8 field_0x8C[0x10]; // mQuat_c
-    /* 0x9C */ void *dtor; // ???
+    /* 0x9C */ void *dtor;          // ???
     /* 0xA0 */ u32 field_0xA0;
     /* 0xA4 */ u32 field_0xA4;
 
@@ -57,11 +60,12 @@ public:
     /* 0x1A8 */ f32 field_0x1A8;
     /* 0x1AC */ u32 mObjectActorFlags;
 
-    u8 unk_0x1B0[0x1E8 - 0x1B0];
+    u8 unk_0x1B0[0x1C0 - 0x1B0];
 
-    /* 0x1E8 */ mVec3_c posIncrements;
+    /* 0x1C0 */ UnkCCDStruct mCCdStruct;
 
-    u8 unk_0x1F4[0x210 - 0x1F4];
+    mVec3_c mStartingPos;
+    mAng3_c mStartingRot;
 
     /* 0x210 */ ActorCarryStruct mActorCarryInfo;
 
@@ -136,7 +140,7 @@ protected:
 
 // Actors' createHeap functions often have patterns that can be matched with this macro
 #define TRY_CREATE(thing) do { bool result = (thing); if (!result) return result; } while (0)
-
+// Use this in actors' createHeap functions
 #define CREATE_ALLOCATOR(className) do { if (!initAllocatorWork1Heap(-1, #className "::m_allocator", 0x20)) { return FAILED; } } while (0)
 
 #endif
diff --git a/include/d/a/obj/d_a_obj_spike.h b/include/d/a/obj/d_a_obj_spike.h
new file mode 100644
index 00000000..779e8501
--- /dev/null
+++ b/include/d/a/obj/d_a_obj_spike.h
@@ -0,0 +1,38 @@
+#ifndef D_A_O_SPIKE_H
+#define D_A_O_SPIKE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <m/m3d/m_smdl.h>
+#include <m/m_vec.h>
+#include <nw4r/g3d/g3d_resfile.h>
+#include <s/s_State.hpp>
+#include <s/s_StateID.hpp>
+#include <toBeSorted/cc/d_cc_shape_colliders.h>
+
+
+class dAcOspike_c : public dAcObjBase_c {
+public:
+    dAcOspike_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcOspike_c() {}
+    virtual bool createHeap() override;
+    virtual int create() override;
+    virtual int actorExecute() override;
+    virtual int draw() override;
+    virtual int doDelete() override;
+
+    STATE_FUNC_DECLARE(dAcOspike_c, Wait);
+
+    static const mVec3_c sVec1;
+    static const mVec3_c sVec2;
+
+private:
+    static dCcD_SrcAabb sCcSrc;
+
+    nw4r::g3d::ResFile mResFile;
+    m3d::smdl_c mMdl;
+    dCcD_Aabb mCollision;
+
+    STATE_MGR_DECLARE(dAcOspike_c);
+};
+
+#endif
diff --git a/include/d/a/obj/d_a_obj_toD3_stone_figure.h b/include/d/a/obj/d_a_obj_toD3_stone_figure.h
new file mode 100644
index 00000000..efbeab47
--- /dev/null
+++ b/include/d/a/obj/d_a_obj_toD3_stone_figure.h
@@ -0,0 +1,47 @@
+#ifndef D_A_O_TTOD3_STONE_FIGURE_H
+#define D_A_O_TTOD3_STONE_FIGURE_H
+
+#include <c/c_math.h>
+#include <d/a/obj/d_a_obj_base.h>
+#include <m/m3d/m_smdl.h>
+#include <nw4r/g3d/g3d_resfile.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+#include <toBeSorted/cc/d_cc_shape_colliders.h>
+
+
+class dAcOtoD3StoneFigure_c : public dAcObjBase_c {
+public:
+    dAcOtoD3StoneFigure_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcOtoD3StoneFigure_c() {}
+    virtual bool createHeap() override;
+    virtual int create() override;
+    virtual int actorExecute() override;
+    virtual int draw() override;
+    virtual int doDelete() override;
+    virtual void doInteraction(s32) override;
+
+    STATE_FUNC_DECLARE(dAcOtoD3StoneFigure_c, OneEye);
+    STATE_FUNC_DECLARE(dAcOtoD3StoneFigure_c, Eyes);
+
+private:
+    f32 getYPos() {
+        return position.y + sHeight;
+    }
+
+    const char *getModelName() const;
+    bool isStoneOfTrialsPlaced() const;
+    bool hasStoneOfTrials() const;
+    static f32 sRadius;
+    static f32 sHeight;
+    static dCcD_SrcCyl sCcSrc;
+
+    nw4r::g3d::ResFile mResFile;
+    m3d::smdl_c mMdl;
+    STATE_MGR_DECLARE(dAcOtoD3StoneFigure_c);
+    dCcD_Cyl mCollision;
+    s8 mExitId;
+    bool mIsSkyKeepAlreadyOpen;
+};
+
+#endif
diff --git a/include/d/a/obj/d_a_obj_triforce.h b/include/d/a/obj/d_a_obj_triforce.h
new file mode 100644
index 00000000..2b036536
--- /dev/null
+++ b/include/d/a/obj/d_a_obj_triforce.h
@@ -0,0 +1,43 @@
+#ifndef D_A_O_TRIFORCE_H
+#define D_A_O_TRIFORCE_H
+
+#include <c/c_math.h>
+#include <d/a/obj/d_a_obj_base.h>
+#include <m/m3d/m_anmtexsrt.h>
+#include <m/m3d/m_smdl.h>
+#include <m/m_angle.h>
+#include <nw4r/g3d/g3d_resfile.h>
+#include <toBeSorted/cc/d_cc_shape_colliders.h>
+#include <toBeSorted/effects_struct.h>
+
+class dAcOtriforce_c : public dAcObjBase_c {
+public:
+    dAcOtriforce_c() {}
+    virtual ~dAcOtriforce_c() {}
+    virtual bool createHeap() override;
+    virtual int create() override;
+    virtual int actorExecute() override;
+    virtual int draw() override;
+    virtual int doDelete() override;
+
+private:
+    f32 getBounceScalar() const {
+        int zero = 0;
+        return (23.0f + zero + -3.0f);
+    }
+
+    static dCcD_SrcSph sCcSrc;
+
+    static const f32 sScale;
+    static const f32 sAmpNeg;
+    static const u32 sStartingOffsetRange;
+
+    nw4r::g3d::ResFile mResFile;
+    m3d::smdl_c mMdl;
+    dCcD_Sph mCollision;
+    EffectsStruct mEffects;
+    m3d::anmTexSrt_c mAnm;
+    mAng mStartingOffset;
+};
+
+#endif
diff --git a/include/d/d_base.h b/include/d/d_base.h
index 6f753108..c57ea39a 100644
--- a/include/d/d_base.h
+++ b/include/d/d_base.h
@@ -20,7 +20,7 @@ public:
 
 public:
     /* 80050980 */ static void resetFlags();
-    /* 800509a0 */ static bool isActorPlayer(dBase_c &);
+    /* 800509a0 */ bool isActorPlayer();
     /* 800509e0 */ static void initLoader();
     /* 80050a00 */ static dBase_c *createBase(ProfileName, dBase_c *, u32, u8);
     /* 80050a10 */ static dBase_c *createRoot(ProfileName, u32, u8);
diff --git a/include/m/m_angle.h b/include/m/m_angle.h
index 514fa6d0..2b0c98c9 100644
--- a/include/m/m_angle.h
+++ b/include/m/m_angle.h
@@ -2,6 +2,7 @@
 #define M_ANGLE_H
 
 #include <common.h>
+#include <nw4r/math/math_triangular.h>
 
 struct mAng {
     mAng() {}
@@ -12,6 +13,14 @@ struct mAng {
     }
     s32 step(s16 target, s32 steps, s16 max, s16 min);
 
+    inline f32 sin() const {
+        return nw4r::math::SinIdx(*this);
+    }
+
+    inline f32 cos() const {
+        return nw4r::math::CosIdx(*this);
+    }
+
     s16 mVal;
 };
 
diff --git a/include/m/m_vec.h b/include/m/m_vec.h
index f27b498c..44be26c3 100644
--- a/include/m/m_vec.h
+++ b/include/m/m_vec.h
@@ -61,6 +61,11 @@ public:
         return (Vec *)&x;
     }
 
+    /// @brief Vec cast operator.
+    operator Vec() const {
+        return *(Vec *)&x;
+    }
+
     operator EGG::Vector3f *() {
         return (EGG::Vector3f *)&x;
     }
diff --git a/include/nw4r/math/math_triangular.h b/include/nw4r/math/math_triangular.h
index ff450d87..c79b0915 100644
--- a/include/nw4r/math/math_triangular.h
+++ b/include/nw4r/math/math_triangular.h
@@ -1,6 +1,7 @@
 #ifndef NW4R_MATH_TRIANGULAR_H
 #define NW4R_MATH_TRIANGULAR_H
 #include <MSL_C/math.h>
+#include <nw4r/math/math_arithmetic.h>
 #include <nw4r/types_nw4r.h>
 
 #define NW4R_MATH_PI M_PI
diff --git a/include/rvl/MTX/mtxvec.h b/include/rvl/MTX/mtxvec.h
index ff00123f..b744d6f4 100644
--- a/include/rvl/MTX/mtxvec.h
+++ b/include/rvl/MTX/mtxvec.h
@@ -7,6 +7,7 @@ extern "C" {
 #endif
 
 void PSMTXMultVec(const Mtx, const Vec *, Vec *);
+void PSMTXMultVecSR(const Mtx, const Vec *, Vec *);
 
 #ifdef __cplusplus
 }
diff --git a/include/rvl/MTX/vec.h b/include/rvl/MTX/vec.h
index cfc4410c..bed89af0 100644
--- a/include/rvl/MTX/vec.h
+++ b/include/rvl/MTX/vec.h
@@ -7,6 +7,7 @@ extern "C" {
 #endif
 
 void PSVECAdd(const Vec *, const Vec *, Vec *);
+void PSVECSubtract(const Vec *, const Vec *, Vec *);
 void PSVECScale(const Vec *, Vec *, f32);
 void PSVECNormalize(const Vec *, Vec *);
 f32 PSVECMag(const Vec *);
diff --git a/include/toBeSorted/attention.h b/include/toBeSorted/attention.h
new file mode 100644
index 00000000..5c09489f
--- /dev/null
+++ b/include/toBeSorted/attention.h
@@ -0,0 +1,16 @@
+#ifndef ATTENTION_H
+#define ATTENTION_H
+
+#include <common.h>
+
+class dAcBase_c;
+
+class dAttention_c {
+public:
+    static dAttention_c *sInstance;
+
+    void addTarget(dAcBase_c *target, s32, f32, f32, f32);
+    void addTarget(dAcBase_c *target, s32, f32, f32, f32, f32);
+};
+
+#endif
diff --git a/include/toBeSorted/cc/d_cc_d.h b/include/toBeSorted/cc/d_cc_d.h
new file mode 100644
index 00000000..be1d8452
--- /dev/null
+++ b/include/toBeSorted/cc/d_cc_d.h
@@ -0,0 +1,519 @@
+#ifndef TOSORT_D_CC_D_H
+#define TOSORT_D_CC_D_H
+
+#include <d/a/d_a_base.h>
+#include <f/f_base_id.h>
+#include <m/m_mtx.h>
+#include <m/m_vec.h>
+#include <nw4r/math/math_types.h>
+#include <toBeSorted/cc/d_cc_m3d_g_cyl.h>
+#include <toBeSorted/cc/d_cc_m3d_g_sph.h>
+
+// Largely modeled off
+// https://github.com/zeldaret/tp/blob/main/include/SSystem/SComponent/c_cc_d.h
+// https://github.com/zeldaret/tp/blob/main/include/d/cc/d_cc_d.h
+// - the SComponent/d split seems to not exist anymore in SS, so we'll just
+//   go with the d names for this merger of the two
+
+class dCcD_DivideInfo {
+private:
+    /* 0x00 */ u32 mXDivInfo;
+    /* 0x04 */ u32 mYDivInfo;
+    /* 0x08 */ u32 mZDivInfo;
+    /* 0x0C vtable */
+public:
+    /* 80328120 */ dCcD_DivideInfo();
+    /* 80328130 */ virtual ~dCcD_DivideInfo();
+    // void Set(u32, u32, u32);
+    // bool Chk(dCcD_DivideInfo const &) const;
+}; // Size = 0x10
+
+// This Aabb type really could be anything
+struct Aabb {
+    mVec3_c mMin;
+    mVec3_c mMax;
+
+    void Set(mVec3_c const &a, mVec3_c const &b) {
+        mMin = a;
+        mMax = b;
+    }
+}; // Size = 0x18
+
+class dCcD_DivideArea : public Aabb {
+private:
+    /* 0x18 */ bool mXDiffIsZero;
+    /* 0x1C */ f32 mScaledXDiff;
+    /* 0x20 */ f32 mInvScaledXDiff;
+    /* 0x24 */ bool mYDiffIsZero;
+    /* 0x28 */ f32 mScaledYDiff;
+    /* 0x2C */ f32 mInvScaledYDiff;
+    /* 0x30 */ bool mZDiffIsZero;
+    /* 0x34 */ f32 mScaledZDiff;
+    /* 0x38 */ f32 mInvScaledZDiff;
+
+public:
+    /* vt at 0x3C */
+    dCcD_DivideArea();
+    virtual ~dCcD_DivideArea();
+    /* 803281c0 */ void SetArea(Aabb const &);
+    /* 803282d0 */ void CalcDivideInfo(dCcD_DivideInfo *, Aabb const &, u32);
+    /* 80328470 */ void CalcDivideInfoOverArea(dCcD_DivideInfo *, Aabb const &);
+}; // Size = 0x40
+
+class dCcD_GAtTgCoCommonBase {
+protected:
+    /* 0x00 */ u32 field_0x00;
+    /* 0x04 */ s8 mEffCounter;
+    /* 0x08 */ dAcRef_c<dAcBase_c> mActor;
+    /* 0x14 */ u32 field_0x14;
+
+public:
+    dCcD_GAtTgCoCommonBase();
+    virtual ~dCcD_GAtTgCoCommonBase();
+
+    void resetEffCounter() {
+        mEffCounter = 0;
+    }
+    void resetField0x14() {
+        field_0x14 = 0;
+    }
+    void decreaseCount();
+    void unlink();
+    dAcBase_c *getActor();
+    void setActor(dAcBase_c *);
+};
+
+struct dCcD_SrcGAtTgCoCommonBase {
+    /* 0x0 */ u32 mGFlag;
+}; // Size: 0x4
+
+struct dCcD_SrcGObjAt {
+    /* 0x00 */ dCcD_SrcGAtTgCoCommonBase base;
+    /* 0x04 */ u32 field_0x04;
+    /* 0x08 */ u32 field_0x08;
+    /* 0x0C */ u8 mSe;      // Sound Effect ID
+    /* 0x0D */ u8 mHitMark; // Hit Mark particle ID
+    /* 0x0E */ u8 mSpl;
+    /* 0x0F */ u8 mMtrl;
+    /* 0x10 */ u16 field_0x10;
+    /* 0x12 */ s16 field_0x12;
+};
+
+struct dCcD_SrcGObjTg {
+    /* 0x00 */ dCcD_SrcGAtTgCoCommonBase base;
+    /* 0x04 */ u32 field_0x04;
+    /* 0x08 */ u32 field_0x08;
+    /* 0x0C */ u16 field_0x0C;
+    /* 0x0E */ u16 field_0x0E;
+};
+
+struct dCcD_SrcGObjCo {
+    /* 0x0 */ dCcD_SrcGAtTgCoCommonBase mBase;
+};
+
+struct dCcD_SrcGObjInf {
+    /* 0x00 */ dCcD_SrcGObjAt mGObjAt;
+    /* 0x14 */ dCcD_SrcGObjTg mGObjTg;
+    /* 0x24 */ dCcD_SrcGObjCo mGObjCo;
+};
+
+class dCcD_GObjAt : public dCcD_GAtTgCoCommonBase {
+private:
+    /* 0x1C */ dCcD_SrcGObjAt mSrc;
+    /* 0x30 */ mVec3_c mHitPos;
+    /* 0x3C */ mVec3_c mVec;
+    /* 0x48 */ mVec3_c mRVec;
+    /* 0x54 */ u8 field_0x4C[0x58 - 0x54];
+    /* 0x58 */ u32 field_0x58;
+
+public:
+    dCcD_GObjAt();
+    virtual ~dCcD_GObjAt();
+
+    void clearFlag() {
+        mSrc.field_0x04 = mSrc.field_0x04 & 0xFFFFFFFE;
+    }
+    mVec3_c *GetHitPosP() {
+        return &mHitPos;
+    }
+    void SetSomeVec(const mVec3_c &p) {
+        mVec = p;
+    }
+    mVec3_c *GetSomeVec() {
+        return &mVec;
+    }
+    void init(const dCcD_SrcGObjAt *);
+    void setSomeAtFlags(u32 flags);
+    void adjustHitPos(f32 dx, f32 dz);
+};
+
+class dCcD_GObjTg : public dCcD_GAtTgCoCommonBase {
+private:
+    /* 0x1C */ dCcD_SrcGObjTg mSrc;
+    /* 0x2C */ u8 field_0x2C[0x38 - 0x2C];
+    /* 0x38 */ mVec3_c mHitPos;
+    /* 0x44 */ u32 field_0x44;
+    /* 0x48 */ u16 field_0x48;
+    /* 0x4A */ u8 field_0x4A;
+    /* 0x4B */ u8 field_0x4B;
+    /* 0x4C */ u32 field_0x4C;
+    /* 0x50 */ u32 field_0x50;
+    /* 0x54 */ u32 field_0x54;
+    /* 0x58 */ u8 field_0x58[0x6C - 0x58];
+    /* 0x6C */ mVec3_c field_0x6C;
+    /* 0x78 */ u32 field_0x78;
+
+public:
+    dCcD_GObjTg();
+    virtual ~dCcD_GObjTg();
+    void clearFlag() {
+        mSrc.field_0x04 = mSrc.field_0x04 & 0xFFFFFFFE;
+    }
+    void setFlag(u32 f) {
+        mSrc.field_0x04 |= f;
+    }
+    void set0x4C(u32 val) {
+        field_0x4C = val;
+    }
+    void init(const dCcD_SrcGObjTg *);
+    void adjustHitPos(f32 dx, f32 dz);
+};
+
+class dCcD_GObjCo : public dCcD_GAtTgCoCommonBase {
+private:
+    /* 0x1C */ dCcD_SrcGObjCo mSrc;
+    /* 0x20 */ u32 field_0x20;
+    /* 0x24 */ u16 field_0x24;
+    /* 0x28 */ u32 field_0x28;
+
+public:
+    dCcD_GObjCo();
+    virtual ~dCcD_GObjCo();
+    void clearFlag() {
+        mSrc.mBase.mGFlag = mSrc.mBase.mGFlag & 0xFFFFFFFE;
+    }
+    void setFlag(u32 f) {
+        mSrc.mBase.mGFlag |= f;
+    }
+    void init(const dCcD_SrcGObjCo *);
+    void setSomeAtFlags(u32 flags);
+    void adjustHitPos(f32 dx, f32 dz);
+
+    void SetGFlag(u32 flag) {
+        mSrc.mBase.mGFlag = flag;
+    }
+};
+
+class dCcD_ShapeAttr {
+public:
+    /* 0x00 */ u8 UNK_0x00[0x18 - 0x00];
+    /* 0x18 */ dCcD_DivideInfo field_0x18;
+
+    dCcD_ShapeAttr();
+
+    /* vt 0x08 */ virtual ~dCcD_ShapeAttr();
+    /* vt 0x0C */ virtual void dCcD_ShapeAttr_0x0C();
+    /* vt 0x10 */ virtual void dCcD_ShapeAttr_0x10();
+    /* vt 0x14 */ virtual void dCcD_ShapeAttr_0x14() = 0;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x18() = 0;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x1C() = 0;
+    /* vt 0x20 */ virtual void dCcD_ShapeAttr_0x20() = 0;
+    /* vt 0x24 */ virtual void dCcD_ShapeAttr_0x24() = 0;
+    /* vt 0x28 */ virtual void dCcD_ShapeAttr_0x28(); // 0x80329110
+    /* vt 0x2C */ virtual void dCcD_ShapeAttr_0x2C() = 0;
+    /* vt 0x30 */ virtual void dCcD_ShapeAttr_0x30() = 0;
+    /* vt 0x34 */ virtual void dCcD_ShapeAttr_0x34() = 0;
+    /* vt 0x38 */ virtual void dCcD_ShapeAttr_0x38() = 0;
+    /* vt 0x3C */ virtual void dCcD_ShapeAttr_0x3C() = 0;
+    /* vt 0x40 */ virtual mVec3_c *getVirtualCenter(); // 0x80329120
+    /* vt 0x44 */ virtual void dCcD_ShapeAttr_0x44() = 0;
+    /* vt 0x48 */ virtual void dCcD_ShapeAttr_0x48() = 0;
+    /* vt 0x4C */ virtual void getShapeAccess(); // 0x80329090
+    /* vt 0x50 */ virtual void dCcD_ShapeAttr_0x50() = 0;
+    /* vt 0x54 */ virtual void dCcD_ShapeAttr_0x54(); // 0x803290F0
+    /* vt 0x58 */ virtual void dCcD_ShapeAttr_0x58() = 0;
+
+    static mVec3_c m_virtual_center;
+};
+
+// This is in dAcObjBase_c @ 0x1c0
+struct UnkCCDStruct {
+    u32 field_0x00;
+    u32 field_0x04;
+    u32 field_0x08;
+    u32 field_0x0C;
+    /* 0x10 */ mVec3_c field_0x10;
+    /* 0x1C */ mVec3_c field_0x1C;
+    /* 0x28 */ mVec3_c posIncrements;
+    dAcBase_c *field_0x34;
+    s32 field_0x38;
+
+    UnkCCDStruct(dAcBase_c *);
+
+    void postExecute();
+    void reset();
+    fBaseID_e getId();
+    u32 getSomething(int);
+
+    void setField0x38ToMagicValue() {
+        field_0x38 = 0xD;
+    }
+};
+
+// Object Info
+class dCcD_GObjInf {
+protected:
+    /* 0x000 */ dCcD_GObjAt mGObjAt;
+    /* 0x05C */ dCcD_GObjTg mGObjTg;
+    /* 0x0D8 */ dCcD_GObjCo mGObjCo;
+    /* 0x104 */ UnkCCDStruct *field_0x104;
+    /* 0x108 */ u32 field_0x108;
+
+public:
+    dCcD_GObjInf();
+    /* vt 0x08 */ virtual ~dCcD_GObjInf();
+    /* vt 0x0C */ virtual void *dCcD_GObjInf_0x0C() = 0;
+    /* vt 0x10 */ virtual void dCcD_GObjInf_0x10(); // 0x80328d30
+
+    void clear();
+    void init(const dCcD_SrcGObjInf &src);
+    static bool weirdConditionCheck(dAcBase_c *ac, u32);
+
+    inline void initUnk(UnkCCDStruct &src) {
+        field_0x104 = &src;
+    }
+
+    inline void clearCoFlag() {
+        mGObjCo.clearFlag();
+    }
+
+    void setTgCoFlag(u32 f) {
+        mGObjTg.setFlag(f);
+        mGObjCo.setFlag(f);
+    }
+
+    inline void setSomeDefendValue(u32 val) {
+        mGObjTg.set0x4C(val);
+    }
+
+    inline void setAtVec(const mVec3_c &p) {
+        mGObjAt.SetSomeVec(p);
+    }
+
+    inline mVec3_c *getAtVec() {
+        return mGObjAt.GetSomeVec();
+    }
+
+    void ResetAtHit();
+    void ResetTgHit();
+    void ResetCoHit();
+
+    mVec3_c *GetAtHitPosP();
+    mVec3_c *GetAtHitPosP2();
+
+    dAcBase_c *GetAtActor();
+    dAcBase_c *GetTgActor();
+    dAcBase_c *GetCoActor();
+
+    void adjustHitPos(f32 dx, f32 dz);
+};
+
+struct dCcD_SrcCylAttr {
+public:
+    /* 0x00 */ f32 mRadius;
+    /* 0x04 */ f32 mHeight;
+}; // Size = 0x8
+
+struct dCcD_SrcSphAttr {
+    /* 0x00 */ f32 mRadius;
+}; // Size = 0x4
+
+class cM3dGAabb {
+public:
+    /* 0x00 */ mMtx_c mMtx1;
+    /* 0x30 */ mMtx_c mMtx2;
+    /* 0x60 */ mVec3_c mMin;
+    /* 0x6C */ mVec3_c mMax;
+    /* 0x78 */ u8 field_0x78[0xB8 - 0x78];
+    /* 0xB8 */ mVec3_c mVirtualCenter;
+    /* 0xC4 */ u32 field_0xC4;
+
+    cM3dGAabb();
+    /* vt 0xC8 */
+    virtual ~cM3dGAabb() {}
+
+    void setWithYRot(const mVec3_c &translation, const mAng &rot);
+    void setMinMax(const mVec3_c &min, const mVec3_c &max);
+};
+
+struct dCcD_SrcAabbAttr {
+    /* 0x00 */ f32 minX, minY, minZ, maxX, maxY, maxZ;
+}; // Size = 0x18
+
+struct dCcD_SrcUnk1Attr {};
+
+class cM3dGUnk1 {
+public:
+    /* 0x00 */ mVec3_c field_0x00;
+    /* 0x0C */ mVec3_c field_0x0C;
+    /* 0x18 */ f32 field_0x18;
+    /* 0x1C */ f32 field_0x1C;
+    /* 0x20 */ u8 field_0x20;
+    /* 0x24 */ u32 field_0x24;
+    /* 0x28 */ mVec3_c mVirtualCenter;
+    cM3dGUnk1();
+};
+
+class cM3dGUnk2 {
+public:
+};
+
+// Unk1
+class dCcD_ShapeAttr1 : public dCcD_ShapeAttr, public cM3dGUnk1 {
+public:
+    dCcD_ShapeAttr1();
+
+    void init(const dCcD_SrcUnk1Attr &);
+
+    /* vt 0x08 */ virtual ~dCcD_ShapeAttr1();
+    /* vt 0x0C */ virtual void dCcD_ShapeAttr_0x0C() override;
+    /* vt 0x10 */ virtual void dCcD_ShapeAttr_0x10() override;
+    /* vt 0x14 */ virtual void dCcD_ShapeAttr_0x14() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x18() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x1C() override;
+    /* vt 0x20 */ virtual void dCcD_ShapeAttr_0x20() override;
+    /* vt 0x24 */ virtual void dCcD_ShapeAttr_0x24() override;
+    /* vt 0x28 */ virtual void dCcD_ShapeAttr_0x28() override;
+    /* vt 0x2C */ virtual void dCcD_ShapeAttr_0x2C() override;
+    /* vt 0x30 */ virtual void dCcD_ShapeAttr_0x30() override;
+    /* vt 0x34 */ virtual void dCcD_ShapeAttr_0x34() override;
+    /* vt 0x38 */ virtual void dCcD_ShapeAttr_0x38() override;
+    /* vt 0x3C */ virtual void dCcD_ShapeAttr_0x3C() override;
+    /* vt 0x40 */ virtual mVec3_c *getVirtualCenter() override;
+    /* vt 0x44 */ virtual void dCcD_ShapeAttr_0x44() override;
+    /* vt 0x48 */ virtual void dCcD_ShapeAttr_0x48() override;
+    /* vt 0x4C */ virtual void getShapeAccess() override;
+    /* vt 0x50 */ virtual void dCcD_ShapeAttr_0x50() override;
+    // /* vt 0x54 */ virtual void dCcD_ShapeAttr_0x54() override;
+    /* vt 0x58 */ virtual void dCcD_ShapeAttr_0x58() override;
+};
+
+// Unk1
+class dCcD_ShapeAttr2 : public dCcD_ShapeAttr, public cM3dGUnk2 {
+public:
+    dCcD_ShapeAttr2();
+
+    /* vt 0x08 */ virtual ~dCcD_ShapeAttr2();
+    /* vt 0x0C */ virtual void dCcD_ShapeAttr_0x0C() override;
+    /* vt 0x10 */ virtual void dCcD_ShapeAttr_0x10() override;
+    /* vt 0x14 */ virtual void dCcD_ShapeAttr_0x14() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x18() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x1C() override;
+    /* vt 0x20 */ virtual void dCcD_ShapeAttr_0x20() override;
+    /* vt 0x24 */ virtual void dCcD_ShapeAttr_0x24() override;
+    /* vt 0x28 */ virtual void dCcD_ShapeAttr_0x28() override;
+    /* vt 0x2C */ virtual void dCcD_ShapeAttr_0x2C() override;
+    /* vt 0x30 */ virtual void dCcD_ShapeAttr_0x30() override;
+    /* vt 0x34 */ virtual void dCcD_ShapeAttr_0x34() override;
+    /* vt 0x38 */ virtual void dCcD_ShapeAttr_0x38() override;
+    /* vt 0x3C */ virtual void dCcD_ShapeAttr_0x3C() override;
+    // /* vt 0x40 */ virtual mVec3_c *getVirtualCenter() override;
+    /* vt 0x44 */ virtual void dCcD_ShapeAttr_0x44() override;
+    /* vt 0x48 */ virtual void dCcD_ShapeAttr_0x48() override;
+    /* vt 0x4C */ virtual void getShapeAccess() override;
+    /* vt 0x50 */ virtual void dCcD_ShapeAttr_0x50() override;
+    // /* vt 0x54 */ virtual void dCcD_ShapeAttr_0x54() override;
+    /* vt 0x58 */ virtual void dCcD_ShapeAttr_0x58() override;
+};
+
+// Aabb
+class dCcD_ShapeAttr5 : public dCcD_ShapeAttr, public cM3dGAabb {
+public:
+    dCcD_ShapeAttr5();
+
+    void init(const dCcD_SrcAabbAttr &);
+
+    /* vt 0x08 */ virtual ~dCcD_ShapeAttr5();
+    /* vt 0x0C */ virtual void dCcD_ShapeAttr_0x0C() override;
+    /* vt 0x10 */ virtual void dCcD_ShapeAttr_0x10() override;
+    /* vt 0x14 */ virtual void dCcD_ShapeAttr_0x14() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x18() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x1C() override;
+    /* vt 0x20 */ virtual void dCcD_ShapeAttr_0x20() override;
+    /* vt 0x24 */ virtual void dCcD_ShapeAttr_0x24() override;
+    /* vt 0x28 */ virtual void dCcD_ShapeAttr_0x28() override;
+    /* vt 0x2C */ virtual void dCcD_ShapeAttr_0x2C() override;
+    /* vt 0x30 */ virtual void dCcD_ShapeAttr_0x30() override;
+    /* vt 0x34 */ virtual void dCcD_ShapeAttr_0x34() override;
+    /* vt 0x38 */ virtual void dCcD_ShapeAttr_0x38() override;
+    /* vt 0x3C */ virtual void dCcD_ShapeAttr_0x3C() override;
+    /* vt 0x40 */ virtual mVec3_c *getVirtualCenter() override;
+    /* vt 0x44 */ virtual void dCcD_ShapeAttr_0x44() override;
+    /* vt 0x48 */ virtual void dCcD_ShapeAttr_0x48() override;
+    // /* vt 0x4C */ virtual void getShapeAccess() override;
+    /* vt 0x50 */ virtual void dCcD_ShapeAttr_0x50() override;
+    // /* vt 0x54 */ virtual void dCcD_ShapeAttr_0x54() override;
+    /* vt 0x58 */ virtual void dCcD_ShapeAttr_0x58() override;
+};
+
+// Cyl
+class dCcD_ShapeAttr3 : public dCcD_ShapeAttr, public cM3dGCyl {
+public:
+    dCcD_ShapeAttr3();
+
+    void init(const dCcD_SrcCylAttr &);
+
+    /* vt 0x08 */ virtual ~dCcD_ShapeAttr3();
+    /* vt 0x0C */ virtual void dCcD_ShapeAttr_0x0C() override;
+    /* vt 0x10 */ virtual void dCcD_ShapeAttr_0x10() override;
+    /* vt 0x14 */ virtual void dCcD_ShapeAttr_0x14() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x18() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x1C() override;
+    /* vt 0x20 */ virtual void dCcD_ShapeAttr_0x20() override;
+    /* vt 0x24 */ virtual void dCcD_ShapeAttr_0x24() override;
+    /* vt 0x28 */ virtual void dCcD_ShapeAttr_0x28() override;
+    /* vt 0x2C */ virtual void dCcD_ShapeAttr_0x2C() override;
+    /* vt 0x30 */ virtual void dCcD_ShapeAttr_0x30() override;
+    /* vt 0x34 */ virtual void dCcD_ShapeAttr_0x34() override;
+    /* vt 0x38 */ virtual void dCcD_ShapeAttr_0x38() override;
+    /* vt 0x3C */ virtual void dCcD_ShapeAttr_0x3C() override;
+    /* vt 0x40 */ virtual mVec3_c *getVirtualCenter() override;
+    /* vt 0x44 */ virtual void dCcD_ShapeAttr_0x44() override;
+    /* vt 0x48 */ virtual void dCcD_ShapeAttr_0x48() override;
+    /* vt 0x4C */ virtual void getShapeAccess() override;
+    /* vt 0x50 */ virtual void dCcD_ShapeAttr_0x50() override;
+    // /* vt 0x54 */ virtual void dCcD_ShapeAttr_0x54() override;
+    /* vt 0x58 */ virtual void dCcD_ShapeAttr_0x58() override;
+};
+
+// Sph
+class dCcD_ShapeAttr4 : public dCcD_ShapeAttr, public cM3dGSph {
+public:
+    dCcD_ShapeAttr4();
+
+    void init(const dCcD_SrcSphAttr &);
+
+    /* vt 0x08 */ virtual ~dCcD_ShapeAttr4();
+    /* vt 0x0C */ virtual void dCcD_ShapeAttr_0x0C() override;
+    /* vt 0x10 */ virtual void dCcD_ShapeAttr_0x10() override;
+    /* vt 0x14 */ virtual void dCcD_ShapeAttr_0x14() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x18() override;
+    /* vt 0x18 */ virtual void dCcD_ShapeAttr_0x1C() override;
+    /* vt 0x20 */ virtual void dCcD_ShapeAttr_0x20() override;
+    /* vt 0x24 */ virtual void dCcD_ShapeAttr_0x24() override;
+    /* vt 0x28 */ virtual void dCcD_ShapeAttr_0x28() override;
+    /* vt 0x2C */ virtual void dCcD_ShapeAttr_0x2C() override;
+    /* vt 0x30 */ virtual void dCcD_ShapeAttr_0x30() override;
+    /* vt 0x34 */ virtual void dCcD_ShapeAttr_0x34() override;
+    /* vt 0x38 */ virtual void dCcD_ShapeAttr_0x38() override;
+    /* vt 0x3C */ virtual void dCcD_ShapeAttr_0x3C() override;
+    /* vt 0x40 */ virtual mVec3_c *getVirtualCenter() override;
+    /* vt 0x44 */ virtual void dCcD_ShapeAttr_0x44() override;
+    /* vt 0x48 */ virtual void dCcD_ShapeAttr_0x48() override;
+    /* vt 0x4C */ virtual void getShapeAccess() override;
+    /* vt 0x50 */ virtual void dCcD_ShapeAttr_0x50() override;
+    /* vt 0x54 */ virtual void dCcD_ShapeAttr_0x54() override;
+    /* vt 0x58 */ virtual void dCcD_ShapeAttr_0x58() override;
+};
+
+#endif
diff --git a/include/toBeSorted/cc/d_cc_m3d.h b/include/toBeSorted/cc/d_cc_m3d.h
new file mode 100644
index 00000000..84459238
--- /dev/null
+++ b/include/toBeSorted/cc/d_cc_m3d.h
@@ -0,0 +1,7 @@
+#ifndef TOSORT_D_CC_M3D_H
+#define TOSORT_D_CC_M3D_H
+
+
+
+
+#endif 
diff --git a/include/toBeSorted/cc/d_cc_m3d_g_cyl.h b/include/toBeSorted/cc/d_cc_m3d_g_cyl.h
new file mode 100644
index 00000000..ad23d4a0
--- /dev/null
+++ b/include/toBeSorted/cc/d_cc_m3d_g_cyl.h
@@ -0,0 +1,24 @@
+#ifndef TO_SORT_D_CC_M3D_G_CYL_H
+#define TO_SORT_D_CC_M3D_G_CYL_H
+
+#include <m/m_vec.h>
+
+class cM3dGCyl {
+public:
+    /* 0x00 */ mVec3_c mCenter;
+    /* 0x0C */ f32 mRadius;
+    /* 0x10 */ f32 mHeight;
+    cM3dGCyl() {}
+
+    void setC(const mVec3_c &, f32 radius, f32 height);
+    void setC(const mVec3_c &);
+    void setH(f32);
+    void setR(f32);
+
+    const mVec3_c &GetC() const {
+        return mCenter;
+    }
+
+}; // Size = 0x14
+
+#endif
diff --git a/include/toBeSorted/cc/d_cc_m3d_g_sph.h b/include/toBeSorted/cc/d_cc_m3d_g_sph.h
new file mode 100644
index 00000000..812f63b7
--- /dev/null
+++ b/include/toBeSorted/cc/d_cc_m3d_g_sph.h
@@ -0,0 +1,23 @@
+#ifndef TO_SORT_D_CC_M3D_G_SPH_H
+#define TO_SORT_D_CC_M3D_G_SPH_H
+
+#include <m/m_vec.h>
+
+class cM3dGSph {
+public:
+    /* 0x00 */ mVec3_c mCenter;
+    /* 0x0C */ f32 mRadius;
+    /* 0x10 */ f32 field_0x10;
+    cM3dGSph();
+
+    void setR(f32);
+    void set(const mVec3_c &, f32);
+    void setC(const mVec3_c &);
+    void setC(f32, f32, f32);
+    const mVec3_c &GetC() const {
+        return mCenter;
+    }
+
+}; // Size = 0x14
+
+#endif
diff --git a/include/toBeSorted/cc/d_cc_mgr.h b/include/toBeSorted/cc/d_cc_mgr.h
new file mode 100644
index 00000000..25686613
--- /dev/null
+++ b/include/toBeSorted/cc/d_cc_mgr.h
@@ -0,0 +1,13 @@
+#ifndef TOSORT_D_CC_MGR_H
+#define TOSORT_D_CC_MGR_H
+
+#include <toBeSorted/cc/d_cc_d.h>
+
+class ColliderManager {
+public:
+    static ColliderManager *getColliderManager();
+
+    void addCollider(dCcD_GObjInf *collider);
+};
+
+#endif
diff --git a/include/toBeSorted/cc/d_cc_shape_colliders.h b/include/toBeSorted/cc/d_cc_shape_colliders.h
new file mode 100644
index 00000000..d46efe3b
--- /dev/null
+++ b/include/toBeSorted/cc/d_cc_shape_colliders.h
@@ -0,0 +1,89 @@
+#ifndef D_CC_SHAPE_COLLIDERS_H
+#define D_CC_SHAPE_COLLIDERS_H
+
+#include <m/m_vec.h>
+#include <toBeSorted/cc/d_cc_d.h>
+
+struct dCcD_SrcUnk {
+    /* 0x00 */ dCcD_SrcGObjInf mObjInf;
+    /* 0x44 */ dCcD_SrcUnk1Attr mUnk1Inf;
+}; // Size: ???
+
+class dCcD_Unk1 : public dCcD_GObjInf, public dCcD_ShapeAttr1 {
+public:
+    dCcD_Unk1();
+    virtual ~dCcD_Unk1();
+
+    virtual void *dCcD_GObjInf_0x0C() override;
+
+    void init(const dCcD_SrcUnk &src);
+    void unknownCalc();
+};
+
+struct dCcD_SrcEmpty {
+    /* 0x00 */ dCcD_SrcGObjInf mObjInf;
+}; // Size: 0x40
+
+// Not sure what this is, the init function
+// doesn't call the shape initializer
+class dCcD_Empty : public dCcD_GObjInf, public dCcD_ShapeAttr2 {
+public:
+    dCcD_Empty();
+    virtual ~dCcD_Empty();
+
+    virtual void *dCcD_GObjInf_0x0C() override;
+
+    void init(const dCcD_SrcEmpty &src);
+};
+
+struct dCcD_SrcCyl {
+    /* 0x00 */ dCcD_SrcGObjInf mObjInf;
+    /* 0x40 */ dCcD_SrcCylAttr mCylAttr;
+}; // Size: 0x44
+
+// Cylinder
+class dCcD_Cyl : public dCcD_GObjInf, public dCcD_ShapeAttr3 {
+public:
+    dCcD_Cyl();
+    virtual ~dCcD_Cyl();
+
+    virtual void *dCcD_GObjInf_0x0C() override;
+    void init(const dCcD_SrcCyl &src);
+    void setCenter(const mVec3_c &);
+    void moveCenter(const mVec3_c &);
+};
+
+struct dCcD_SrcSph {
+    /* 0x00 */ dCcD_SrcGObjInf mObjInf;
+    /* 0x40 */ dCcD_SrcSphAttr mSphAttr;
+}; // Size: 0x44
+
+// Sphere
+class dCcD_Sph : public dCcD_GObjInf, public dCcD_ShapeAttr4 {
+public:
+    dCcD_Sph();
+    virtual ~dCcD_Sph();
+
+    virtual void *dCcD_GObjInf_0x0C() override;
+    void init(const dCcD_SrcSph &src);
+    void setCenter(const mVec3_c &);
+    void moveCenter(const mVec3_c &);
+    void setCenterAndAtVec(const mVec3_c &, const mVec3_c &);
+};
+
+struct dCcD_SrcAabb {
+    /* 0x00 */ dCcD_SrcGObjInf mObjInf;
+    /* 0x40 */ dCcD_SrcAabbAttr mAabbAttr;
+}; // Size: 0x58
+
+class dCcD_Aabb : public dCcD_GObjInf, public dCcD_ShapeAttr5 {
+public:
+    dCcD_Aabb();
+    virtual ~dCcD_Aabb();
+
+    virtual void *dCcD_GObjInf_0x0C() override;
+
+    void init(const dCcD_SrcAabb &src);
+};
+
+#endif
diff --git a/include/toBeSorted/effects_struct.h b/include/toBeSorted/effects_struct.h
new file mode 100644
index 00000000..49773237
--- /dev/null
+++ b/include/toBeSorted/effects_struct.h
@@ -0,0 +1,28 @@
+#ifndef EFFECTS_STRUCT_H
+#define EFFECTS_STRUCT_H
+
+#include <common.h>
+#include <d/a/d_a_base.h>
+
+
+class EffectsStruct {
+private:
+    u8 field_0x00[0x1C - 0x00];
+
+public:
+    // vt at 0x1C
+    EffectsStruct();
+    EffectsStruct(dAcBase_c *);
+    virtual ~EffectsStruct();
+
+    inline void init(dAcBase_c *owner) {
+        mpOwner = owner;
+    }
+
+private:
+    u8 field_0x20[0x28 - 0x20];
+    /* 0x28 */ dAcBase_c *mpOwner;
+    u8 field_0x2C[0x34 - 0x2C];
+};
+
+#endif
diff --git a/include/toBeSorted/event_manager.h b/include/toBeSorted/event_manager.h
new file mode 100644
index 00000000..e95d8db4
--- /dev/null
+++ b/include/toBeSorted/event_manager.h
@@ -0,0 +1,16 @@
+#ifndef EVENT_MANAGER_H
+#define EVENT_MANAGER_H
+
+#include <toBeSorted/event.h>
+
+class dAcBase_c;
+
+class EventManager {
+public:
+    static bool isInEvent(dAcBase_c *actor, const char *eventName);
+    static bool alsoSetAsCurrentEvent(dAcBase_c *actor, Event *event, void *unknown);
+
+    static EventManager *sInstance;
+};
+
+#endif
diff --git a/include/toBeSorted/scgame.h b/include/toBeSorted/scgame.h
index 8ac27782..6572366c 100644
--- a/include/toBeSorted/scgame.h
+++ b/include/toBeSorted/scgame.h
@@ -7,7 +7,7 @@ struct SpawnInfo {
     /* 0x00 */ char stageName[32]; // Probably SizedString<32>
     /* 0x20 */ s16 transitionFadeFrames;
     /* 0x22 */ s8 room;
-    /* 0x23 */ s8 layer;
+    /* 0x23 */ u8 layer;
     /* 0x24 */ s8 entrance;
     /* 0x25 */ s8 night;
     /* 0x26 */ s8 trial;
@@ -26,6 +26,7 @@ public:
     static ScGame *sInstance;
 
     static bool isCurrentStage(const char *stageName);
+    void triggerExit(s32 room, u8 exitIndex, s32 forcedNight = 2, s32 forcedTrial = 2);
 };
 
 #endif