Updated CC collision (#80)

* c_cc_d soooo close

* d_cc_shape_colliders -> d_cc_d

* ported over changes from #43

* Oops, didnt save

* use better collision functions in bombf

* bombf fixes

* bombf actorPostCreate matching

* fix

* small fix for cCcD_UnkAttr Set function

* more cleanup(?) for c_cc_d

* d_cc_mass_s OK

* Initial d_cc_s setup

* some easy funcs

---------

Co-authored-by: robojumper <robojumper@gmail.com>

1 files changed, 912 insertions, 0 deletions

diff --git a/include/d/col/c/c_cc_d.h b/include/d/col/c/c_cc_d.h
index be4685be..3a1796b1 100644
--- a/include/d/col/c/c_cc_d.h
+++ b/include/d/col/c/c_cc_d.h
@@ -1,4 +1,916 @@
 #ifndef C_CC_D_H
 #define C_CC_D_H
 
+#include "common.h"
+#include "d/a/d_a_base.h"
+#include "d/col/c/c_m3d.h"
+#include "d/col/c/c_m3d_g_aab.h"
+#include "d/col/c/c_m3d_g_cps.h"
+#include "d/col/c/c_m3d_g_cyl.h"
+#include "d/col/c/c_m3d_g_sph.h"
+#include "d/col/c/c_m3d_g_tri.h"
+#include "d/col/c/c_m3d_g_unk.h"
+#include "m/m_vec.h"
+#include "nw4r/types_nw4r.h"
+
+class dAcObjBase_c;
+
+class cCcD_CpsAttr;
+class cCcD_TriAttr;
+class cCcD_UnkAttr;
+class cCcD_CylAttr;
+class cCcD_SphAttr;
+
+class cCcD_DivideInfo {
+private:
+    /* 0x00 */ u32 mXDivInfo;
+    /* 0x04 */ u32 mYDivInfo;
+    /* 0x08 */ u32 mZDivInfo;
+    /* 0x0C vtable */
+public:
+    cCcD_DivideInfo();
+    virtual ~cCcD_DivideInfo();
+
+    // Following two funcs were probably inlined based on how other classes went
+    void Set(u32 xDivInfo, u32 yDivInfo, u32 zDivInfo) {
+        mXDivInfo = xDivInfo;
+        mYDivInfo = yDivInfo;
+        mZDivInfo = zDivInfo;
+    }
+
+    bool Chk(cCcD_DivideInfo const &other) const {
+        if ((mXDivInfo & other.mXDivInfo) && (mZDivInfo & other.mZDivInfo) && (mYDivInfo & other.mYDivInfo)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+};
+
+class cCcD_DivideArea : public cM3dGAab {
+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;
+    /* 0x3C vtable */
+
+public:
+    cCcD_DivideArea();
+    virtual ~cCcD_DivideArea();
+    void SetArea(cM3dGAab const &);
+    void CalcDivideInfo(cCcD_DivideInfo *, cM3dGAab const &);
+    void CalcDivideInfoOverArea(cCcD_DivideInfo *, cM3dGAab const &);
+};
+
+class cCcD_ShapeAttr {
+public:
+    cM3dGAab mAab;
+    cCcD_DivideInfo mInfo;
+    enum ShapeType {
+        SHAPE_SPHERE = 0,
+        SHAPE_CYLINDER = 1,
+        SHAPE_CAPSULE = 2,
+        SHAPE_TRIANGLE = 3,
+        SHAPE_DEFAULT = 4,
+    };
+    struct Shape {
+        ~Shape();
+
+        /* 0x00 */ int mField_0x00;
+        /* 0x04 */ mVec3_c mField_0x04;
+        /* 0x10 */ mVec3_c mField_0x10;
+        /* 0x1C */ mVec3_c mField_0x1C;
+    };
+    cCcD_ShapeAttr();
+    /* vt 0x08 */ virtual ~cCcD_ShapeAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *);
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *);
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) = 0;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) = 0;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) = 0;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) = 0;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) = 0;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *);
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) = 0;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) = 0;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) = 0;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) = 0;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) = 0;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP();
+    /* vt 0x44 */ virtual void CalcAabBox() = 0;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const = 0;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const = 0;
+    /* vt 0x54 */ virtual bool GetPosBool(mVec3_c *) const;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) = 0;
+
+    cM3dGAab &GetWorkAab() {
+        return mAab;
+    }
+    cM3dGAab const &GetWorkAab() const {
+        return mAab;
+    }
+
+    static mVec3_c sVirtualCenter;
+};
+
+struct cCcD_SrcCpsAttr {
+    f32 mRadius;
+};
+class cCcD_CpsAttr : public cCcD_ShapeAttr, public cM3dGCps {
+public:
+    mVec3_c mVirtCenter;
+
+    cCcD_CpsAttr();
+    void Set(const cCcD_SrcCpsAttr &src);
+    void SetVirtCenter(mVec3_c *);
+
+    f32 CrossCoCommon(cCcD_ShapeAttr &, f32);
+
+    /* vt 0x08 */ virtual ~cCcD_CpsAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+class cCcD_TriAttr : public cCcD_ShapeAttr, public cM3dGTri {
+public:
+    cCcD_TriAttr();
+    /* vt 0x08 */ virtual ~cCcD_TriAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+struct cCcD_SrcUnkAttr {
+    f32 mMinX, mMinY, mMinZ;
+    f32 mMaxX, mMaxY, mMaxZ;
+
+    mVec3_c &getMin() const {
+        return *(mVec3_c *)&mMinX;
+    }
+    mVec3_c &getMax() const {
+        return *(mVec3_c *)&mMaxX;
+    }
+};
+
+class cCcD_UnkAttr : public cCcD_ShapeAttr, public cM3dGUnk {
+public:
+    cCcD_UnkAttr();
+
+    void Set(const cCcD_SrcUnkAttr &src);
+    /* vt 0x08 */ virtual ~cCcD_UnkAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+struct cCcD_SrcCylAttr {
+    f32 mRadius;
+    f32 mHeight;
+};
+
+class cCcD_CylAttr : public cCcD_ShapeAttr, public cM3dGCyl {
+public:
+    cCcD_CylAttr();
+    void Set(const cCcD_SrcCylAttr &);
+    /* vt 0x08 */ virtual ~cCcD_CylAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+struct cCcD_SrcSphAttr {
+    f32 mRadius;
+};
+
+class cCcD_SphAttr : public cCcD_ShapeAttr, public cM3dGSph {
+public:
+    cCcD_SphAttr();
+    void Set(const cCcD_SrcSphAttr &);
+    /* vt 0x08 */ virtual ~cCcD_SphAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x54 */ virtual bool GetPosBool(mVec3_c *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+// This has changed bit
+class cCcD_Stts {
+public:
+    /* 0x00 */ int mAtApid;
+    /* 0x04 */ int mAtOldApid;
+    /* 0x08 */ int mTgApid;
+    /* 0x0C */ int mTgOldApid;
+    /* 0x10 */ mVec3_c mField_0x10;
+    /* 0x1C */ mVec3_c mField_0x1C;
+    /* 0x28 */ mVec3_c mCcMove;
+    /* 0x34 */ dAcObjBase_c *mpActor;
+    /* 0x38 */ int mRank;
+
+    cCcD_Stts(dAcObjBase_c *);
+    void Move();
+    int GetID() const;
+    void PlusCcMove(f32, f32, f32);
+    void ClrCcMove();
+    int GetWeight(int) const; // idk what to really call it but it removes the rank table
+
+    void SetDefaultRank() {
+        mRank = 0xD;
+    }
+    void SetRank(int rank) {
+        mRank = rank;
+    }
+    dAcObjBase_c *GetAc() {
+        return mpActor;
+    }
+};
+
+struct cCcD_SrcGObjTgInfo {
+    /* 0x00 */ u16 mField_0x0;
+    /* 0x02 */ u16 mField_0x2;
+};
+
+struct cCcD_SrcGObjTg {
+    /* 0x00 */ u32 mType;
+    /* 0x04 */ u32 mSPrm;
+    /* 0x08 */ cCcD_SrcGObjTgInfo mInfo;
+    /* 0x0C */ u16 mField_0x0C;
+    /* 0x0E */ u16 mField_0x0E;
+};
+
+enum cCcD_AtModifiers_e {
+    /* 0x 0000 0001 */ AT_MOD_FIRE = (1 << 0),
+    /* 0x 0000 0002 */ AT_MOD_0x2 = (1 << 1),
+    /* 0x 0000 0004 */ AT_MOD_ELECTRIC = (1 << 2),
+    /* 0x 0000 0008 */ AT_MOD_WIND = (1 << 3),
+    /* 0x 0000 0010 */ AT_MOD_0x10 = (1 << 4),
+    /* 0x 0000 0020 */ AT_MOD_0x20 = (1 << 5),
+    /* 0x 0000 0040 */ AT_MOD_WATER = (1 << 6),
+    /* 0x 0000 0080 */ AT_MOD_0x80 = (1 << 7),
+    /* 0x 0000 0100 */ AT_MOD_0x100 = (1 << 8),
+    /* 0x 0000 0200 */ AT_MOD_STINKY = (1 << 9),
+    /* 0x 0000 0400 */ AT_MOD_CURSED = (1 << 10),
+};
+struct cCcD_SrcGObjAtInfo {
+    /* 0x00 */ u8 mField_0x0;
+    /* 0x01 */ u8 mField_0x1;
+    /* 0x02 */ u16 mModifier;
+};
+
+enum cCcD_AtSPrm {
+    AT_SPRM_DAMAGE = 0x4,
+};
+
+struct cCcD_SrcGObjAt {
+    /* 0x00 */ u32 mType;
+    /* 0x04 */ u32 mSPrm;
+    /* 0x08 */ cCcD_SrcGObjAtInfo mInfo;
+    /* 0x0C */ u8 mDamage;
+    /* 0x0D */ u8 mField_0xD;
+    /* 0x0E */ u8 mField_0xE;
+    /* 0x0F */ u8 mField_0xF;
+    /* 0x10 */ u16 mField_0x10;
+    /* 0x12 */ s16 mField_0x12;
+};
+
+struct cCcD_SrcGObjCo {
+    /* 0x00 */ u32 mSPrm;
+};
+
+struct cCcD_SrcGObj {
+    /* 0x00 */ cCcD_SrcGObjAt mObjAt;
+    /* 0x14 */ cCcD_SrcGObjTg mObjTg;
+    /* 0x1C */ cCcD_SrcGObjCo mObjCo;
+};
+
+class dAcObjBase_c;
+class cCcD_Obj;
+
+typedef bool (*cCcD_HitCallback)(
+    dAcObjBase_c *i_actorA, cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB
+);
+typedef int (*cCcD_ShieldChkCallback)(
+    dAcObjBase_c *i_actorA, cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB
+);
+
+class cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_HitCallback mHit_cb;
+    s8 mEffCounter;
+    dAcRef_c<dAcObjBase_c> mAc;
+    u32 mRPrm;
+
+    cCcD_GAtTgCoCommonBase();
+
+    virtual ~cCcD_GAtTgCoCommonBase();
+    void dt() {
+        mEffCounter = 0;
+        ClrActorInfo();
+        mHit_cb = nullptr;
+    }
+    void ClrActorInfo();
+    void SetHitActor(dAcObjBase_c *);
+    dAcObjBase_c *GetActor();
+    void SubtractEffCounter();
+
+    bool ChkEffCounter() {
+        return mEffCounter > 0;
+    }
+    void ClrEffCounter() {
+        mEffCounter = 0;
+    }
+    void SetEffCounterTimer() {
+        mEffCounter = 5;
+    }
+
+    u32 MskRPrm(u32 m) const {
+        return mRPrm & m;
+    }
+    void SetRPrm(u32 f) {
+        mRPrm = f;
+    }
+    void OnRPrm(u32 m) {
+        mRPrm |= m;
+    }
+    void OffRPrm(u32 m) {
+        mRPrm = (mRPrm & ~m) | m;
+    }
+};
+
+class cCcD_ObjAt : public cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_ObjAt();
+    virtual ~cCcD_ObjAt();
+    void Set(const cCcD_SrcGObjAt &);
+    void SetAtFlag(u32);
+    void AdjustHitPos(f32, f32);
+
+    void SetVec(const mVec3_c &vec) {
+        mVec = vec;
+    }
+    mVec3_c &GetVec() {
+        return mVec;
+    }
+
+    void SetHitPos(mVec3_c &pos) {
+        mHitPos = pos;
+    }
+    mVec3_c &GetHitPos() {
+        return mHitPos;
+    }
+    void ClrSet() {
+        OffSPrm(1);
+    }
+    u32 ChkSet() {
+        return MskSPrm(1);
+    }
+
+    void SetCallback(cCcD_HitCallback cb) {
+        mHit_cb = cb;
+    }
+
+    u32 MskType(u32 mask) const {
+        return mSrc.mType & mask;
+    }
+    void SetType(u32 flag) {
+        mSrc.mType = flag;
+    }
+    void OnType(u32 m) {
+        mSrc.mType |= m;
+    }
+    void OffType(u32 m) {
+        mSrc.mType &= ~m;
+    }
+    u32 MskSPrm(u32 m) const {
+        return mSrc.mSPrm & m;
+    }
+    void SetSPrm(u32 f) {
+        mSrc.mSPrm = f;
+    }
+    void OnSPrm(u32 m) {
+        mSrc.mSPrm |= m;
+    }
+    void OffSPrm(u32 m) {
+        mSrc.mSPrm &= ~m;
+    }
+    u32 MskTgHitSPrm(u32 m) const {
+        return mTgHitSrc.mSPrm & m;
+    }
+    void SetTgHitSPrm(u32 f) {
+        mTgHitSrc.mSPrm = f;
+    }
+    void OnTgHitSPrm(u32 m) {
+        mTgHitSrc.mSPrm |= m;
+    }
+    void OffTgHitSPrm(u32 m) {
+        mTgHitSrc.mSPrm &= ~m;
+    }
+
+    const cCcD_SrcGObjAt &GetSrc() const {
+        return mSrc;
+    }
+    void SetTgHitSrc(const cCcD_SrcGObjTg &src) {
+        mTgHitSrc = src;
+    }
+    const cCcD_SrcGObjTg &GetTgHitSrc() const {
+        return mTgHitSrc;
+    }
+
+public:
+    /* 0x1C */ cCcD_SrcGObjAt mSrc;
+    /* 0x30 */ mVec3_c mHitPos;
+    /* 0x3C */ mVec3_c mVec;
+    /* 0x48 */ cCcD_SrcGObjTg mTgHitSrc;
+    /* 0x58 */ cCcD_HitCallback mField_0x58;
+};
+
+class cCcD_ObjTg : public cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_ObjTg();
+    virtual ~cCcD_ObjTg();
+    void Set(const cCcD_SrcGObjTg &);
+    void AdjustHitPos(f32, f32);
+
+    void SetHitPos(mVec3_c &pos) {
+        mHitPos = pos;
+    }
+    mVec3_c &GetHitPos() {
+        return mHitPos;
+    }
+
+    u32 GetAtHitType() const {
+        return mAtHitSrc.mType;
+    }
+
+    void SetFlag_0xA(u16 flag) {
+        mSrc.mField_0x0E = flag;
+    }
+
+    u16 GetFlag_0xA(u16 mask) const {
+        return mSrc.mField_0x0E & mask;
+    }
+    void ClrSet() {
+        OffSPrm(1);
+    }
+    u32 ChkSet() {
+        return MskSPrm(1);
+    }
+
+    void Set_0x4C(u32 f) {
+        mField_0x4C = f;
+    }
+
+    u32 MskType(u32 mask) const {
+        return mSrc.mType & mask;
+    }
+    void SetType(u32 flag) {
+        mSrc.mType = flag;
+    }
+    void OnType(u32 m) {
+        mSrc.mType |= m;
+    }
+    void OffType(u32 m) {
+        mSrc.mType &= ~m;
+    }
+    u32 MskSPrm(u32 m) const {
+        return mSrc.mSPrm & m;
+    }
+    void SetSPrm(u32 f) {
+        mSrc.mSPrm = f;
+    }
+    void OnSPrm(u32 m) {
+        mSrc.mSPrm |= m;
+    }
+    void OffSPrm(u32 m) {
+        mSrc.mSPrm &= ~m;
+    }
+    u32 MskAtHitSPrm(u32 m) const {
+        return mAtHitSrc.mSPrm & m;
+    }
+    void SetAtHitSPrm(u32 f) {
+        mAtHitSrc.mSPrm = f;
+    }
+    void OnAtHitSPrm(u32 m) {
+        mAtHitSrc.mSPrm |= m;
+    }
+    void OffAtHitSPrm(u32 m) {
+        mAtHitSrc.mSPrm &= ~m;
+    }
+
+    const cCcD_SrcGObjTg &GetSrc() const {
+        return mSrc;
+    }
+    void SetAtHitSrc(const cCcD_SrcGObjAt &src) {
+        mAtHitSrc = src;
+    }
+    const cCcD_SrcGObjAt &GetAtHitSrc() const {
+        return mAtHitSrc;
+    }
+
+    void Set_0x4B(u8 val) {
+        mField_0x4B = val;
+    }
+
+public:
+    /* 0x1C */ cCcD_SrcGObjTg mSrc;
+    /* 0x2C */ mVec3_c mField_0x2C;
+    /* 0x38 */ mVec3_c mHitPos;
+    /* 0x44 */ s16 *mShieldFrontRangeYAngle;
+    /* 0x48 */ s16 mShieldRange;
+    /* 0x4A */ u8 mField_0x4A;
+    /* 0x4B */ u8 mField_0x4B;
+    /* 0x4C */ u32 mField_0x4C;
+    /* 0x50 */ u32 mField_0x50;
+    /* 0x54 */ cCcD_ShieldChkCallback mField_0x54;
+    /* 0x58 */ cCcD_SrcGObjAt mAtHitSrc;
+    /* 0x6C */ mVec3_c mField_0x6C;
+    /* 0x78 */ cCcD_HitCallback mField_0x78;
+};
+
+class cCcD_ObjCo : public cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_ObjCo();
+    virtual ~cCcD_ObjCo();
+    void Set(const cCcD_SrcGObjCo &);
+    void SetCoFlag(u32);
+    void AdjustHitPos(f32, f32);
+
+    void ClrSet() {
+        OffSPrm(1);
+    }
+    u32 ChkSet() {
+        return MskSPrm(1);
+    }
+    u32 MskSPrm(u32 m) const {
+        return mSrc.mSPrm & m;
+    }
+    void SetSPrm(u32 f) {
+        mSrc.mSPrm = f;
+    }
+    void OnSPrm(u32 m) {
+        mSrc.mSPrm |= m;
+    }
+    void OffSPrm(u32 m) {
+        mSrc.mSPrm &= ~m;
+    }
+
+    const cCcD_SrcGObjCo &GetSrc() const {
+        return mSrc;
+    }
+    void SetCoHitSrc(const cCcD_SrcGObjCo &src) {
+        mCoHitSrc = src;
+    }
+
+public:
+    /* 0x1C */ cCcD_SrcGObjCo mSrc;
+    /* 0x20 */ u32 mGrp;
+    /* 0x24 */ cCcD_SrcGObjCo mCoHitSrc;
+    /* 0x28 */ cCcD_HitCallback mField_0x28_callback;
+};
+
+// Maybe ?
+class cCcD_ObjInf {
+public:
+    /* 0x000 */ cCcD_ObjAt mObjAt;
+    /* 0x05C */ cCcD_ObjTg mObjTg;
+    /* 0x0D8 */ cCcD_ObjCo mObjCo;
+};
+
+class cCcD_Obj {
+public:
+    /* 0x000 */ cCcD_ObjAt mAt;
+    /* 0x05C */ cCcD_ObjTg mTg;
+    /* 0x0D8 */ cCcD_ObjCo mCo;
+    /* 0x104 */ cCcD_Stts *mStts;
+    /* 0x108 */ u32 mField_0x108;
+
+public:
+    cCcD_Obj();
+    virtual ~cCcD_Obj();
+    virtual cCcD_ShapeAttr *GetShapeAttr() = 0;
+    virtual cCcD_ObjInf *GetGObjInfo();
+    void ClrSet();
+    void Set(const cCcD_SrcGObj &);
+    void ClrAtHit();
+    void ClrTgHit();
+    void ClrCoHit();
+
+    const mVec3_c &GetAtHitPos() const;
+    mVec3_c &GetAtHitPos();
+    bool GetAtFlag0x2() const;
+    bool GetAtFlag0x4() const;
+    bool GetAtFlag0x8() const;
+
+    const mVec3_c &GetTgHitPos() const;
+    mVec3_c &GetTgHitPos();
+    bool GetTgFlag0x4() const;
+    bool GetTgFlag0x8() const;
+
+    bool ChkAtClawshot() const;
+    bool ChkAtClawshotDebug() const;
+    bool ChkAtElectrified() const;
+    bool ChkAtElectrifiedExtra() const;
+    bool ChkAtWhippable() const;
+    bool ChkAtBit24() const;
+    bool ChkAtArrowStick() const;
+    bool ChkAtWaterScaleBonk() const;
+    bool ChkAtSwordBonk() const;
+    dAcObjBase_c *GetAtActor();
+
+    bool ChkTgAtHitType(u32) const;
+    u32 GetTg_0x58() const;
+    bool ChkTgBit14() const;
+    u8 GetTgDamage() const;
+    u16 GetTgDamageFlags() const;
+    bool ChkTgSkywardStrike() const;
+    bool ChkTgBit17() const;
+    bool ChkTgBit18() const;
+    bool ChkTgBit19() const;
+    bool ChkTgBit20() const;
+    bool ChkTgBit23() const;
+    bool ChkTgBit24() const;
+    bool ChkTgBit25() const;
+    u16 GetTgSoundID() const;
+    s16 GetTg_0x6A() const;
+    bool ChkTgBit8() const;
+    u8 GetTg_0x4A() const;
+    dAcObjBase_c *GetTgActor();
+    const mVec3_c &GetTg_0x2C() const;
+
+    dAcObjBase_c *GetCoActor();
+    bool ChkCoBit4() const;
+
+    void SetAtFlagsUpper(u32);
+    bool ChkTgBit1() const;
+
+    void AdjustHitPos(f32, f32);
+
+    static bool fn_80328ad0(dAcObjBase_c *pObj, u32 attype);
+
+    // clang-format off
+    cCcD_Stts* GetStts() {
+        return mStts;
+    }
+    void SetStts(cCcD_Stts &stts) { mStts = &stts; }
+
+    void SetAtVec(const mVec3_c &vec) {  mAt.SetVec(vec); }
+
+
+    void OnTgCoFlag(u32 f) {
+        mTg.OnSPrm(f);
+        mCo.OnSPrm(f);
+    }
+
+    void SetTgFlag(u32 flag) {
+        mTg.SetType(flag);
+    }
+    void SetAtFlag(u32 flag) {
+        mAt.SetSPrm(flag);
+    }
+
+    void SetTgFlag_0xA(u16 flag) {
+        mTg.SetFlag_0xA(flag);
+    }
+
+    bool ChkTgHit() {
+        return mTg.MskSPrm(1) != 0 && mTg.GetActor() != nullptr;
+    }
+    bool ChkAtHit() {
+        return mAt.MskSPrm(1) != 0 && mAt.GetActor() != nullptr;
+    }
+    bool ChkCoHit() {
+        return mCo.MskSPrm(1) != 0 && mCo.GetActor() != nullptr;
+    }
+
+    dAcObjBase_c *GetAc() {
+        if (mStts == nullptr) {
+            return nullptr;
+        } else {
+            return mStts->mpActor;
+        }
+    }
+
+    void ClrCoSet() {
+        mCo.ClrSet();
+    }
+    void ClrAtSet() {
+        mAt.ClrSet();
+    }
+    void ClrTgSet() {
+        mTg.ClrSet();
+    }
+    u32 ChkCoSet() {
+        return mCo.ChkSet();
+    }
+    u32 ChkAtSet() {
+        return mAt.ChkSet();
+    }
+    u32 ChkTgSet() {
+        return mTg.ChkSet();
+    }
+
+    
+    bool ChkAtEffCounter() { return mAt.ChkEffCounter(); }
+    bool ChkTgEffCounter() { return mTg.ChkEffCounter(); }
+    void ClrAtEffCounter() { mAt.ClrEffCounter(); }
+    void ClrTgEffCounter() { mTg.ClrEffCounter(); }
+    void ClrCoEffCounter() { mCo.ClrEffCounter(); }
+    void SetAtEffCounterTimer() { mAt.SetEffCounterTimer(); }
+    void SetTgEffCounterTimer() { mTg.SetEffCounterTimer(); }
+    void SubtractAtEffCounter() { mAt.SubtractEffCounter(); }
+    void SubtractTgEffCounter() { mTg.SubtractEffCounter(); }
+    void SubtractCoEffCounter() { mCo.SubtractEffCounter(); }
+
+    void SetTg_0x4C(u32 f) {
+        mTg.Set_0x4C(f);
+    }
+
+    void SetAtCallback(cCcD_HitCallback cb) {
+        mAt.SetCallback(cb);
+    }
+
+    u32 ChkTgNoAtHitInfSet() const {
+        return mTg.MskSPrm(0x40);
+    }
+    u32 ChkAtNoTgHitInfSet() const {
+        return mAt.MskSPrm(0x40);
+    }
+    u32 ChkCoNoCoHitInfSet() const {
+        return mCo.MskSPrm(0x800); 
+    }
+
+    // At
+
+    u32 ChkAtNoMass() const {
+        return mAt.MskSPrm(0x400);
+    }
+    u32 GetAtGrp() const {
+        return mAt.MskSPrm(0x3E);
+    }
+    u32 ChkAtNoConHit() const {
+        return mAt.MskSPrm(0x80);
+    }
+    u32 ChkAtStopNoConHit() const {
+        return mAt.MskSPrm(0x200);
+    }
+    u32 ChkAtNoGaurd() const {
+        return mAt.MskSPrm(0x200000);
+    }
+
+    // Tg
+
+    u32 GetTgGrp() const {
+        return mTg.MskSPrm(0x3E);
+    }
+    u32 ChkTgNoConHit() const {
+        return mTg.MskSPrm(0x100);
+    }
+    u32 ChkTgStopNoConHit() const {
+        return mTg.MskSPrm(0x100000);
+    }
+    u32 ChkTgShieldFrontRange() const {
+        return mTg.MskSPrm(0x400);
+    }
+
+    void SetTg_0x4B(u8 val) {
+        mTg.Set_0x4B(val);
+    }
+
+    // Co
+
+    u32 ChkCoSet2() const {
+        return mCo.MskSPrm(0x800);
+    }
+    u32 ChkCoNoCamHit() const {
+        return mCo.MskSPrm(0x4000);
+    }
+    u32 ChkCoSameActorHit() const {
+        return mCo.MskSPrm(0x1000);
+    }
+
+    /**
+     * SET HIT
+     */
+
+    // Actor Objs
+    void SetAtHit(cCcD_Obj *other) {
+        mAt.SetHitActor(other->GetAc());
+    }
+    void SetTgHit(cCcD_Obj *other) {
+        mTg.SetHitActor(other->GetAc());
+    }
+    void SetCoHit(cCcD_Obj *other) {
+        mCo.SetHitActor(other->GetAc());
+    }
+
+    // Hit Positions
+    void SetAtHitPos(mVec3_c &pos) {
+        mAt.SetHitPos(pos);
+    }
+    void SetTgHitPos(mVec3_c &pos) {
+        mTg.SetHitPos(pos);
+    }
+
+    /**
+     * SET SOURCES
+     */
+
+    void SetAtTgHitSrc(cCcD_Obj *tg) {
+        mAt.SetTgHitSrc(tg->mTg.GetSrc());
+    }
+    void SetTgAtHitSrc(cCcD_Obj *at) {
+        mTg.SetAtHitSrc(at->mAt.GetSrc());
+    }
+    void SetCoCoHitSrc(cCcD_Obj *co) {
+        mCo.SetCoHitSrc(co->mCo.GetSrc());
+    }
+
+    // clang-format on
+};
+
 #endif