Merge pull request #367 from elijah-thomas774/basesHEADmain

d_a_obj_base OK

13 files changed, 547 insertions, 73 deletions

diff --git a/src/d/a/d_a_base.cpp b/src/d/a/d_a_base.cpp
index 9fac1e7a..afe82995 100644
--- a/src/d/a/d_a_base.cpp
+++ b/src/d/a/d_a_base.cpp
@@ -1,11 +1,13 @@
 #include "d/a/d_a_base.h"
 
 #include "c/c_lib.h"
+#include "c/c_math.h"
 #include "common.h"
 #include "d/a/d_a_player.h"
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/col/bg/d_bg_s.h"
 #include "d/col/bg/d_bg_s_gnd_chk.h"
+#include "d/d_base.h"
 #include "d/d_heap.h"
 #include "d/d_room.h"
 #include "d/d_sc_game.h"
@@ -30,9 +32,9 @@ u32 dAcBase_c::s_Create_Params2 = -1;
 u16 dAcBase_c::s_Create_UnkFlags = -1;
 u8 dAcBase_c::s_Create_ViewClipIdx = -1;
 
-mVec3_c *dAcBase_c::s_Create_Position;
-mAng3_c *dAcBase_c::s_Create_Rotation;
-mVec3_c *dAcBase_c::s_Create_Scale;
+const mVec3_c *dAcBase_c::s_Create_Position;
+const mAng3_c *dAcBase_c::s_Create_Rotation;
+const mVec3_c *dAcBase_c::s_Create_Scale;
 dAcBase_c *dAcBase_c::s_Create_Parent;
 const ActorInfo *dAcBase_c::s_Create_ActorInfo;
 u8 dAcBase_c::s_Create_Subtype;
