cc debug work (#3133)

6 files changed, 336 insertions, 110 deletions

diff --git a/src/d/actor/d_a_tag_sppath.cpp b/src/d/actor/d_a_tag_sppath.cpp
index b40908b387..81fbe04184 100644
--- a/src/d/actor/d_a_tag_sppath.cpp
+++ b/src/d/actor/d_a_tag_sppath.cpp
@@ -97,7 +97,7 @@ int daTagSppath_c::getNearPathPos(cXyz* i_result, dPath* i_path) {
                     if (flatness > 0.001f) {
                         flatness = 30.0f / flatness;
                         if (segLen > flatness) {
-                            line.GetStartP() = line.GetStart() + pntDiff * flatness;
+                            *line.GetStartP() = line.GetStart() + pntDiff * flatness;
                         }
                     }
                 }
@@ -111,7 +111,7 @@ int daTagSppath_c::getNearPathPos(cXyz* i_result, dPath* i_path) {
                     if (flatness > 0.001f) {
                         flatness = 30.0f / flatness;
                         if (segLen > flatness) {
-                            line.GetEndP() = line.GetEnd() + pntDiff * flatness;
+                            *line.GetEndP() = line.GetEnd() + pntDiff * flatness;
                         }
                     }
                 }
diff --git a/src/d/d_bg_w.cpp b/src/d/d_bg_w.cpp
index 1407b38b15..1b4cca4837 100644
--- a/src/d/d_bg_w.cpp
+++ b/src/d/d_bg_w.cpp
@@ -516,8 +516,8 @@ bool cBgW::LineCheckRp(cBgS_LinChk* plinchk, int node_index) {
     cBgW_NodeTree* node = &pm_node_tree[node_index];
 
     if (!cM3d_Cross_MinMaxBoxLine(node->GetMinP(), node->GetMaxP(),
-                                  &plinchk->GetLinP()->GetStartP(),
-                                  &plinchk->GetLinP()->GetEndP()))
+                                  plinchk->GetLinP()->GetStartP(),
+                                  plinchk->GetLinP()->GetEndP()))
     {
         return false;
     }
