Merge pull request #309 from elijah-thomas774/Various-Actors

Various actors

src/REL/d/a/npc/d_a_npc_rival_lod.cpp

@@ -14,9 +14,7 @@ bool dAcNpcRivalLOD_c::createHeap() {
     return true;
 }
 int dAcNpcRivalLOD_c::create() {
-    if (!initAllocatorWork1Heap(-1, "dAcNpcRivalLOD_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR(dAcNpcRivalLOD_c);
     0.0f; // float order, cool
     mAcceleration = -1.0f;
     mMaxSpeed = -40.0f;

src/REL/d/a/obj/d_a_obj_barrel.cpp

@@ -28,7 +28,6 @@
 #include "m/m_mtx.h"
 #include "m/m_quat.h"
 #include "m/m_vec.h"
-#include "math.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
 #include "nw4r/math/math_arithmetic.h"
 #include "rvl/MTX/mtxvec.h"

src/REL/d/a/obj/d_a_obj_bell.cpp

@@ -1,11 +1,71 @@
 #include "d/a/obj/d_a_obj_bell.h"
 
+#include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/col/bg/d_bg_plc.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_w.h"
+#include "d/col/cc/d_cc_d.h"
+#include "d/d_stage.h"
+#include "f/f_base.h"
+#include "m/m_vec.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "toBeSorted/arc_managers/current_stage_arc_manager.h"
+#include "toBeSorted/dowsing_target.h"
+
 SPECIAL_ACTOR_PROFILE(OBJ_BELL, dAcObell_c, fProfile::OBJ_BELL, 0x208, 0, 2);
 
 STATE_DEFINE(dAcObell_c, Wait);
 STATE_DEFINE(dAcObell_c, WaitRupee);
 STATE_DEFINE(dAcObell_c, After);
 
+static dCcD_SrcSph sSrcSph = {
+    // TODO
+};
+
+bool dAcObell_c::createHeap() {
+    mResFile = nw4r::g3d::ResFile(CurrentStageArcManager::GetInstance()->getData("g3d/stage.brres"));
+    dStage_c::bindStageResToFile(&mResFile);
+    dStage_c::bindSkyCmnToResFile(&mResFile);
+
+    nw4r::g3d::ResMdl resMdl = mResFile.GetResMdl("StageF000Bell");
+    TRY_CREATE(mMdl.create(resMdl, &mAllocator, 0x120));
+
+    cBgD_t *dzb = (cBgD_t *)CurrentStageArcManager::GetInstance()->getData("dzb/StageF000Bell.dzb");
+    PLC *plc = (PLC *)CurrentStageArcManager::GetInstance()->getData("dat/StageF000Bell.plc");
+    updateMatrix();
+
+    TRY_CREATE(!(BOOL)mBgW.Set(dzb, plc, 1, &mWorldMtx, &mScale));
+
+    return true;
+}
+
+int dAcObell_c::create() {
+    CREATE_ALLOCATOR(dAcObell_c);
+
+    mBgW.SetCrrFunc(dBgS_MoveBGProc_Typical);
+    dBgS::GetInstance()->Regist(&mBgW, this);
+
+    mStts.SetRank(13);
+    mSph.Set(sSrcSph);
+    mSph.SetStts(mStts);
+
+    mRupeeDir = mVec3_c(0.f, -300.f, 0.f);
+    field_0x718 = mVec3_c(0.f, -210.f, 0.f);
+
+    mDowsingTarget.initialize(DowsingTarget::SLOT_RUPEE, 0, nullptr, 0.f);
+    mDowsingTarget.doRegister();
+    mDowsingTarget.setOffset(mVec3_c::Ey * -150.f);
+
+    mStateMgr.changeState(StateID_Wait);
+
+    mMdl.setPriorityDraw(0x1C, 9);
+    mBoundingBox.Set(mVec3_c(-160.f, -320.f, -160.f), mVec3_c(160.f, 10.f, 160.f));
+    mCullingDistance = 50000.f;
+    return SUCCEEDED;
+}
+
 void dAcObell_c::initializeState_Wait() {}
 void dAcObell_c::executeState_Wait() {}
 void dAcObell_c::finalizeState_Wait() {}

src/REL/d/a/obj/d_a_obj_bird_statue.cpp

@@ -1,5 +1,7 @@
 #include "d/a/obj/d_a_obj_bird_statue.h"
 
+#include "d/a/obj/d_a_obj_base.h"
+
 SPECIAL_ACTOR_PROFILE(OBJ_BIRD_STATUE, dAcOBirdStatue_c, fProfile::OBJ_BIRD_STATUE, 0x285, 0, 3);
 
 bool dAcOBirdStatue_c::createHeap() {
@@ -22,9 +24,7 @@ bool dAcOBirdStatue_c::createHeap() {
 }
 
 int dAcOBirdStatue_c::create() {
-    if (!initAllocatorWork1Heap(0xffffffff, "dAcOBirdStatue_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR(dAcOBirdStatue_c);
     updateMatrix();
     mMdl.setLocalMtx(mWorldMtx);
     mVec3_c min, max;

src/REL/d/a/obj/d_a_obj_chest.cpp

@@ -109,9 +109,7 @@ bool dAcOChest_c::createHeap() {
 }
 
 int dAcOChest_c::create() {
-    if (!initAllocatorWork1Heap(0x4000, "dAcOChest_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR_SIZE(dAcOChest_c, 0x4000);
     mBgW.Lock();
     dBgS::GetInstance()->Regist(&mBgW, this);
     dBgS::GetInstance()->RegistBg(&mBgW, this);

src/REL/d/a/obj/d_a_obj_decoB.cpp

@@ -2,6 +2,7 @@
 
 #include "common.h"
 #include "d/a/d_a_player.h"
+#include "d/a/obj/d_a_obj_base.h"
 #include "f/f_base.h"
 #include "m/m_vec.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
@@ -20,9 +21,7 @@ bool dAcODecoB_c::createHeap() {
 }
 
 int dAcODecoB_c::create() {
-    if (!initAllocatorWork1Heap(0x1000, "dAcODecoB_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR_SIZE(dAcODecoB_c, 0x1000);
     mAcceleration = 0.0f;
     mMaxSpeed = 0.0f;
     mStateMgr.changeState(StateID_Wait);

src/REL/d/a/obj/d_a_obj_dormitory_gate.cpp

@@ -1,10 +1,134 @@
 #include "d/a/obj/d_a_obj_dormitory_gate.h"
 
+#include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_w.h"
+#include "d/col/c/c_m3d_g_aab.h"
+#include "d/d_stage.h"
+#include "d/flag/storyflag_manager.h"
+#include "f/f_base.h"
+#include "m/m_vec.h"
+#include "nw4r/g3d/res/g3d_resanmclr.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "nw4r/g3d/res/g3d_resnode.h"
+#include "toBeSorted/arc_managers/current_stage_arc_manager.h"
+
 SPECIAL_ACTOR_PROFILE(OBJ_DORMITORY_GATE, dAcODormitoryGate_c, fProfile::OBJ_DORMITORY_GATE, 0x17A, 0, 3);
 
 STATE_DEFINE(dAcODormitoryGate_c, Wait);
 STATE_DEFINE(dAcODormitoryGate_c, End);
 
+static const char *sGateMdls[4] = {
+    "StageF000Gate",
+    "StageF000GodDoor",
+    "StageF000Shutter",
+    "StageF400Gate",
+};
+static const char *sGateDZB[4] = {
+    "dzb/StageF000Gate.dzb",
+    "dzb/StageF000GodDoor.dzb",
+    "dzb/StageF000Shutter.dzb",
+    "dzb/StageF400Gate.dzb",
+};
+static const char *sGatePLC[4] = {
+    "dat/StageF000Gate.plc",
+    "dat/StageF000GodDoor.plc",
+    "dat/StageF000Shutter.plc",
+    "dat/StageF400Gate.plc",
+};
+bool dAcODormitoryGate_c::createHeap() {
+    mResFile = nw4r::g3d::ResFile(CurrentStageArcManager::GetInstance()->getData("g3d/stage.brres"));
+    dStage_c::bindStageResToFile(&mResFile);
+    dStage_c::bindSkyCmnToResFile(&mResFile);
+
+    nw4r::g3d::ResMdl resMdl = mResFile.GetResMdl(sGateMdls[mSubtype]);
+    if (mSubtype == TYPE_GATE || mSubtype == TYPE_GATE_F400) {
+        mNumDoors = 2;
+    } else {
+        mNumDoors = 1;
+    }
+
+    // TODO: Rename - Opens the Doors
+    fn_534_C80();
+    fn_534_D40();
+    for (int i = 0; i < mNumDoors; ++i) {
+        if (!mMdls[i].create(resMdl, &mAllocator, 0x120, 1, nullptr)) {
+            return false;
+        }
+        cBgD_t *dzb = (cBgD_t *)CurrentStageArcManager::GetInstance()->getData(sGateDZB[mSubtype]);
+        PLC *plc = (PLC *)CurrentStageArcManager::GetInstance()->getData(sGatePLC[mSubtype]);
+        if (mSubtype != TYPE_GODDOOR) {
+            mMdls[i].setPriorityDraw(0x1C, -1);
+        }
+
+        // TODO: Return Type
+        s32 tmp = !(BOOL)mCollision[i].Set(dzb, plc, 1, &mDoorMtx[i], &mScale);
+        if (tmp != 0) {
+            return false;
+        }
+    }
+
+    if (mSubtype == TYPE_GODDOOR) {
+        nw4r::g3d::ResMdl mdl = mResFile.GetResMdl(sGateMdls[mSubtype]);
+        nw4r::g3d::ResAnmClr anmClr = mResFile.GetResAnmClr("StageF000GodDoor");
+        if (!mAnmMatClr.create(mdl, anmClr, &mAllocator, nullptr, 1)) {
+            return false;
+        }
+        mMdls[0].setAnm(mAnmMatClr);
+        mAnmMatClr.setRate(0.f, 0);
+        mScnCallback.attach(mMdls[0]);
+    }
+    return true;
+}
+
+int dAcODormitoryGate_c::create() {
+    mSubtype = static_cast<Type_e>(getFromParams(8, 0xFF));
+    if (mSubtype == 1 && StoryflagManager::sInstance->getFlag(STORYFLAG_GODDESS_STATUE_ACCESS)) {
+        return FAILED;
+    }
+
+    if (mSubtype == TYPE_GATE_F400) {
+        mStoryflag = getFromParams(16, 0x7FF);
+    }
+
+    CREATE_ALLOCATOR_SIZE(dAcODormitoryGate_c, 0x2000);
+
+    for (int i = 0; i < mNumDoors; ++i) {
+        dBgS::GetInstance()->Regist(&mCollision[i], this);
+    }
+
+    mStateMgr.changeState(StateID_Wait);
+
+    mVec3_c min, max;
+    switch (mSubtype) {
+        case TYPE_GATE:
+        case TYPE_GATE_F400:
+            min = mVec3_c(-400.f, -0.f, -50.f);
+            max = mVec3_c(400.f, 600.f, 250.f);
+            break;
+        case TYPE_SHUTTER:
+            min = mVec3_c(-250.f, -0.f, -50.f);
+            max = mVec3_c(250.f, 400.f, 50.f);
+            break;
+        case TYPE_GODDOOR:
+            min = mVec3_c(-50.f, -0.f, -100.f);
+            max = mVec3_c(500.f, 500.f, 100.f);
+            break;
+    }
+    mBoundingBox.Set(min, max);
+
+    if (mSubtype == TYPE_GODDOOR) {
+        mPosition.copyFrom(mMdls[0].getResMdl().GetResNode(0).GetTranslate());
+    }
+    mWorldMtx.transS(mPosition);
+    mWorldMtx.ZXYrotM(mRotation);
+    mIsOpen = checkOpenFlag();
+
+    return SUCCEEDED;
+}
+
 void dAcODormitoryGate_c::initializeState_Wait() {}
 void dAcODormitoryGate_c::executeState_Wait() {}
 void dAcODormitoryGate_c::finalizeState_Wait() {}

src/REL/d/a/obj/d_a_obj_dungeon_ship.cpp

@@ -4,6 +4,7 @@
 #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/cc/d_cc_s.h"
 #include "d/flag/sceneflag_manager.h"
@@ -116,9 +117,7 @@ int dAcODungeonShip_c::create() {
         mIsDocked = true;
     }
 
-    if (!initAllocatorWork1Heap(0x40000, "dAcODungeonShip_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR_SIZE(dAcODungeonShip_c, 0x40000);
 
     mPathIdx = mParams & 0xFF;
     if (mPathIdx == 0xFF) {
@@ -190,9 +189,7 @@ int dAcODungeonShip_c::actorExecute() {
     mAnmMatClr.play();
     mMdl.calc(false);
     if (field_0x8D8) {
-        mEffects[0].holdEffect(
-            PARTICLE_RESOURCE_ID_MAPPING_682_, mPosition, &mRotation, nullptr, nullptr, nullptr
-        );
+        mEffects[0].holdEffect(PARTICLE_RESOURCE_ID_MAPPING_682_, mPosition, &mRotation, nullptr, nullptr, nullptr);
     }
 
     if (field_0x8D9) {

src/REL/d/a/obj/d_a_obj_flag.cpp

@@ -1,9 +1,219 @@
 #include "d/a/obj/d_a_obj_flag.h"
 
+#include "c/c_math.h"
+#include "common.h"
+#include "d/a/d_a_base.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/a/obj/d_a_obj_desert_ago.h"
+#include "d/col/cc/d_cc_d.h"
+#include "d/d_sc_game.h"
+#include "d/snd/d_snd_wzsound.h"
+#include "f/f_base.h"
+#include "f/f_manager.h"
+#include "f/f_profile_name.h"
+#include "m/m_mtx.h"
+#include "m/m_vec.h"
+#include "nw4r/g3d/res/g3d_resanmtexsrt.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+
 SPECIAL_ACTOR_PROFILE(OBJ_FLAG, dAcOFlag_c, fProfile::OBJ_FLAG, 0x14E, 0, 3);
 
 STATE_DEFINE(dAcOFlag_c, Wait);
 
+static dCcD_SrcCps sSrcCps = {
+    // TODO
+};
+
+bool dAcOFlag_c::createHeap() {
+    const char *arcName = getArcName();
+    const char *mdlName = getMdlName();
+    const char *anmName = getAnmTexSrtName();
+
+    mResFile = nw4r::g3d::ResFile(getOarcResFile(arcName));
+    nw4r::g3d::ResMdl resMdl = mResFile.GetResMdl(mdlName);
+    u32 bufferOption = 0x1003120;
+    if (anmName) {
+        bufferOption = 0x1003324;
+    }
+    if (!mMdl.create(resMdl, &mAllocator, bufferOption, 1, nullptr)) {
+        return false;
+    }
+
+    s32 type = getFromParams(0, 0xF);
+    if (anmName) {
+        nw4r::g3d::ResAnmTexSrt texSrt = mResFile.GetResAnmTexSrt(anmName);
+        if (!mAnmTexSrt.create(resMdl, texSrt, &mAllocator, nullptr, 1)) {
+            return false;
+        }
+        mMdl.setAnm(mAnmTexSrt);
+        if (type == 2) {
+            mAnmTexSrt.setFrame(0.f, 0);
+        } else if (type == 3) {
+            mAnmTexSrt.setFrame(1.f, 0);
+        }
+        mAnmTexSrt.setRate(0.f, 0);
+    }
+
+    mpJoints = new mVec3_c[mNumJoints];
+    if (!mpJoints) {
+        return false;
+    }
+
+    for (s32 i = 0; i < mNumJoints; ++i) {
+        mpJoints[i] = mVec3_c::Zero;
+    }
+
+    if (type == 1 || type == 2 || type == 3) {
+        mpJoints1 = new mVec3_c[15];
+        if (!mpJoints1) {
+            return false;
+        }
+        mpJoints2 = new mVec3_c[15];
+        if (!mpJoints2) {
+            return false;
+        }
+        mpJoints3 = new mVec3_c[15];
+        if (!mpJoints3) {
+            return false;
+        }
+        for (int i = 0; i < 15; ++i) {
+            mpJoints2[i] = mVec3_c::Zero;
+            mpJoints3[i] = mVec3_c::Zero;
+        }
+    }
+    mMdl.setCallback(&mCallback);
+    mMdl.enableCallbackOp(nw4r::g3d::ScnObj::EXECOP_CALC_MAT);
+    mMdl.enableCallbackTiming(nw4r::g3d::ScnObj::CALLBACK_TIMING_C);
+
+    return true;
+}
+
+int dAcOFlag_c::actorCreate() {
+    s32 type = getFromParams(0, 0xF);
+    if (isSail()) {
+        mNumJoints = 104;
+    } else {
+        mNumJoints = 21;
+    }
+
+    CREATE_ALLOCATOR_SIZE(dAcOFlag_c, 0x4000);
+
+    mStts.SetRank(0);
+    mCps.Set(sSrcCps);
+    mCps.SetR(sSrcCps.mCpsInf.mRadius * mScale.x);
+    mCps.SetStts(mStts);
+
+    mAcceleration = -9.8f;
+    mMaxSpeed = 0.f;
+    mStateMgr.changeState(StateID_Wait);
+
+    if (type == 1) {
+        mBoundingBox.Set(mVec3_c(-800.f, -100.f, -800.f), mVec3_c(800.f, 410.f, 800.f));
+    } else if (isPurpleFlag()) {
+        mBoundingBox.Set(mVec3_c(-250.f, -500.f, -250.f), mVec3_c(250.f, 500.f, 250.f));
+    }
+
+    mWorldMtx.transS(mPosition);
+    mWorldMtx.YrotM(mRotation.y);
+    field_0x530 = cM::rndInt(100);
+
+    switch (type) {
+        case 1: {
+            field_0x548 = 0;
+            if (mScale.x < 0.5f) {
+                mCullingDistance += 6000.f;
+            } else {
+                mCullingDistance += 3000.f;
+            }
+        } break;
+        case 2:
+        case 3: {
+            field_0x548 = 1;
+        } break;
+        case 4: {
+            if (mScale.x < 1.f) {
+                mCullingDistance *= 100.f;
+            }
+            mMdl.setPriorityDraw(0x1C, -1);
+        } break;
+        case 5: {
+            mCullingDistance *= 5.f;
+            mMdl.setPriorityDraw(0x1C, -1);
+        }
+    }
+    return SUCCEEDED;
+}
+
+int dAcOFlag_c::actorPostCreate() {
+    if (isSail()) {
+        if (dScGame_c::isCurrentStage("F301_6")) {
+            if ((s32)getFromParams(0, 0xF) == 4) {
+                dAcODesertAgo_c *pDesertAgo =
+                    static_cast<dAcODesertAgo_c *>(fManager_c::searchBaseByProfName(fProfile::OBJ_DESERT_AGO));
+                if (!pDesertAgo) {
+                    return FAILED;
+                }
+                mDesertAgoRef.link(pDesertAgo);
+                unsetActorProperty(AC_PROP_0x1 | AC_PROP_0x2);
+                field_0x530 = 8995;
+                field_0x564 = 249;
+                field_0x561 = 0;
+            } else {
+                f32 s = 1.f / mScale.x;
+                mBoundingBox.Set(
+                    mVec3_c(s * -4000.f, s * -2000.f, s * -6000.f), mVec3_c(s * 4000.f, s * 1500.f, s * 4000.f)
+                );
+            }
+            setActorProperty(AC_PROP_0x4);
+        } else {
+            f32 s = 1.f / mScale.x;
+            mBoundingBox.Set(
+                mVec3_c(s * -3000.f, s * -4000.f, s * -3000.f), mVec3_c(s * 3000.f, s * 2000.f, s * 3000.f)
+            );
+        }
+        field_0x558 = 0;
+        field_0x55C = 91;
+    }
+    createPlacement();
+    return SUCCEEDED;
+}
+
+int dAcOFlag_c::doDelete() {
+    return SUCCEEDED;
+}
+
+int dAcOFlag_c::actorExecute() {
+    field_0x530++;
+    mStateMgr.executeState();
+
+    if (isSail()) {
+        setCollider();
+    }
+
+    if ((s32)getFromParams(0, 0xF) == 4) {
+        mVec3_c v = mVec3_c::Zero;
+        if (mDesertAgoRef.isLinked()) {
+            // TODO: Fix for field at 0x86C. Probably translation from matrix
+            mMtx_c m = mDesertAgoRef.get()->mWorldMtx;
+            m.getTranslation(v);
+        } else {
+            v = mPosition;
+        }
+        mWorldMtx.transS(v);
+    } else {
+        mWorldMtx.transS(mPosition);
+    }
+    mMdl.setLocalMtx(mWorldMtx);
+    holdSound(SE_Flag_FLUTTER_LV);
+    return SUCCEEDED;
+}
+
+int dAcOFlag_c::draw() {
+    drawModelType1(&mMdl);
+    return SUCCEEDED;
+}
+
 void dAcOFlag_c::initializeState_Wait() {}
 void dAcOFlag_c::executeState_Wait() {}
 void dAcOFlag_c::finalizeState_Wait() {}

src/REL/d/a/obj/d_a_obj_flying_clawshot_target.cpp

@@ -46,7 +46,7 @@ const cCcD_SrcGObj dAcOFlyingClawshotTarget_c::sColSrc = {
 // clang-format on
 
 int dAcOFlyingClawshotTarget_c::actorCreate() {
-    initAllocatorWork1Heap(-1, "dAcOFlyingClawshotTarget_c::m_allocator", 0x20);
+    CREATE_ALLOCATOR_UNCHECKED(dAcOFlyingClawshotTarget_c);
 
     mMdl.setPriorityDraw(0x7F, 0x7F);
     mWorldMtx.transS(mVec3_c::Zero);

src/REL/d/a/obj/d_a_obj_pumpkin_leaf.cpp

@@ -1,5 +1,6 @@
 #include "d/a/obj/d_a_obj_pumpkin_leaf.h"
 
+#include "d/a/obj/d_a_obj_base.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
 #include "s/s_Math.h"
 
@@ -15,9 +16,7 @@ bool dAcOPumpkinLeaf_c::createHeap() {
 }
 
 int dAcOPumpkinLeaf_c::create() {
-    if (!initAllocatorWork1Heap(0x1000, "dAcOPumpkinLeaf_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR_SIZE(dAcOPumpkinLeaf_c, 0x1000);
 
     mAcceleration = -1.0f;
     mMaxSpeed = -40.0f;

src/REL/d/a/obj/d_a_obj_spike.cpp

@@ -1,5 +1,6 @@
 #include "d/a/obj/d_a_obj_spike.h"
 
+#include "d/a/obj/d_a_obj_base.h"
 #include "d/col/cc/d_cc_s.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_SPIKE, dAcOspike_c, fProfile::OBJ_SPIKE, 0x1D9, 0, 2);
@@ -25,9 +26,7 @@ bool dAcOspike_c::createHeap() {
 }
 
 int dAcOspike_c::create() {
-    if (!initAllocatorWork1Heap(-1, "dAcOspike_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR(dAcOspike_c);
 
     mStts.SetDefaultRank();
     mCollision.Set(sCcSrc);

src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp

@@ -1,6 +1,7 @@
 #include "d/a/obj/d_a_obj_toD3_stone_figure.h"
 
 #include "d/a/d_a_item.h"
+#include "d/a/obj/d_a_obj_base.h"
 #include "d/col/cc/d_cc_s.h"
 #include "d/d_sc_game.h"
 #include "d/flag/storyflag_manager.h"
@@ -39,9 +40,8 @@ int dAcOtoD3StoneFigure_c::create() {
     mIsSkyKeepAlreadyOpen = isStoneOfTrialsPlaced();
     mExitId = mParams & 0xFF;
     updateMatrix();
-    if (!initAllocatorWork1Heap(-1, "dAcOtoD3StoneFigure_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+
+    CREATE_ALLOCATOR(dAcOtoD3StoneFigure_c);
 
     mMdl.setLocalMtx(mWorldMtx);
     mStts.SetDefaultRank();

src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp

@@ -34,9 +34,7 @@ bool dAcOTowerGearD101_c::createHeap() {
 }
 
 int dAcOTowerGearD101_c::actorCreate() {
-    if (!initAllocatorWork1Heap(0x1000, "dAcOTowerGearD101_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR_SIZE(dAcOTowerGearD101_c, 0x1000);
     nw4r::g3d::ResMdl mdl = mMdl.getResMdl();
     mMdlCallback.init(mdl.GetResNode("model0").GetID());
     mMdl.setCallback(&mMdlCallback);
@@ -128,7 +126,5 @@ void dAcOTowerGearD101_c::initTransform() {
 }
 
 void dAcOTowerGearD101_c::playVisualEffect() {
-    mEffects.holdEffect(
-        PARTICLE_RESOURCE_ID_MAPPING_572_, field_0x3F4, &mRotation, nullptr, nullptr, nullptr
-    );
+    mEffects.holdEffect(PARTICLE_RESOURCE_ID_MAPPING_572_, field_0x3F4, &mRotation, nullptr, nullptr, nullptr);
 }

src/REL/d/a/obj/d_a_obj_triforce.cpp

@@ -1,6 +1,7 @@
 #include "d/a/obj/d_a_obj_triforce.h"
 
 #include "c/c_math.h"
+#include "d/a/obj/d_a_obj_base.h"
 #include "d/col/cc/d_cc_s.h"
 #include "m/m_vec.h"
 #include "nw4r/g3d/res/g3d_resfile.h"
@@ -32,9 +33,7 @@ bool dAcOtriforce_c::createHeap() {
 }
 
 int dAcOtriforce_c::create() {
-    if (!initAllocatorWork1Heap(-1, "dAcOtriforce_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR(dAcOtriforce_c);
 
     mStts.SetDefaultRank();
     mCollision.Set(sCcSrc);

src/REL/d/a/obj/d_a_obj_underground_switch.cpp

@@ -40,9 +40,7 @@ int dAcOUgSwitch_c::create() {
     mActiveSceneFlag = mParams & 0xFF;
     field_0x3BD = (mParams >> 8) & 0xFF;
     setVariant((mParams >> 16) & 0xF);
-    if (!initAllocatorWork1Heap(0x1000, "dAcOUgSwitch_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR_SIZE(dAcOUgSwitch_c, 0x1000);
 
     mOnEventTimer = 0;
     updateMatrix();

src/REL/d/t/d_t_reaction.cpp

@@ -4,6 +4,7 @@
 #include "c/c_math.h"
 #include "d/a/d_a_item.h"
 #include "d/a/d_a_player.h"
+#include "d/a/obj/d_a_obj_base.h"
 #include "d/col/c/c_cc_d.h"
 #include "d/col/cc/d_cc_s.h"
 #include "d/d_pouch.h"
@@ -33,9 +34,7 @@ bool dTgReaction_c::createHeap() {
 
 int dTgReaction_c::create() {
     // Note the double _c here
-    if (!initAllocatorWork1Heap(0x1000, "dTgReaction_c_c::m_allocator", 0x20)) {
-        return FAILED;
-    }
+    CREATE_ALLOCATOR_SIZE(dTgReaction_c_c, 0x1000);
 
     if (getReactType() != REACT_UNDERWATER) {
         if (getSceneFlag() >= 0xFF) {