@@ -84,8 +86,8 @@ dAcBase_c::dAcBase_c()
 dAcBase_c::~dAcBase_c() {}
 
 void dAcBase_c::setTempCreateParams(
-    mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, s32 roomId, u32 params2, dAcBase_c *parent, u8 subtype, u16 unkFlag,
-    s8 viewClipIdx, const ActorInfo *actorInfo
+    const mVec3_c *pos, const mAng3_c *rot, const mVec3_c *scale, s32 roomId, u32 params2, dAcBase_c *parent,
+    u8 subtype, u16 unkFlag, s8 viewClipIdx, const ActorInfo *actorInfo
 ) {
     s_Create_Position = pos;
     s_Create_Rotation = rot;
@@ -268,7 +270,26 @@ void dAcBase_c::postExecute(fBase_c::MAIN_STATE_e state) {
         it->calc();
     }
 
-    // TODO - ...
+    if (state != CANCELED) {
+        unsetActorProperty(AC_PROP_0x20000000);
+        unsetActorProperty(AC_PROP_0x4000000);
+        setActorProperty(AC_PROP_0x10000000);
+
+        // Kill Actors out of bounds, but keep player within bounds
+        if ((mPosition.x < -1000000.0f || mPosition.x > 1000000.0f) ||
+            (mPosition.y < -1000000.0f || mPosition.y > 1000000.0f) ||
+            (mPosition.z < -1000000.0f || mPosition.z > 1000000.0f)) {
+            if (mProfileName == fProfile::PLAYER) {
+                mPosition.x = cM::minMaxLimit(mPosition.x, -1000000.0f, 1000000.0f);
+                mPosition.y = cM::minMaxLimit(mPosition.y, -1000000.0f, 1000000.0f);
+                mPosition.z = cM::minMaxLimit(mPosition.z, -1000000.0f, 1000000.0f);
+            } else {
+                killNoItemDrop();
+            }
+        }
+    }
+
+    dBase_c::postExecute(state);
 }
 
 void dAcBase_c::unkVirtFunc_0x5C() {
@@ -381,7 +402,7 @@ void dAcBase_c::forEveryActor(void *func(dAcBase_c *, dAcBase_c *), dAcBase_c *p
 }
 
 mAng dAcBase_c::getXZAngleToPlayer() const {
-    return cLib::targetAngleY(this->mPosition, dAcPy_c::LINK->mPosition);
+    return cLib::targetAngleY(this->mPosition, dAcPy_c::GetLink()->mPosition);
 }
 
 bool dAcBase_c::getDistanceToActor(dAcBase_c *actor, f32 distThresh, f32 *outDist) {
diff --git a/src/d/a/d_a_bird_base.cpp b/src/d/a/d_a_bird_base.cpp
index 28f481bf..27eb8012 100644
--- a/src/d/a/d_a_bird_base.cpp
+++ b/src/d/a/d_a_bird_base.cpp
@@ -17,7 +17,7 @@ int dAcBirdBase_c::doDelete() {
 }
 
 int dAcBirdBase_c::draw() {
-    drawModelType1(&mMdl.getModel());
+    drawModel(&mMdl.getModel());
     return SUCCEEDED;
 }
 
diff --git a/src/d/a/d_a_fish_base.cpp b/src/d/a/d_a_fish_base.cpp
index e00132f8..54253876 100644
--- a/src/d/a/d_a_fish_base.cpp
+++ b/src/d/a/d_a_fish_base.cpp
@@ -23,8 +23,8 @@ bool dAcFishBase_c::createHeap() {
 }
 
 int dAcFishBase_c::create() {
-    mAcceleration = 0.0f;
-    mMaxSpeed = -40.0f;
+    mGravity = 0.0f;
+    mMaxFallSpeed = -40.0f;
     field_0xA7C = 0;
     field_0xA7E = 0;
     field_0xA80 = cM::rndF(65536.0f);
diff --git a/src/d/a/d_a_item.cpp b/src/d/a/d_a_item.cpp
index bedc7495..bff88bc4 100644
--- a/src/d/a/d_a_item.cpp
+++ b/src/d/a/d_a_item.cpp
@@ -784,8 +784,8 @@ int dAcItem_c::create() {
     mObjAcch.SetRoofCrrHeight(50.0f);
     mObjAcch.SetClrSpeedY();
     mObjAcch.SetField_0xC(4);
-    mAcceleration = -2.0f;
-    mMaxSpeed = -80.0f;
+    mGravity = -2.0f;
+    mMaxFallSpeed = -80.0f;
 
     mGetItemPouchSlot = sGetItemPouchSlot;
     mItemQuantity = sGetItemQuantity;
@@ -1049,8 +1049,9 @@ int dAcItem_c::create() {
         if (type == TEAR_MAX) {
             type = TEAR_FARON;
         }
-        dAcObjBase_c *forceSign =
-            dAcObjBase_c::create(this, fProfile::OBJ_FORCE_SIGN, type & 0xFF, nullptr, nullptr, nullptr, nullptr, 0x3F);
+        dAcObjBase_c *forceSign = dAcObjBase_c::createChildAttached(
+            fProfile::OBJ_FORCE_SIGN, type & 0xFF, nullptr, nullptr, nullptr, nullptr, 0x3F
+        );
         if (forceSign != nullptr) {
             mForceSignRef.link(forceSign);
         }
@@ -1253,7 +1254,7 @@ int dAcItem_c::actorExecute() {
     mCyl.ClrCoHit();
     field_0xD65 = 0;
     if ((isAnyRupeeV() || mId == ITEM_STAMINA_FRUIT) && field_0xD66 && mObjAcch.ChkGroundLanding()) {
-        dJEffManager_c::spawnGroundEffect(mPosition, mPolyAttr0, mPolyAttr1, field_0x1B4, 1, 0.7f, field_0x1B0);
+        dJEffManager_c::spawnGroundEffect(mPosition, mPolyAttr0, mPolyAttr1, mGndNormal, 1, 0.7f, field_0x1B0);
     }
 
     if (isStarryFireflyV() && !checkObjectProperty(OBJ_PROP_0x200)) {
@@ -1305,13 +1306,13 @@ int dAcItem_c::draw() {
             /* nothing */
         } else if (mMdlScaleType == 2) {
             mSphere_c v(mVec3_c(0.0f, 0.0f, 0.0f), getItemFlagStruct(getItemId())->field_0x02);
-            drawShadow(mShdw, nullptr, mWorldMtx, &v, -1, -1, -1, -1, -1, field_0xD18);
+            drawShadow(mShdw, nullptr, mWorldMtx, v, -1, -1, -1, -1, -1, field_0xD18);
         } else {
             mSphere_c v(
                 mVec3_c(0.0f, field_0xCD8 * 0.5f * getItemFlagStruct(getItemId())->field_0x01, 0.0f),
                 field_0xCD8 * getItemFlagStruct(getItemId())->field_0x02
             );
-            drawShadow(mShdw, nullptr, mWorldMtx, &v, -1, -1, -1, -1, -1, field_0xD18);
+            drawShadow(mShdw, nullptr, mWorldMtx, v, -1, -1, -1, -1, -1, field_0xD18);
         }
     }
     return SUCCEEDED;
@@ -1366,7 +1367,7 @@ void dAcItem_c::initializeState_Wait() {
     }
     mMdlScaleType = 0;
     mSinkOffset = 0.0f;
-    mYOffset = 0.0f;
+    mSinkDepth = 0.0f;
 }
 
 void dAcItem_c::executeState_Wait() {
@@ -1594,33 +1595,33 @@ void dAcItem_c::executeState_Wait() {
                 }
 
                 switch (which) {
-                    case 1: mAcceleration = (this->*mFnGetRupeeGravity)(); break;
-                    case 2: mAcceleration = (this->*mFnGetGravity1)(); break;
+                    case 1: mGravity = (this->*mFnGetRupeeGravity)(); break;
+                    case 2: mGravity = (this->*mFnGetGravity1)(); break;
                 }
             } else if (isHeartV()) {
                 if (field_0xD52) {
                     if (mFnGetHeartGravity != nullptr) {
-                        mAcceleration = (this->*mFnGetHeartGravity)();
+                        mGravity = (this->*mFnGetHeartGravity)();
                     }
                 } else {
                     if (mFnGetGravity1 != nullptr) {
-                        mAcceleration = (this->*mFnGetGravity1)();
+                        mGravity = (this->*mFnGetGravity1)();
                     }
                 }
             } else {
                 if (mFnGetRupeeGravity == nullptr || !field_0xD62) {
                     if (mFnGetGravity1 != nullptr) {
-                        mAcceleration = (this->*mFnGetGravity1)();
+                        mGravity = (this->*mFnGetGravity1)();
                     }
                 } else {
                     if (mFnGetRupeeGravity != nullptr) {
-                        mAcceleration = (this->*mFnGetRupeeGravity)();
+                        mGravity = (this->*mFnGetRupeeGravity)();
                     }
                 }
             }
 
             if (mFnGetGravity4 != nullptr) {
-                mMaxSpeed = (this->*mFnGetGravity4)();
+                mMaxFallSpeed = (this->*mFnGetGravity4)();
             }
 
             fn_80256F20();
@@ -1658,7 +1659,7 @@ void dAcItem_c::executeState_Wait() {
                 mSinkOffset = 0.0f;
             }
 
-            mYOffset = mSinkOffset;
+            mSinkDepth = mSinkOffset;
             if (isAnyTear() && mObjAcch.ChkGroundLanding()) {
                 startSoundWithFloatParam(SE_Item_A43_FALL, mVelocity.y);
             }
@@ -1725,7 +1726,7 @@ void dAcItem_c::finalizeState_Wait() {
     mObjAcch.SetRoofNone();
     mObjAcch.Clr_0x2000000();
     mSinkOffset = 0.0f;
-    mYOffset = 0.0f;
+    mSinkDepth = 0.0f;
     if (isTriforce() && mEff_0x928.hasEmitters()) {
         mEff_0x928.remove(true);
     }
diff --git a/src/d/a/d_a_salbage_obj.cpp b/src/d/a/d_a_salbage_obj.cpp
index 81b7173d..6eded1d4 100644
--- a/src/d/a/d_a_salbage_obj.cpp
+++ b/src/d/a/d_a_salbage_obj.cpp
@@ -115,8 +115,8 @@ int dAcSalbageObj_c::preDraw() {
 }
 
 int dAcSalbageObj_c::draw() {
-    drawModelType1(mpMdl);
-    fn_8002edb0(mShadow, *mpMdl, &mShadowSph, -1, -1, field_0x900);
+    drawModel(mpMdl);
+    drawShadow(mShadow, *mpMdl, mShadowSph, -1, -1, field_0x900);
     return SUCCEEDED;
 }
 
@@ -156,7 +156,7 @@ void dAcSalbageObj_c::initSalbageObj() {
             case BEHAVIOR_CARRY: {
                 mSpeed = 0.0f;
                 mVelocity.set(0.0f, 0.0f, 0.0f);
-                mAcceleration = 0.0f;
+                mGravity = 0.0f;
                 mSalvageIf.setHidden();
                 if (dSalvageMgr_c::sInstance->getCurrentSalvageObjId() != mSalvageIf.getSalvageObjId()) {
                     mStateMgr.changeState(StateID_Kill);
@@ -170,7 +170,7 @@ void dAcSalbageObj_c::initSalbageObj() {
             case BEHAVIOR_FLY: {
                 mSpeed = 0.0f;
                 mVelocity.set(0.0f, 0.0f, 0.0f);
-                mAcceleration = 0.0f;
+                mGravity = 0.0f;
                 mStateMgr.changeState(StateID_Fly);
                 break;
             }
@@ -180,11 +180,11 @@ void dAcSalbageObj_c::initSalbageObj() {
                     return;
                 } else {
                     mBehavior = BEHAVIOR_STATIONARY;
-                    mAcceleration = -1.0f;
-                    mMaxSpeed = -40.0f;
+                    mGravity = -1.0f;
+                    mMaxFallSpeed = -40.0f;
                     initCcAndBg();
                     mSpeed = 0.0f;
-                    mAcceleration = 0.0f;
+                    mGravity = 0.0f;
                     mVelocity.set(0.0f, 0.0f, 0.0f);
                     mStateMgr.changeState(StateID_Wait);
                 }
@@ -369,7 +369,7 @@ void dAcSalbageObj_c::initializeState_DemoThrow() {
     mAngle.x = 0;
     mAngle.y = mRotation.y;
     mAngle.z = 0;
-    mMaxSpeed = -40.0f;
+    mMaxFallSpeed = -40.0f;
     mBgObjAcch.Set(this, 1, &mBgAcchCir);
     mBgObjAcch.SetWaterNone();
     mBgObjAcch.SetRoofNone();
diff --git a/src/d/a/obj/d_a_obj_arrow.cpp b/src/d/a/obj/d_a_obj_arrow.cpp
index ee0c1097..15f7b6ed 100644
--- a/src/d/a/obj/d_a_obj_arrow.cpp
+++ b/src/d/a/obj/d_a_obj_arrow.cpp
@@ -647,13 +647,13 @@ void dAcArrow_c::executeState_Move() {
                     }
                 } else {
                     f32 diff = mPosition.distance(field_0x6C8);
-                    if (diff > field_0x6A4 || mAcceleration < 0.0f) {
+                    if (diff > field_0x6A4 || mGravity < 0.0f) {
                         if (isSlingshotProjectile()) {
-                            mAcceleration = -5.0f;
+                            mGravity = -5.0f;
                         } else {
-                            mAcceleration = -2.0f;
+                            mGravity = -2.0f;
                         }
-                        mVelocity.y += mAcceleration;
+                        mVelocity.y += mGravity;
                         if (isSlingshotProjectile()) {
                             dAcPy_c *link = dAcPy_c::GetLink2();
                             f32 xz = mVelocity.absXZ();
@@ -945,6 +945,6 @@ int dAcArrow_c::draw() {
         setInitialPosition();
         unsetArrowFlag(ARROW_INITIAL_SPAWN);
     }
-    drawModelType1(&mModel);
+    drawModel(&mModel);
     return SUCCEEDED;
 }
diff --git a/src/d/a/obj/d_a_obj_base.cpp b/src/d/a/obj/d_a_obj_base.cpp
index ac66e142..ef5ec939 100644
--- a/src/d/a/obj/d_a_obj_base.cpp
+++ b/src/d/a/obj/d_a_obj_base.cpp
@@ -1 +1,453 @@
 #include "d/a/obj/d_a_obj_base.h"
+
+#include "common.h"
+#include "d/a/d_a_base.h"
+#include "d/a/d_a_player.h"
+#include "d/a/obj/d_a_obj_desert.h"
+#include "d/col/bg/d_bg_pc.h"
+#include "d/col/c/c_bg_s_poly_info.h"
+#include "d/col/c/c_m3d_g_pla.h"
+#include "d/d_base.h"
+#include "d/d_bzs_types.h"
+#include "d/d_linkage.h"
+#include "d/d_stage.h"
+#include "d/d_stage_mgr.h"
+#include "d/d_vec.h"
+#include "d/t/d_t_view_clip.h"
+#include "f/f_base.h"
+#include "f/f_list_mg.h"
+#include "f/f_list_nd.h"
+#include "f/f_manager.h"
+#include "f/f_profile.h"
+#include "f/f_profile_name.h"
+#include "m/m3d/m_smdl.h"
+#include "m/m_angle.h"
+#include "m/m_mtx.h"
+#include "m/m_vec.h"
+#include "nw4r/math/math_geometry.h"
+#include "s/s_Math.h"
+#include "toBeSorted/actor_info.h"
+#include "toBeSorted/arc_managers/oarc_manager.h"
+#include "toBeSorted/d_d3d.h"
+#include "toBeSorted/event_manager.h"
+#include "toBeSorted/time_area_mgr.h"
+
+void *dAcObjBase_c::getOarcFile(const char *oarcName, const char *fileName) {
+    return OarcManager::GetInstance()->getData(oarcName, fileName);
+}
+
+void *dAcObjBase_c::getOarcSubEntry(const char *oarcName, const char *fileName) {
+    return OarcManager::GetInstance()->getSubEntryData(oarcName, fileName);
+}
+
+void *dAcObjBase_c::getOarcResFile(const char *oarcName) {
+    return OarcManager::GetInstance()->getMdlFromArc2(oarcName);
+}
+
+void *dAcObjBase_c::getOarcModelFile(const char *oarcName) {
+    return OarcManager::GetInstance()->getMdlFromArc(oarcName);
+}
+
+void *dAcObjBase_c::getOarcZev(const char *oarcName) {
+    return OarcManager::GetInstance()->getZevFromArc(oarcName);
+}
+
+void *dAcObjBase_c::getOarcDZB(const char *oarcName, const char *dzbName) {
+    return OarcManager::GetInstance()->getDzbFromArc(oarcName, dzbName);
+}
+
+void *dAcObjBase_c::getOarcPLC(const char *oarcName, const char *plcName) {
+    return OarcManager::GetInstance()->getPlcFromArc(oarcName, plcName);
+}
+
+dAcObjBase_c::dAcObjBase_c()
+    : mTargetFiTextID(0xFFFF),
+      mCullingDistance(8000.0f),
+      field_0x1A8(400.0f),
+      field_0x1B0(-1e9f),
+      mGndNormal(0.0f, 1.0f, 0.0f),
+      mStts(this),
+      mStartingPos(mPosition.x, mPosition.y, mPosition.z),
+      mStartingRot(mRotation) {
+    mLightingInfo.reset();
+    mpSalvageIf = nullptr;
+    if (s_Create_Rotation != nullptr) {
+        mAngle = *s_Create_Rotation;
+    }
+    if (mpActorInfo != nullptr) {
+        mTargetFiTextID = mpActorInfo->fiTextEntryId;
+    }
+    if (dStageMgr_c::GetInstance()->getStif() != nullptr) {
+        mCullingDistance = dStageMgr_c::GetInstance()->getStif()->defaultCullingDistance;
+    }
+}
+
+dAcObjBase_c::~dAcObjBase_c() {}
+
+int dAcObjBase_c::preCreate() {
+    if (fBase_c::preCreate() == NOT_READY) {
+        return NOT_READY;
+    }
+
+    mOldPosition = mPosition;
+    mPositionCopy2 = mPosition;
+    mPositionCopy3 = mPosition;
+
+    return SUCCEEDED;
+}
+
+int dAcObjBase_c::preExecute() {
+    bool notOk = false;
+    if (dAcBase_c::preExecute() == NOT_READY) {
+        notOk = true;
+    }
+
+    mLinkage.fn_80051190(this);
+
+    unsetObjectProperty(OBJ_PROP_0x4000 | OBJ_PROP_0x400 | OBJ_PROP_0x80 | OBJ_PROP_0x20);
+
+    if (checkObjectProperty(OBJ_PROP_0x40)) {
+        setObjectProperty(OBJ_PROP_0x80);
+    } else if (checkObjectProperty(OBJ_PROP_0x1)) {
+        if (checkActorProperty(AC_PROP_0x1) && checkActorProperty(AC_PROP_0x10000000)) {
+            if (!(EventManager::checkFlag(0x10) || EventManager::FUN_800a0570(this) ||
+                  (checkActorProperty(AC_PROP_0x1000) && dTimeAreaMgr_c::fn_800BBE00()))) {
+                if (!dTimeAreaMgr_c::fn_800BBD40() || !dTgViewClip_c::checkForceOn(mViewClipIdx)) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    if (notOk) {
+        return NOT_READY;
+    }
+
+    if (!checkObjectProperty(OBJ_PROP_0x1)) {
+        unsetObjectProperty(OBJ_PROP_0x40);
+    }
+
+    return SUCCEEDED;
+}
+
+void dAcObjBase_c::postExecute(MAIN_STATE_e state) {
+    if (state != CANCELED) {
+        mOldPosition = mPosition;
+        mStts.Move();
+        if (!mLinkage.checkState(dLinkage_c::STATE_ACTIVE)) {
+            mLinkage.setState(dLinkage_c::STATE_0);
+        }
+        unsetObjectProperty(OBJ_PROP_0x8000 | OBJ_PROP_0x2000);
+    }
+
+    return dAcBase_c::postExecute(state);
+}
+
+extern "C" bool fn_801BB750(f32 f, nw4r::math::AABB &);
+
+int dAcObjBase_c::preDraw() {
+    bool notOk = false;
+    if (dBase_c::preDraw() == NOT_READY) {
+        notOk = true;
+    }
+
+    unsetObjectProperty(OBJ_PROP_0x2 | OBJ_PROP_0x1);
+
+    mMtx_c m = mWorldMtx;
+    m.scaleM(mScale);
+    nw4r::math::AABB aabb;
+    // UHHHH
+    aabb.Set((nw4r::math::AABB *)(&mBoundingBox), m);
+
+    f32 cull = dTgViewClip_c::getCull(mViewClipIdx, mCullingDistance);
+    if (EventManager::checkFlag(0x20)) {
+        cull = FLT_MAX;
+    }
+    if (cull < 0.0f) {
+        if (checkActorProperty(AC_PROP_0x1) && checkActorProperty(AC_PROP_0x2)) {
+            setObjectProperty(OBJ_PROP_0x1 | OBJ_PROP_0x2);
+            return NOT_READY;
+        }
+        cull = mCullingDistance;
+    }
+    if (fn_801BB750(cull, aabb)) {
+        setObjectProperty(OBJ_PROP_0x2);
+    }
+
+    aabb.min.x -= field_0x1A8;
+    aabb.min.y -= field_0x1A8;
+    aabb.min.z -= field_0x1A8;
+
+    aabb.max.x += field_0x1A8;
+    aabb.max.y += field_0x1A8;
+    aabb.max.z += field_0x1A8;
+
+    if (fn_801BB750(cull, aabb)) {
+        setObjectProperty(OBJ_PROP_0x1);
+    }
+
+    if (checkObjectProperty(OBJ_PROP_0x2) && checkActorProperty(AC_PROP_0x2)) {
+        return NOT_READY;
+    }
+
+    if ((notOk || checkObjectProperty(OBJ_PROP_0x200)) ||
+        (mLinkage.checkState(dLinkage_c::STATE_ACTIVE) && mLinkage.getControllingActor()->isPlayer() &&
+         (mLinkage.getControllingActor() && mLinkage.getControllingActor()->checkObjectProperty(OBJ_PROP_0x200)))) {
+        return NOT_READY;
+    }
+
+    return SUCCEEDED;
+}
+
+fLiNdBa_c *dAcObjBase_c::getObjectListEntry() {
+    return nullptr;
+}
+
+bool dAcObjBase_c::restorePosRotFromCopy() {
+    if (!dAcBase_c::restorePosRotFromCopy()) {
+        return false;
+    }
+
+    mOldPosition = mPosition;
+    mAngle = mRotation;
+    return true;
+}
+
+dAcObjBase_c *dAcObjBase_c::create(
+    ProfileName profile, u32 roomID, u32 params, const mVec3_c *pPos, const mAng3_c *pRot, const mVec3_c *pScale,
+    u32 params2
+) {
+    setTempCreateParams(pPos, pRot, pScale, roomID, params2, nullptr, 0, 0xFFFF, 0xFF, nullptr);
+    return static_cast<dAcObjBase_c *>(createBase(profile, dStage_c::getParentForRoom(roomID), params, ACTOR));
+}
+
+dAcObjBase_c *dAcObjBase_c::create(
+    const char *name, u32 roomID, u32 params, const mVec3_c *pPos, const mAng3_c *pRot, const mVec3_c *pScale,
+    u32 params2, u16 id, s8 viewclipId
+) {
+    const ActorInfo *pInfo = getActorInfoByName(name);
+    setTempCreateParams(pPos, pRot, pScale, roomID, params2, nullptr, pInfo->subtype, id, viewclipId, pInfo);
+    return static_cast<dAcObjBase_c *>(createBase(pInfo->profileId, dStage_c::getParentForRoom(roomID), params, ACTOR));
+}
+
+dAcObjBase_c *dAcObjBase_c::findObject(ProfileName actorId, fLiMgBa_c *refList, dAcObjBase_c *parent) {
+    fLiNdBa_c *pNode = parent != nullptr ? parent->getObjectListEntry() : nullptr;
+    pNode = (fLiNdBa_c *)refList->searchNodeByProfName(actorId, pNode);
+    return pNode != nullptr ? (dAcObjBase_c *)pNode->p_owner : nullptr;
+}
+
+dAcObjBase_c *dAcObjBase_c::getNextObject(fLiMgBa_c *ref, dAcObjBase_c *parent) {
+    fLiNdBa_c *pNode = parent != nullptr ? parent->getObjectListEntry()->getNext() : ref->getFirst();
+
+    return pNode != nullptr ? (dAcObjBase_c *)pNode->p_owner : nullptr;
+}
+
+bool dAcObjBase_c::isPlayer() {
+    return this == dAcPy_c::GetLink();
+}
+
+void dAcObjBase_c::calcVelocity(const mVec3_c &pos, f32 speed) {
+    mVec3_c v = pos - mPosition;
+    mVelocity.set((v.x / speed), (mGravity * speed * 0.5f) + (v.y / speed), (v.z / speed));
+}
+
+void dAcObjBase_c::calcVelocity() {
+    f32 f = nw4r::ut::Max(mVelocity.y + mGravity, mMaxFallSpeed);
+    setXYZCirclePoint(mVelocity, mAngle.y, mSpeed, f);
+}
+
+void dAcObjBase_c::updateMatrix() {
+    mWorldMtx.transS(mPosition.x, mPosition.y + getYOffset(), mPosition.z);
+    mWorldMtx.ZXYrotM(mRotation);
+}
+
+void dAcObjBase_c::setDefaultCullDistance() {
+    mCullingDistance = 8000.0f;
+}
+
+bool dAcObjBase_c::canBeLinkedToWoodTag() {
+    return false;
+}
+
+bool dAcObjBase_c::drop() {
+    return true;
+}
+
+void dAcObjBase_c::setSinkDepths(f32 f0, f32 f1, f32 f2, f32 f3, f32 f4, dBgS_Acch *acch) {
+    acch->SetGroundSink();
+    mDeepSinkTarget = f0;
+    mShallowSinkTarget = f1;
+    mDeepSinkRate = f2;
+    mShallowSinkRate = f3;
+    mDefaultSinkRate = f4;
+}
+
+void dAcObjBase_c::calcSinkDepth(const cBgS_PolyInfo &gnd) {
+    f32 target = 0.0f;
+    f32 step = mDefaultSinkRate;
+
+    if (!mLinkage.checkState(dLinkage_c::STATE_ACTIVE)) {
+        int attr = dBgS::GetInstance()->GetSpecialCode(gnd);
+
+        if (attr == POLY_ATTR_SAND_DEEP_INSTANT || attr == POLY_ATTR_LAVA || attr == POLY_ATTR_SAND_DEEP_SLOW ||
+            attr == POLY_ATTR_SAND_MED || attr == POLY_ATTR_CURSED_WATER) {
+            target = mDeepSinkTarget;
+            step = mDeepSinkRate;
+        } else if (attr == POLY_ATTR_SAND_SHALLOW || attr == POLY_ATTR_SAND_SHALLOW2) {
+            target = mShallowSinkTarget;
+            step = mShallowSinkRate;
+        }
+    }
+    sLib::chase(&mSinkDepth, target, step);
+}
+
+void dAcObjBase_c::setGndNormal(const cBgS_PolyInfo &gnd) {
+    cM3dGPla plane;
+    dBgS::GetInstance()->GetTriPla(gnd, &plane);
+    mGndNormal = plane.GetN();
+}
+
+bool dAcObjBase_c::putInODesert(f32 depth, mVec3_c *pos) {
+    dAcODesert *pDesert = static_cast<dAcODesert *>(fManager_c::searchBaseByProfName(fProfile::OBJ_DESERT));
+    if (pDesert != nullptr) {
+        dAcODesert::Entry entry;
+        entry.mIsSet = 1;
+        entry.mPosition = *pos;
+        // entry.field_0x10 = ???
+        entry.field_0x14 = depth;
+        pDesert->addEntry(entry);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void dAcObjBase_c::drawModel(m3d::smdl_c *pMdl) {
+    d3d::setLight(pMdl, mLightingInfo.mLightSetIdx >= 0 ? mLightingInfo.mLightSetIdx : -1, &mLightingInfo);
+    pMdl->entry();
+}
+
+void dAcObjBase_c::drawModel(m3d::smdl_c *pMdl, int lightSetIdx) {
+    d3d::setLight(pMdl, lightSetIdx, &mLightingInfo);
+    pMdl->entry();
+}
+
+bool dAcObjBase_c::drawShadowAlone(m3d::smdl_c &mdl) {
+    bool check;
+    if (dStageMgr_c::GetInstance()->checkFlag0x88A0(0x2)) {
+        check = false;
+    } else {
+        if (mLinkage.fn_800513C0()) {
+            if (mLinkage.getControllingActor()->isActorPlayer()) {
+                static_cast<dAcPy_c *>(mLinkage.getControllingActor())->updateShadow(mdl);
+            }
+            check = false;
+        } else {
+            check = true;
+        }
+    }
+    return check;
+}
+
+bool dAcObjBase_c::drawShadow(
+    dShadowCircle_c &shadow, m3d::smdl_c &mdl, const mSphere_c &sph, s32 priority, s32 alpha, f32 height
+) {
+    return drawShadowAlone(mdl) ? shadow.drawMdl(mdl, sph, mLightingInfo, priority, alpha, this, height) : false;
+}
+
+bool dAcObjBase_c::drawShadow(
+    dShadowCircle_c &shadow, const GXTexObj *pTex, const mMtx_c &mtx, const mSphere_c &sph, s32 priority, s32 alpha,
+    s32 red, s32 green, s32 blue, f32 height
+) {
+    bool check;
+    if (dStageMgr_c::GetInstance()->checkFlag0x88A0(0x2)) {
+        check = false;
+    } else {
+        if (mLinkage.fn_800513C0()) {
+            if (mLinkage.getControllingActor()->isActorPlayer()) {
+                static_cast<dAcPy_c *>(mLinkage.getControllingActor())->updateShadow(sph, mtx);
+            }
+            check = false;
+        } else {
+            check = true;
+        }
+    }
+
+    return check ? shadow.drawTexObj(pTex, mtx, sph, mLightingInfo, priority, alpha, red, green, blue, this, height) :
+                   false;
+}
+
+dAcObjBase_c *dAcObjBase_c::createChildAttached(
+    ProfileName actorId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2, u32 roomId
+) {
+    return static_cast<dAcObjBase_c *>(createActor(actorId, params1, pos, rot, scale, params2, roomId, this));
+}
+dAcObjBase_c *dAcObjBase_c::createChildDetached(
+    ProfileName actorId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2, u32 roomId
+) {
+    return static_cast<dAcObjBase_c *>(createActor(actorId, params1, pos, rot, scale, params2, roomId, nullptr));
+}
+
+void dAcObjBase_c::fn_8002efa0() {
+    if (isRoomFlags_0x6_Set()) {
+        setObjectProperty(OBJ_PROP_0x200);
+    } else {
+        unsetObjectProperty(OBJ_PROP_0x200);
+    }
+}
+bool dAcObjBase_c::fn_8002eff0(
+    const f32 &radius, const s16 &rollRotRange, cCcD_Obj *pCc, const f32 &heightMax, const f32 &heightMin
+) {
+    if (pCc == nullptr || pCc->ChkCoHit()) {
+        dAcPy_c *pPlayer = dAcPy_c::GetLinkM();
+
+        f32 rad = (radius + 40.0f);
+        f32 heightDiffToPlayer = dAcPy_c::GetLinkM()->mPosition.y - mPosition.y;
+
+        bool b = heightDiffToPlayer > heightMin;
+        if (b) {
+            b = heightDiffToPlayer < heightMax;
+        }
+        if (b) {
+            b = pPlayer->checkCurrentAction(12 /* ROLL */);
+        }
+        if (b) {
+            mVec3_c v = pPlayer->mPosition - mPosition;
+            b = v.squareMagXZ() < rad * rad;
+        }
+        if (b) {
+            // TODO: Find a better solution for ang bullsh*t
+            s32 a = getPostionDifference(*pPlayer).atan2sX_Z();
+            mAng b = (mAng)a - pPlayer->mAngle.y;
+            if (mAng(b).abs() < rollRotRange) {
+                pPlayer->setBonkRelatedAnimFlag(false);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+// These may not belong here
+dAcObjBase_c *dAcObjBase_c::createInsectActor(
+    dAcBase_c *parent, ProfileName actorId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2,
+    s32 roomId
+) {
+    return static_cast<dAcObjBase_c *>(parent->createActor(actorId, params1, pos, rot, scale, params2, roomId, parent));
+}
+
+dAcObjBase_c *dAcObjBase_c::createStageActor(
+    ProfileName profile, u32 roomID, u32 params, mVec3_c *pPos, mAng3_c *pRot, mVec3_c *pScale, u32 params2
+) {
+    setTempCreateParams(pPos, pRot, pScale, roomID, params2, nullptr, 0, 0xFFFF, 0xFF, nullptr);
+    return static_cast<dAcObjBase_c *>(createBase(profile, dStage_c::getParentForRoom(roomID), params, STAGE));
+}
+
+dAcObjBase_c *dAcObjBase_c::createStageActor(
+    const char *name, u32 roomID, u32 params, const mVec3_c *pPos, const mAng3_c *pRot, const mVec3_c *pScale,
+    u32 params2, u16 id, s8 viewclipId
+) {
+    const ActorInfo *pInfo = getActorInfoByName(name);
+    setTempCreateParams(pPos, pRot, pScale, roomID, params2, nullptr, pInfo->subtype, id, viewclipId, pInfo);
+    return static_cast<dAcObjBase_c *>(createBase(pInfo->profileId, dStage_c::getParentForRoom(roomID), params, STAGE));
+}
diff --git a/src/d/a/obj/d_a_obj_bomb.cpp b/src/d/a/obj/d_a_obj_bomb.cpp
index 05d5e931..4b00a842 100644
--- a/src/d/a/obj/d_a_obj_bomb.cpp
+++ b/src/d/a/obj/d_a_obj_bomb.cpp
@@ -210,8 +210,8 @@ int dAcBomb_c::create() {
 
     mBoundingBox.Set(sHIO.getBBoxMin(), sHIO.getBBoxMax());
 
-    mAcceleration = dAcPy_c::getBombAcceleration();
-    mMaxSpeed = dAcPy_c::getBombMaxSpeed();
+    mGravity = dAcPy_c::getBombAcceleration();
+    mMaxFallSpeed = dAcPy_c::getBombMaxSpeed();
 
     mFuseTime = dAcPy_c::getBombExplodeTimer();
 
@@ -234,8 +234,8 @@ int dAcBomb_c::create() {
             setFlag(dAcBomb_c::FLAG_PLAYER_MAKE);
             if (checkWaterIn()) {
                 setFlag(dAcBomb_c::FLAG_UNDERWATER);
-                mAcceleration = dAcPy_c::getBombAcceleration_1();
-                mMaxSpeed = dAcPy_c::getBombMaxSpeed_1();
+                mGravity = dAcPy_c::getBombAcceleration_1();
+                mMaxFallSpeed = dAcPy_c::getBombMaxSpeed_1();
             }
             changeState(StateID_Carry);
         } break;
@@ -517,7 +517,7 @@ void dAcBomb_c::initializeState_Explode() {
 
     mSpeed = 0.0f;
     mVelocity = mVec3_c::Zero;
-    mAcceleration = 0.0f;
+    mGravity = 0.0f;
 
     mSph.ClrTgSet();
     mSph.ClrCoSet();
@@ -681,8 +681,8 @@ void dAcBomb_c::executeState_Wait() {
         gndAngle = 0;
     }
 
-    f32 prevAccel = mAcceleration;
-    mVelocity.y = nw4r::ut::Max(mVelocity.y + mAcceleration, mMaxSpeed);
+    f32 prevAccel = mGravity;
+    mVelocity.y = nw4r::ut::Max(mVelocity.y + mGravity, mMaxFallSpeed);
     bombVelocity.y = mVelocity.y;
     mPosition += bombVelocity;
     mPosition += mStts.GetCcMove();
@@ -693,7 +693,7 @@ void dAcBomb_c::executeState_Wait() {
             mVelocity.y = 0.0f;
         }
     }
-    mAcceleration = prevAccel;
+    mGravity = prevAccel;
     f32 prevVelocityY = mVelocity.y;
     s16 a0 = 0;
     s16 a1 = 0;
@@ -711,7 +711,7 @@ void dAcBomb_c::executeState_Wait() {
     f32 sinkTarget = 0.0f;
     f32 sinkRate = 4.0f;
     mVec3_c force = mVec3_c::Zero;
-    f32 sinkValue = mYOffset;
+    f32 sinkValue = mSinkDepth;
     if (mAcch.ChkGndHit() && !mLinkage.checkState(dLinkage_c::STATE_ACTIVE)) {
         s32 attr = dBgS::GetInstance()->GetSpecialCode(mAcch.mGnd);
         if (attr == POLY_ATTR_CURSED_WATER) {
@@ -722,8 +722,8 @@ void dAcBomb_c::executeState_Wait() {
             }
             sinkRate = nw4r::math::FAbs(prevVelocityY);
             mVelocity.y = prevVelocityY;
-            mAcceleration = dAcPy_c::getBombAcceleration_1();
-            mMaxSpeed = dAcPy_c::getBombMaxSpeed_1();
+            mGravity = dAcPy_c::getBombAcceleration_1();
+            mMaxFallSpeed = dAcPy_c::getBombMaxSpeed_1();
         } else if (attr == POLY_ATTR_SAND_DEEP_INSTANT || attr == POLY_ATTR_SAND_DEEP_SLOW ||
                    attr == POLY_ATTR_SAND_MED) {
             sinkTarget = -10.0f;
@@ -735,7 +735,7 @@ void dAcBomb_c::executeState_Wait() {
     }
     cLib::addCalcPosXZ(&mStreamForce, force, 0.5f, 10.0f, 3.0f);
     sLib::chase(&sinkValue, sinkTarget, sinkRate);
-    mYOffset = sinkValue;
+    mSinkDepth = sinkValue;
     if (sinkValue <= -60.0f) {
         setFlag(dAcBomb_c::FLAG_DELETE_BOMB);
     }
@@ -784,7 +784,7 @@ void dAcBomb_c::executeState_Wait() {
         if (prevVelocityY < -5.0f) {
             startSoundWithFloatParam(SE_BM_BOUND, prevVelocityY * -1.0f);
             if (dBgS::GetInstance()->GetPolyAtt0(mAcch.GetGnd()) != POLY_ATT_0_LAVA) {
-                dJEffManager_c::spawnGroundEffect(mPosition, mPolyAttr0, mPolyAttr1, field_0x1B4, 1, 0.8f, field_0x1B0);
+                dJEffManager_c::spawnGroundEffect(mPosition, mPolyAttr0, mPolyAttr1, mGndNormal, 1, 0.8f, field_0x1B0);
             }
         }
 
@@ -994,8 +994,8 @@ void dAcBomb_c::setBombColor() {
             if ( 
             // Is controlled - and by player
             // And Controlling Actor (player) as objprop 0x200 set
-               (mLinkage.checkState(dLinkage_c::STATE_ACTIVE) && static_cast<dAcObjBase_c *>(mLinkage.getControllingActor())->isPlayer()) 
-               && ((pObj = static_cast<dAcObjBase_c *>(mLinkage.getControllingActor())) && pObj->checkObjectProperty(OBJ_PROP_0x200)) 
+               (mLinkage.checkState(dLinkage_c::STATE_ACTIVE) &&mLinkage.getControllingActor()->isPlayer()) 
+               && ((pObj = mLinkage.getControllingActor()) && pObj->checkObjectProperty(OBJ_PROP_0x200)) 
             // OOOOR this bomb has it set.
                || checkObjectProperty(OBJ_PROP_0x200)
             ) {
@@ -1156,8 +1156,8 @@ int dAcBomb_c::actorExecute() {
                 mSpeed *= 0.5f;
                 mVelocity.y *= 0.5f;
 
-                mAcceleration = dAcPy_c::getBombAcceleration_1();
-                mMaxSpeed = dAcPy_c::getBombMaxSpeed_1();
+                mGravity = dAcPy_c::getBombAcceleration_1();
+                mMaxFallSpeed = dAcPy_c::getBombMaxSpeed_1();
             }
 
             if (checkFlag(dAcBomb_c::FLAG_DELETE_BOMB)) {
@@ -1167,8 +1167,8 @@ int dAcBomb_c::actorExecute() {
             }
         } else {
             unsetFlag(dAcBomb_c::FLAG_UNDERWATER);
-            mAcceleration = dAcPy_c::getBombAcceleration();
-            mMaxSpeed = dAcPy_c::getBombMaxSpeed();
+            mGravity = dAcPy_c::getBombAcceleration();
+            mMaxFallSpeed = dAcPy_c::getBombMaxSpeed();
         }
 
         if (mSpeed > 1.0f || f > 1.0f) {
@@ -1250,12 +1250,12 @@ int dAcBomb_c::draw() {
         return SUCCEEDED;
     }
 
-    drawModelType1(&mMdl);
+    drawModel(&mMdl);
 
     mSphere_c sph(mVec3_c(0.0f, mScale.x * sHIO.getBombScale(), 0.0f), mScale.x * sHIO.getBombScale());
 
     if (!isState(StateID_FlowerWait)) {
-        drawShadow(mShdw, nullptr, mWorldMtx, &sph, -1, -1, -1, -1, -1, mPosition.y - mAcch.GetGroundH());
+        drawShadow(mShdw, nullptr, mWorldMtx, sph, -1, -1, -1, -1, -1, mPosition.y - mAcch.GetGroundH());
     }
     return SUCCEEDED;
 }
diff --git a/src/d/a/obj/d_a_obj_boomerang.cpp b/src/d/a/obj/d_a_obj_boomerang.cpp
index d7c707f1..a2320767 100644
--- a/src/d/a/obj/d_a_obj_boomerang.cpp
+++ b/src/d/a/obj/d_a_obj_boomerang.cpp
@@ -565,11 +565,11 @@ int dAcBoomerang_c::draw() {
     if (mStateMgr.isState(StateID_EventReturnWait) || dAcPy_c::GetLink2()->checkModelUpdateFlag(0x10000 | 0x80)) {
         return SUCCEEDED;
     }
-    drawModelType1(&mMdl);
+    drawModel(&mMdl);
     if (!mStateMgr.isState(StateID_Wait)) {
         mProc.entry();
         static mSphere_c sph(mVec3_c::Zero, 50.f);
-        drawShadow(mShadow, nullptr, mWorldMtx, &sph, -1, -1, -1, -1, -1, mPosition.y - mAcch.GetGroundH());
+        drawShadow(mShadow, nullptr, mWorldMtx, sph, -1, -1, -1, -1, -1, mPosition.y - mAcch.GetGroundH());
     }
     return SUCCEEDED;
 }
diff --git a/src/d/a/obj/d_a_obj_fairy.cpp b/src/d/a/obj/d_a_obj_fairy.cpp
index e6b173e7..7b10e258 100644
--- a/src/d/a/obj/d_a_obj_fairy.cpp
+++ b/src/d/a/obj/d_a_obj_fairy.cpp
@@ -78,8 +78,8 @@ int dAcOFairy_c::create() {
     mAcchCir.SetWall(20.0f, 150.0f);
     mObjAcch.SetWaterNone();
     mObjAcch.SetGndThinCellingOff();
-    mAcceleration = 0.0f;
-    mMaxSpeed = -40.0f;
+    mGravity = 0.0f;
+    mMaxFallSpeed = -40.0f;
 
     setPosYWaveParams();
     int rnd = cM::rndInt(40);
@@ -255,12 +255,12 @@ int dAcOFairy_c::actorExecute() {
 
 int dAcOFairy_c::draw() {
     if (!mStateMgr.isState(StateID_CatchDemo)) {
-        drawModelType1(&mModel.getModel());
+        drawModel(&mModel.getModel());
 
         if (!isCuring()) {
             static mSphere_c sph(mVec3_c(0.0f, 0.0f, 0.0f), 10.0f);
             f32 f = mObjAcch.GetGroundH();
-            drawShadow(mShadow, nullptr, mWorldMtx, &sph, -1, -1, -1, -1, -1, mPosition.y - f);
+            drawShadow(mShadow, nullptr, mWorldMtx, sph, -1, -1, -1, -1, -1, mPosition.y - f);
         }
     }
 
diff --git a/src/d/a/obj/d_a_obj_switch.cpp b/src/d/a/obj/d_a_obj_switch.cpp
index 6ffba7c8..11489382 100644
--- a/src/d/a/obj/d_a_obj_switch.cpp
+++ b/src/d/a/obj/d_a_obj_switch.cpp
@@ -206,7 +206,7 @@ int dAcOsw_c::actorExecuteInEvent() {
 }
 
 int dAcOsw_c::draw() {
-    drawModelType1(&mModel);
+    drawModel(&mModel);
 
     return SUCCEEDED;
 }
diff --git a/src/d/a/obj/d_a_obj_tbox.cpp b/src/d/a/obj/d_a_obj_tbox.cpp
index d1747e8f..f310c918 100644
--- a/src/d/a/obj/d_a_obj_tbox.cpp
+++ b/src/d/a/obj/d_a_obj_tbox.cpp
@@ -1508,9 +1508,9 @@ int dAcTbox_c::draw() {
         return SUCCEEDED;
     }
 
-    drawModelType1(&mMdl1.getModel());
+    drawModel(&mMdl1.getModel());
     if (fn_8026D540()) {
-        drawModelType1(&mOpenFxMdl);
+        drawModel(&mOpenFxMdl);
     }
 
     static mSphere_c shadowSphs[4] = {
@@ -1520,7 +1520,7 @@ int dAcTbox_c::draw() {
         mSphere_c(mVec3_c(0.0f, 45.0f, 0.0f), 100.0f),
     };
 
-    drawShadow(mShadowCircle, nullptr, mWorldMtx, &shadowSphs[mVariant], -1, -1, -1, -1, -1, 0.0f);
+    drawShadow(mShadowCircle, nullptr, mWorldMtx, shadowSphs[mVariant], -1, -1, -1, -1, -1, 0.0f);
 
     return SUCCEEDED;
 }
@@ -1571,7 +1571,7 @@ bool dAcTbox_c::isValidVariant(int variant) {
     return 0 <= variant && variant <= 3;
 }
 
-void *dAcTbox_c::getObjectListEntry() {
+fLiNdBa_c *dAcTbox_c::getObjectListEntry() {
     return &mTboxListNode;
 }
 
diff --git a/src/d/a/obj/d_a_obj_water_spout.cpp b/src/d/a/obj/d_a_obj_water_spout.cpp
index 052fa74e..e9c512f7 100644
--- a/src/d/a/obj/d_a_obj_water_spout.cpp
+++ b/src/d/a/obj/d_a_obj_water_spout.cpp
@@ -56,7 +56,7 @@ int dAcOwaterSpout_c::actorExecute() {
 }
 
 int dAcOwaterSpout_c::draw() {
-    drawModelType1(&mMdl.getModel());
+    drawModel(&mMdl.getModel());
     return SUCCEEDED;
 }