diff --git a/src/d/d_cc_d.cpp b/src/d/d_cc_d.cpp
index 3c1acd7d5a..1c30502d03 100644
--- a/src/d/d_cc_d.cpp
+++ b/src/d/d_cc_d.cpp
@@ -365,7 +365,7 @@ void dCcD_Cps::Draw(const GXColor& color) {
 
     cXyz cStack_d8;
     CalcVec(&cStack_d8);
-    cMtx_trans(auStack_98, GetStartP().x, GetStartP().y, GetStartP().z);
+    cMtx_trans(auStack_98, GetStartP()->x, GetStartP()->y, GetStartP()->z);
     cM3d_UpMtx(cStack_d8, auStack_c8);
     cMtx_concat(auStack_98, auStack_c8, auStack_68);
     cMtx_scale(auStack_98, GetR(), 0.5f * GetLen(), GetR());
@@ -375,8 +375,8 @@ void dCcD_Cps::Draw(const GXColor& color) {
     cMtx_XrotS(auStack_98, 0x4000);
     cMtx_concat(auStack_68, auStack_98, auStack_68);
     dDbVw_drawCylinderMXlu(auStack_68, color, 1);
-    dDbVw_drawSphereXlu(GetStartP(), GetR(), color, 1);
-    dDbVw_drawSphereXlu(GetEndP(), GetR(), color, 1);
+    dDbVw_drawSphereXlu(*GetStartP(), GetR(), color, 1);
+    dDbVw_drawSphereXlu(*GetEndP(), GetR(), color, 1);
 }
 
 #endif
diff --git a/src/d/d_cc_mass_s.cpp b/src/d/d_cc_mass_s.cpp
index 3a8ecdc7b2..1bc43a4565 100644
--- a/src/d/d_cc_mass_s.cpp
+++ b/src/d/d_cc_mass_s.cpp
@@ -10,16 +10,16 @@
 #include "d/d_cc_d.h"
 #include "f_op/f_op_actor.h"
 
-void dCcMassS_Obj::Set(cCcD_Obj* p_obj, u8 priority, dCcMassS_ObjCallback callback) {
-    mpObj = p_obj;
-    mPriority = priority;
-    mpCallback = callback;
+void dCcMassS_Obj::Set(cCcD_Obj* pobj, u8 priority, dCcMassS_ObjCallback callback) {
+    mpObj = pobj;
+    mPriority = (u8)priority;
+    mpAreaCheckFunc = callback;
 }
 
 void dCcMassS_Obj::Clear() {
     mpObj = NULL;
     mPriority = 5;
-    mpCallback = NULL;
+    mpAreaCheckFunc = NULL;
     mDivideInfo.Set(0, 0, 0);
 }
 
@@ -53,24 +53,30 @@ void dCcMassS_Mng::Ct() {
 void dCcMassS_Mng::SetAttr(f32 radius, f32 height, u8 param_2, u8 param_3) {
     mCylAttr.SetR(radius);
     mCylAttr.SetH(height);
-    field_0x200 = param_2;
-    field_0x201 = param_3;
+    field_0x200 = (u8)param_2;
+    field_0x201 = (u8)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* i = mMassObjs; i < mMassObjs + mMassObjCount; ++i) {
+        cCcD_Obj* pobj = i->GetObj();
+        JUT_ASSERT(123, pobj != NULL);
+
+        cCcD_ShapeAttr* shape = pobj->GetShapeAttr();
+        shape->CalcAabBox();
+        aab.SetMinMax(shape->GetWorkAab());
     }
 
-    for (dCcMassS_Obj* pObj = mMassAreas; pObj < mMassAreas + mMassAreaCount; ++pObj) {
-        cCcD_ShapeAttr* objShape = pObj->GetObj()->GetShapeAttr();
-        objShape->CalcAabBox();
-        aab.SetMinMax(objShape->GetWorkAab());
+    for (dCcMassS_Obj* i = mMassAreas; i < mMassAreas + mMassAreaCount; ++i) {
+        cCcD_Obj* parea = i->GetObj();
+        JUT_ASSERT(135, parea != NULL);
+
+        cCcD_ShapeAttr* shape = parea->GetShapeAttr();
+        shape->CalcAabBox();
+        aab.SetMinMax(shape->GetWorkAab());
     }
 
     if (field_0x202 & 1) {
@@ -79,16 +85,23 @@ void dCcMassS_Mng::Prepare() {
     }
 
     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(), 0);
+
+    for (dCcMassS_Obj* i = mMassObjs; i < mMassObjs + mMassObjCount; ++i) {
+        cCcD_Obj* pobj = i->GetObj();
+        JUT_ASSERT(155, pobj != NULL);
+
+        cCcD_ShapeAttr* shape = pobj->GetShapeAttr();
+        cCcD_DivideInfo* pdivinfo = i->GetPDivideInfo();
+        mDivideArea.CalcDivideInfo(pdivinfo, shape->GetWorkAab(), 0);
     }
 
-    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(), 0);
+    for (dCcMassS_Obj* i = mMassAreas; i < mMassAreas + mMassAreaCount; ++i) {
+        cCcD_Obj* parea = i->GetObj();
+        JUT_ASSERT(166, parea != NULL);
+
+        cCcD_ShapeAttr* shape = parea->GetShapeAttr();
+        cCcD_DivideInfo* pdivinfo = i->GetPDivideInfo();
+        mDivideArea.CalcDivideInfo(pdivinfo, shape->GetWorkAab(), 0);
     }
 
     if (field_0x202 & 1) {
@@ -106,32 +119,36 @@ void dCcMassS_Mng::Prepare() {
     mCamBottomDist = G_CM3D_F_INF;
 }
 
-u32 dCcMassS_Mng::Chk(cXyz* p_xyz, fopAc_ac_c** p_actor, dCcMassS_HitInf* p_hitInf) {
+u32 dCcMassS_Mng::Chk(cXyz* ppos, fopAc_ac_c** ppactor, dCcMassS_HitInf* phitinf) {
     cCcD_DivideInfo divideInfo;
     u32 flagsMaybe = 0;
-    *p_actor = NULL;
+    *ppactor = NULL;
 
-    mCylAttr.SetC(*p_xyz);
+    mCylAttr.SetC(*ppos);
     mCylAttr.CalcAabBox();
 
     mDivideArea.CalcDivideInfoOverArea(&divideInfo, mCylAttr.GetWorkAab());
-    p_hitInf->ClearPointer();
+    phitinf->ClearPointer();
 
     if (field_0x200 & 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();
+            cCcD_DivideInfo* pdivinfo = massObj->GetPDivideInfo();
+            if (pdivinfo->Chk(divideInfo)) {
+                cCcD_Obj* pobj = massObj->GetObj();
+                JUT_ASSERT(226, pobj != NULL);
+
+                cCcD_ShapeAttr* shape = pobj->GetShapeAttr();
                 f32 f;
-                if (obj->ChkCoSet() && mCylAttr.CrossCo(*objShape, &f)) {
+                if (pobj->ChkCoSet() && mCylAttr.CrossCo(*shape, &f)) {
                     flagsMaybe |= 4;
-                    *p_actor = obj->GetStts()->GetAc();
-                    if (p_hitInf != NULL) {
-                        p_hitInf->SetAreaHitObj(obj);
+                    *ppactor = pobj->GetStts()->GetActor();
+                    if (phitinf != NULL) {
+                        phitinf->SetAreaHitObj(pobj);
                     }
 
-                    if (massObj->GetCallback() != NULL) {
-                        massObj->GetCallback()(obj->GetStts()->GetAc(), p_xyz, field_0x201);
+                    if (massObj->GetAreaCheckFunc() != NULL) {
+                        dCcMassS_ObjCallback sp1C = massObj->GetAreaCheckFunc();
+                        sp1C(pobj->GetStts()->GetActor(), ppos, field_0x201);
                     }
                 }
             }
@@ -139,42 +156,46 @@ u32 dCcMassS_Mng::Chk(cXyz* p_xyz, fopAc_ac_c** p_actor, dCcMassS_HitInf* p_hitI
     }
 
     for (dCcMassS_Obj* massObj = mMassObjs; massObj < mMassObjs + mMassObjCount; ++massObj) {
-        if (massObj->GetDivideInfo().Chk(divideInfo)) {
-            cCcD_Obj* obj = massObj->GetObj();
-            dCcD_GObjInf* gobjInf = (dCcD_GObjInf*)obj->GetGObjInf();
-            cCcD_ShapeAttr* objShape = obj->GetShapeAttr();
+        cCcD_DivideInfo* pdivinfo = massObj->GetPDivideInfo();
+        if (pdivinfo->Chk(divideInfo)) {
             cXyz unusedVec;
-            if (obj->ChkAtSet() && !gobjInf->ChkAtNoMass() &&
-                mCylAttr.CrossAtTg(*objShape, &unusedVec) && (field_0x200 & 1))
+            cCcD_Obj* pobj = massObj->GetObj();
+            dCcD_GObjInf* gobjInf = (dCcD_GObjInf*)pobj->GetGObjInf();
+            JUT_ASSERT(266, pobj != NULL);
+            
+            cCcD_ShapeAttr* shape = pobj->GetShapeAttr();
+            
+            if (pobj->ChkAtSet() && !gobjInf->ChkAtNoMass() &&
+                mCylAttr.CrossAtTg(*shape, &unusedVec) && (field_0x200 & 1))
             {
                 flagsMaybe |= 1;
-                *p_actor = obj->GetStts()->GetAc();
-                if (p_hitInf != NULL) {
-                    p_hitInf->SetAtHitObj(obj);
+                *ppactor = pobj->GetStts()->GetActor();
+                if (phitinf != NULL) {
+                    phitinf->SetAtHitObj(pobj);
                 }
             }
 
             f32 f;
-            if (obj->ChkCoSet() && mCylAttr.CrossCo(*objShape, &f) && (field_0x200 & 2)) {
+            if (pobj->ChkCoSet() && mCylAttr.CrossCo(*shape, &f) && (field_0x200 & 2)) {
                 flagsMaybe |= 2;
-                *p_actor = obj->GetStts()->GetAc();
+                *ppactor = pobj->GetStts()->GetActor();
 
                 if (field_0x200 & 0x10) {
-                    Vec vec;
-                    VECSubtract(&(*p_actor)->current.pos, p_xyz, &vec);
+                    cXyz vec;
+                    PSVECSubtract(&(*ppactor)->current.pos, ppos, &vec);
                     vec.y = 0;
-                    f32 vecMag = VECMag(&vec);
+                    f32 vecMag = PSVECMag(&vec);
                     if (cM3d_IsZero(vecMag)) {
                         vec.x = 1;
                     } else {
-                        VECScale(&vec, &vec, f / vecMag);
+                        PSVECScale(&vec, &vec, f / vecMag);
                     }
-                    obj->GetStts()->PlusCcMove(vec.x, vec.y, vec.z);
+                    pobj->GetStts()->PlusCcMove(vec.x, vec.y, vec.z);
                 }
 
-                if (p_hitInf != NULL) {
-                    p_hitInf->SetCoHitObj(obj);
-                    p_hitInf->SetCoHitLen(f);
+                if (phitinf != NULL) {
+                    phitinf->SetCoHitObj(pobj);
+                    phitinf->SetCoHitLen(f);
                 }
             }
         }
@@ -182,18 +203,18 @@ u32 dCcMassS_Mng::Chk(cXyz* p_xyz, fopAc_ac_c** p_actor, dCcMassS_HitInf* p_hitI
 
     f32 f;
     if ((field_0x202 & 1) && mDivideInfo.Chk(divideInfo) && mCylAttr.CrossCo(mCpsAttr, &f)) {
-        mResultCam |= 1;
-        mResultCam |= 1 << (field_0x201 + 1);
+        mResultCam |= (u8)1;
+        mResultCam |= (1 << (field_0x201 + 1));
 
         if ((mResultCam & 2) || (mResultCam & 8)) {
-            cXyz tmpVec;
-            f32 plusH = p_xyz->y + mCylAttr.GetH();
-            tmpVec.x = p_xyz->x;
+            Vec tmpVec;
+            f32 plusH = ppos->y + mCylAttr.GetH();
+            tmpVec.x = ppos->x;
             tmpVec.y = plusH;
-            tmpVec.z = p_xyz->z;
+            tmpVec.z = ppos->z;
 
             if (mCamTopPos.y < (20.0f + plusH)) {
-                f32 newCamTopDist = VECSquareDistance(&tmpVec, &mCpsAttr.GetStartP());
+                f32 newCamTopDist = PSVECSquareDistance(&tmpVec, mCpsAttr.GetStartP());
                 if (mCamTopDist > newCamTopDist) {
                     mCamTopDist = newCamTopDist;
                     mCamTopPos = tmpVec;
@@ -201,7 +222,7 @@ u32 dCcMassS_Mng::Chk(cXyz* p_xyz, fopAc_ac_c** p_actor, dCcMassS_HitInf* p_hitI
             }
 
             if (mCamBottomPos.y < (20.0f + plusH)) {
-                f32 newCamBottomDist = VECSquareDistance(&tmpVec, &mCpsAttr.GetEndP());
+                f32 newCamBottomDist = PSVECSquareDistance(&tmpVec, mCpsAttr.GetEndP());
                 if (mCamBottomDist > newCamBottomDist) {
                     mCamBottomDist = newCamBottomDist;
                     mCamBottomPos = tmpVec;
@@ -231,24 +252,24 @@ void dCcMassS_Mng::Clear() {
     field_0x201 = 4;
 }
 
-void dCcMassS_Mng::Set(cCcD_Obj* p_obj, u8 priority) {
+void dCcMassS_Mng::Set(cCcD_Obj* pobj, u8 priority) {
     if (mMassObjCount >= ARRAY_SIZE(mMassObjs)) {
         for (int i = 0; i < ARRAY_SIZE(mMassObjs); ++i) {
             int prevPrio = mMassObjs[i].GetPriority();
             if (prevPrio > priority || (prevPrio == priority && cM_rndF(1.0f) < 0.5f)) {
-                mMassObjs[i].Set(p_obj, priority, NULL);
+                mMassObjs[i].Set(pobj, priority, NULL);
                 break;
             }
         }
     } else {
-        mMassObjs[mMassObjCount].Set(p_obj, priority, NULL);
+        mMassObjs[mMassObjCount].Set(pobj, priority, NULL);
         mMassObjCount++;
     }
 }
 
-void dCcMassS_Mng::SetCam(cM3dGCps const& cps) {
+void dCcMassS_Mng::SetCam(const cM3dGCps& cps) {
     mCpsAttr.SetCps(cps);
-    field_0x202 |= 1;
+    field_0x202 |= (u8)1;
     mResultCam = 0;
 }
 
@@ -256,6 +277,6 @@ u32 dCcMassS_Mng::GetResultCam() const {
     return mResultCam;
 }
 
-void dCcMassS_Mng::GetCamTopPos(Vec* p_out) {
-    *p_out = mCamTopPos;
+void dCcMassS_Mng::GetCamTopPos(Vec* ppos) {
+    *ppos = mCamTopPos;
 }
diff --git a/src/d/d_cc_s.cpp b/src/d/d_cc_s.cpp
index ccb8501542..de9fa587ed 100644
--- a/src/d/d_cc_s.cpp
+++ b/src/d/d_cc_s.cpp
@@ -10,13 +10,114 @@
 #include "d/d_jnt_col.h"
 #include "f_op/f_op_actor_mng.h"
 
+class dCcS_HIO : public JORReflexible {
+public:
+    enum flags_e {
+        FLAG_CAM_COL_DISP_e   = 0x1,
+        FLAG_AT_ON_e          = 0x2,
+        FLAG_TG_ON_e          = 0x4,
+        FLAG_CO_ON_e          = 0x8,
+        FLAG_DRAW_CLEAR_OFF_e = 0x10,
+        FLAG_COUNTER_e        = 0x20,
+        FLAG_MOVE_OFF_e       = 0x40,
+        FLAG_MASS_OFF_e       = 0x80,
+        FLAG_MOVE_TIMER_e     = 0x100,
+        FLAG_MASS_TIMER_e     = 0x200,
+        FLAG_MASS_COUNTER_e   = 0x400,
+        FLAG_ALL_MASS_TIMER_e = 0x800,
+
+    };
+
+    dCcS_HIO() {
+        m_flags = 0;
+        m_shield_range = 0x4000;
+    }
+
+    virtual ~dCcS_HIO();
+
+    void genMessage(JORMContext*);
+
+    BOOL ChkMoveTimer() { return m_flags & FLAG_MOVE_TIMER_e; }
+    BOOL ChkMoveOff() { return m_flags & FLAG_MOVE_OFF_e; }
+    BOOL ChkAllMassTimer() { return m_flags & FLAG_ALL_MASS_TIMER_e; }
+    BOOL ChkDrawClearOff() { return m_flags & FLAG_DRAW_CLEAR_OFF_e; }
+    BOOL ChkCounter() { return m_flags & FLAG_COUNTER_e; }
+    BOOL ChkCamColDisp() { return m_flags & FLAG_CAM_COL_DISP_e; }
+    BOOL CheckCoOn() { return m_flags & FLAG_CO_ON_e; }
+    BOOL CheckTgOn() { return m_flags & FLAG_TG_ON_e; }
+    BOOL CheckAtOn() { return m_flags & FLAG_AT_ON_e; }
+    BOOL ChkMassCounter() { return m_flags & FLAG_MASS_COUNTER_e; }
+    BOOL ChkMassOff() { return m_flags & FLAG_MASS_OFF_e; }
+    BOOL ChkMassTimer() { return m_flags & FLAG_MASS_TIMER_e; }
+
+    /* 0x4 */ s8 id;
+    /* 0x6 */ u16 m_flags;
+    /* 0x8 */ s16 m_shield_range;
+};
+
+#if DEBUG
+dCcS_HIO::~dCcS_HIO() {}
+
+void dCcS_HIO::genMessage(JORMContext* mctx) {
+    mctx->genLabel("処理関係 -----", 0);
+    mctx->genCheckBox("処理Off", &m_flags, 0x40);
+    mctx->genCheckBox("多数ヒットチェック(草木花)Off", &m_flags, 0x80);
+    mctx->genCheckBox("多数ヒット １回時間", &m_flags, 0x200);
+    mctx->genCheckBox("多数ヒット 通しの処理時間(->terminal)", &m_flags, 0x800);
+    mctx->genCheckBox("多数ヒット チェックカウンタ", &m_flags, 0x400);
+    mctx->genCheckBox("処理時間(->terminal)", &m_flags, 0x100);
+
+    mctx->genLabel("描画関係 -----", 0);
+    mctx->genCheckBox("At 描画", &m_flags, 2);
+    mctx->genCheckBox("Tg 描画", &m_flags, 4);
+    mctx->genCheckBox("Co 描画", &m_flags, 8);
+    mctx->genCheckBox("カメラCo描画", &m_flags, 1);
+    mctx->genCheckBox("クリアOff", &m_flags, 0x10);
+
+    mctx->genLabel("情報(->terminal) -----", 0);
+    mctx->genCheckBox("個数", &m_flags, 0x20);
+
+    mctx->genLabel("特殊-----", 0);
+    mctx->genSlider("盾範囲(max=360度)", &m_shield_range, 0, 0x7FFF);
+}
+
+static OSStopwatch s_move_timer;
+static OSStopwatch s_mass_timer;
+
+static dCcS_HIO s_Hio;
+
+int g_mass_counter;
+#endif
+
 void dCcS::Ct() {
     cCcS::Ct();
+
+    #if DEBUG
+    m_is_mass_all_timer = 0;
+    s_Hio.id = mDoHIO_CREATE_CHILD("zelda コリジョンシステム", &s_Hio);
+
+    OSInitStopwatch(&s_move_timer, "CollsionCheckMove");
+    OSResetStopwatch(&s_move_timer);
+    OSInitStopwatch(&s_mass_timer, "MassCheck");
+    OSResetStopwatch(&s_mass_timer);
+
+    g_mass_counter = 0;
+    #endif
+
     mMass_Mng.Ct();
+
+    #if DEBUG
+    dJntCol_setDebugHIO();
+    #endif
 }
 
 void dCcS::Dt() {
     cCcS::Dt();
+
+    #if DEBUG
+    mDoHIO_DELETE_CHILD(s_Hio.id);
+    dJntCol_deleteDebugHIO();
+    #endif
 }
 
 bool dCcS::ChkShieldFrontRange(cCcD_Obj* i_atObj, cCcD_Obj* i_tgObj, int param_2,
@@ -110,11 +211,11 @@ void dCcS::CalcTgPlusDmg(cCcD_Obj* i_atObj, cCcD_Obj* i_tgObj, cCcD_Stts* i_atSt
 bool dCcS::ChkAtTgHitAfterCross(bool i_setAt, bool i_setTg, cCcD_GObjInf const* i_atObjInf,
                                 cCcD_GObjInf const* i_tgObjInf, cCcD_Stts* i_atStts,
                                 cCcD_Stts* i_tgStts, cCcD_GStts* i_atGStts, cCcD_GStts* i_tgGStts) {
-    dCcD_GObjInf* atObjInf = (dCcD_GObjInf*)i_atObjInf;
-    dCcD_GObjInf* tgObjInf = (dCcD_GObjInf*)i_tgObjInf;
-
     fpc_ProcID tgApid = i_atStts->GetApid();
     fpc_ProcID atApid = i_tgStts->GetApid();
+    
+    dCcD_GObjInf* atObjInf = (dCcD_GObjInf*)i_atObjInf;
+    dCcD_GObjInf* tgObjInf = (dCcD_GObjInf*)i_tgObjInf;
 
     if (i_setAt) {
         static_cast<dCcD_GStts*>(i_atGStts)->SetAtApid(atApid);
@@ -269,9 +370,10 @@ void dCcS::SetPosCorrect(cCcD_Obj* i_co1Obj, cXyz* i_pos1, cCcD_Obj* i_co2Obj, c
     int co1_rank = GetRank(i_co1Obj->GetStts()->GetWeightUc());
     int co2_rank = GetRank(i_co2Obj->GetStts()->GetWeightUc());
     u8 rank = rank_tbl[co1_rank][co2_rank];
+    u8 var_r22 = 100 - rank;
 
     f32 fvar1 = rank * 0.01f;
-    f32 fvar2 = (u8)(100 - rank) * 0.01f;
+    f32 fvar2 = var_r22 * 0.01f;
 
     cXyz co1_move;
     cXyz co2_move;
@@ -279,8 +381,8 @@ void dCcS::SetPosCorrect(cCcD_Obj* i_co1Obj, cXyz* i_pos1, cCcD_Obj* i_co2Obj, c
 
     f32 fvar14;
     if (bvar2) {
-        VECSubtract(i_pos2, i_pos1, &local_c8);
-        fvar14 = VECMag(&local_c8);
+        PSVECSubtract(i_pos2, i_pos1, &local_c8);
+        fvar14 = PSVECMag(&local_c8);
     } else {
         local_c8.x = i_pos2->x - i_pos1->x;
         local_c8.y = 0.0f;
@@ -290,14 +392,15 @@ void dCcS::SetPosCorrect(cCcD_Obj* i_co1Obj, cXyz* i_pos1, cCcD_Obj* i_co2Obj, c
 
     if (!cM3d_IsZero(fvar14)) {
         if (bvar2) {
-            VECScale(&local_c8, &local_c8, i_cross_len / fvar14);
+            f32 var_f26 = i_cross_len / fvar14;
+            PSVECScale(&local_c8, &local_c8, var_f26);
             fvar1 *= -1.0f;
-            VECScale(&local_c8, &co1_move, fvar1);
-            VECScale(&local_c8, &co2_move, fvar2);
+            PSVECScale(&local_c8, &co1_move, fvar1);
+            PSVECScale(&local_c8, &co2_move, fvar2);
         } else {
-            fvar14 = i_cross_len / fvar14;
-            local_c8.x *= fvar14;
-            local_c8.z *= fvar14;
+            f32 var_f27 = i_cross_len / fvar14;
+            local_c8.x *= var_f27;
+            local_c8.z *= var_f27;
 
             co1_move.x = -local_c8.x * fvar1;
             co1_move.y = 0.0f;
@@ -332,27 +435,25 @@ void dCcS::CalcParticleAngle(dCcD_GObjInf* i_atObjInf, cCcD_Stts* i_atStts, cCcD
                              csXyz* o_angle) {
     cXyz vec(*i_atObjInf->GetAtVecP());
 
-    if (cM3d_IsZero(VECMag(&vec))) {
+    if (cM3d_IsZero(PSVECMag(&vec))) {
         fopAc_ac_c* atActor = i_atStts->GetActor();
         fopAc_ac_c* tgActor = i_tgStts->GetActor();
 
         if (atActor == NULL || tgActor == NULL) {
-            vec.z = 0.0f;
-            vec.x = 0.0f;
+            vec.x = vec.z = 0.0f;
             vec.y = -1.0f;
         } else {
-            VECSubtract(&tgActor->current.pos, &atActor->current.pos, &vec);
+            PSVECSubtract(&tgActor->current.pos, &atActor->current.pos, &vec);
 
-            if (cM3d_IsZero(VECMag(&vec))) {
-                vec.z = 0.0f;
-                vec.x = 0.0f;
+            if (cM3d_IsZero(PSVECMag(&vec))) {
+                vec.x = vec.z = 0.0f;
                 vec.y = -1.0f;
             } else {
-                VECNormalize(&vec, &vec);
+                PSVECNormalize(&vec, &vec);
             }
         }
     } else {
-        VECNormalize(&vec, &vec);
+        PSVECNormalize(&vec, &vec);
     }
 
     cM3d_CalcVecZAngle(vec, o_angle);
@@ -441,9 +542,9 @@ void dCcS::SetAtTgGObjInf(bool i_setAt, bool i_setTg, cCcD_Obj* i_atObj, cCcD_Ob
 
         atObjInf->SetAtHitApid(i_tgStts->GetApid());
 
-        if (chk_shield || tgObjInf->GetTgHitMark() == 8 && atObjInf->GetAtMtrl() != dCcD_MTRL_ICE &&
+        if (chk_shield || (tgObjInf->GetTgHitMark() == 8 && atObjInf->GetAtMtrl() != dCcD_MTRL_ICE &&
                               (atObjInf->GetAtSpl() == 0 || atObjInf->GetAtSpl() == 5 ||
-                               atObjInf->GetAtSpl() == 8))
+                               atObjInf->GetAtSpl() == 8)))
         {
             atObjInf->OnAtShieldHit();
         }
@@ -466,7 +567,8 @@ void dCcS::SetAtTgGObjInf(bool i_setAt, bool i_setTg, cCcD_Obj* i_atObj, cCcD_Ob
         if (chk_shield) {
             tgObjInf->OnTgShieldHit();
         } else {
-            i_tgStts->PlusDmg(i_atObj->GetAtAtp());
+            int atp = i_atObj->GetAtAtp();
+            i_tgStts->PlusDmg(atp);
         }
 
         if (at_gstts->ChkNoActor()) {
@@ -523,9 +625,10 @@ bool dCcS::ChkCamera(cXyz& param_0, cXyz& param_1, f32 param_2, fopAc_ac_c* para
                 dCcD_GObjInf* obj = (dCcD_GObjInf*)(*i)->GetGObjInf();
 
                 if (obj == NULL || !obj->ChkCoNoCamHit()) {
-                    cCcD_ShapeAttr* shapeAttr = (*i)->GetShapeAttr();
+                    cCcD_ShapeAttr* pco_sa = (*i)->GetShapeAttr();
+                    JUT_ASSERT(1058, pco_sa != NULL);
 
-                    if (sp48.CrossCo(*shapeAttr, &sp14)) {
+                    if (sp48.CrossCo(*pco_sa, &sp14)) {
                         return true;
                     }
                 }
@@ -604,10 +707,11 @@ bool dCcS::chkCameraPoint(cXyz const& param_0, cCcD_ShapeAttr::Shape* param_1, f
                 dCcD_GObjInf* obj = (dCcD_GObjInf*)(*i)->GetGObjInf();
 
                 if (obj == NULL || !obj->ChkCoNoCamHit()) {
-                    cCcD_ShapeAttr* shapeAttr = (*i)->GetShapeAttr();
+                    cCcD_ShapeAttr* pco_sa = (*i)->GetShapeAttr();
+                    JUT_ASSERT(1196, pco_sa != NULL);
 
-                    if (sp48.CrossCo(*shapeAttr, &sp14)) {
-                        shapeAttr->getShapeAccess(param_1);
+                    if (sp48.CrossCo(*pco_sa, &sp14)) {
+                        pco_sa->getShapeAccess(param_1);
 
                         if (param_1->_0 != 2) {
                             return true;
@@ -626,12 +730,110 @@ void dCcS::MoveAfterCheck() {}
 void dCcS::DrawAfter() {}
 
 void dCcS::Move() {
+    #if DEBUG
+    if (s_Hio.ChkAllMassTimer()) {
+        OnMassAllTimer();
+    } else {
+        OffMassAllTimer();
+    }
+
+    if (s_Hio.ChkMoveOff()) {
+        return;
+    }
+
+    if (s_Hio.ChkMoveTimer()) {
+        OSStartStopwatch(&s_move_timer);
+    }
+    #endif
+
     cCcS::Move();
+
+    #if DEBUG
+    if (s_Hio.ChkMoveTimer()) {
+        OSStopStopwatch(&s_move_timer);
+        OSDumpStopwatch(&s_move_timer);
+    }
+    #endif
 }
 
 void dCcS::Draw() {
+    #if DEBUG
+    if (s_Hio.ChkMassCounter()) {
+        OS_REPORT("Mass Counter %d\n", g_mass_counter);
+        g_mass_counter = 0;
+    }
+
+    if (s_Hio.CheckAtOn()) {
+        for (int i = 0; i < field_0x280c; i++) {
+            if (mpObjAt[i] != NULL && mpObjAt[i]->ChkAtSet()) {
+                dCcD_GObjInf* gobj = (dCcD_GObjInf*)mpObjAt[i]->GetGObjInf();
+                if (gobj->ChkAtHit()) {
+                    GXColor color = {0xFF, 0, 0, 0xB4};
+                    mpObjAt[i]->Draw(color);
+                } else {
+                    GXColor color = {0xFF, 0, 0, 0x50};
+                    mpObjAt[i]->Draw(color);
+                }
+            }
+        }
+    }
+
+    if (s_Hio.CheckTgOn()) {
+        for (int i = 0; i < field_0x280e; i++) {
+            if (mpObjTg[i] != NULL && mpObjTg[i]->ChkTgSet()) {
+                dCcD_GObjInf* gobj = (dCcD_GObjInf*)mpObjTg[i]->GetGObjInf();
+                if (gobj->ChkTgHit()) {
+                    GXColor color = {0, 0xFF, 0, 0xB4};
+                    mpObjTg[i]->Draw(color);
+                } else {
+                    GXColor color = {0, 0xFF, 0, 0x50};
+                    mpObjTg[i]->Draw(color);
+                }
+            }
+        }
+    }
+
+    if (s_Hio.CheckCoOn()) {
+        for (int i = 0; i < field_0x2810; i++) {
+            if (mpObjCo[i] != NULL && mpObjCo[i]->ChkCoSet()) {
+                dCcD_GObjInf* gobj = (dCcD_GObjInf*)mpObjCo[i]->GetGObjInf();
+                if (gobj->ChkCoHit()) {
+                    GXColor color = {0xFF, 0xFF, 0xFF, 0xB4};
+                    mpObjCo[i]->Draw(color);
+                } else {
+                    GXColor color = {0xFF, 0xFF, 0xFF, 0x50};
+                    mpObjCo[i]->Draw(color);
+                }
+            }
+        }
+    }
+
+    if (s_Hio.ChkCamColDisp()) {
+        for (int i = 0; i < field_0x2810; i++) {
+            if (mpObjCo[i] != NULL && mpObjCo[i]->ChkCoSet()) {
+                dCcD_GObjInf* gobj = (dCcD_GObjInf*)mpObjCo[i]->GetGObjInf();
+                if (!gobj->ChkCoNoCamHit()) {
+                    GXColor color = {0xFF, 0xFF, 0, 0x50};
+                    mpObjCo[i]->Draw(color);
+                }
+            }
+        }
+    }
+
+    if (s_Hio.ChkCounter()) {
+        OS_REPORT("At:%d,Tg:%d,Co:%d\n", field_0x280c, field_0x280e, field_0x2810);
+    }
+    #endif
+
     DrawAfter();
-    DrawClear();
+
+    #if DEBUG
+    if (!s_Hio.ChkDrawClearOff())
+    #endif
+    {
+        DrawClear();
+    }
+
     mMass_Mng.Clear();
 }
 
@@ -657,7 +859,10 @@ BOOL dCcS::ChkAtTgMtrlHit(u8 i_atMtrl, u8 i_tgMtrl) {
 }
 
 bool dCcS::ChkNoHitGAtTg(cCcD_GObjInf const* i_atObjInf, cCcD_GObjInf const* i_tgObjInf,
-                         cCcD_GStts*, cCcD_GStts*) {
+                         cCcD_GStts* i_atStts, cCcD_GStts* i_tgStts) {
+    UNUSED(i_atStts);
+    UNUSED(i_tgStts);
+
     dCcD_GObjInf* atObjInf = (dCcD_GObjInf*)i_atObjInf;
     dCcD_GObjInf* tgObjInf = (dCcD_GObjInf*)i_tgObjInf;
 
diff --git a/src/d/d_jnt_col.cpp b/src/d/d_jnt_col.cpp
index 7cf0d4af2b..a4e9e9bafc 100644
--- a/src/d/d_jnt_col.cpp
+++ b/src/d/d_jnt_col.cpp
@@ -376,8 +376,8 @@ int dJntCol_c::searchNearPos(cM3dGLin const* param_1, cXyz const* param_2, cXyz*
                     mDoMtx_stack_c::YrotM(cM_atan2s(-sp1AC.x, sp1AC.z));
                     mDoMtx_stack_c::transM(-sp188.x, -sp188.y, -sp188.z);
                     mDoMtx_stack_c::multVec(&sp17C, &sp194);
-                    mDoMtx_stack_c::multVec(&param_1->GetStartP(), &sp170);
-                    mDoMtx_stack_c::multVec(&param_1->GetEndP(), &sp164);
+                    mDoMtx_stack_c::multVec(param_1->GetStartP(), &sp170);
+                    mDoMtx_stack_c::multVec(param_1->GetEndP(), &sp164);
                     sp1C4.SetStartEnd(sp170, sp164);
                     sp1C = 1;
                 } else {