d_a_e_sm (chu chu) start (#117)

* d_a_e_sm (chu chu) start

* progress, includes LightParam addition in BlurPaletteMgr

* oops - TBox Progress I guess

* dAcEsm_c::actorExecute and Particle Resource data moved

* step in symbols map

* Update blur_and_palette_manager.h

* m_angle cleanup pass

* Last explicit_zero_data Fixes #69

* add mQuat_c ctor

31 files changed, 1552 insertions, 217 deletions

diff --git a/src/REL/d/a/e/d_a_e_hb_leaf.cpp b/src/REL/d/a/e/d_a_e_hb_leaf.cpp
index a5fa959f..c8ac6391 100644
--- a/src/REL/d/a/e/d_a_e_hb_leaf.cpp
+++ b/src/REL/d/a/e/d_a_e_hb_leaf.cpp
@@ -33,7 +33,7 @@ int dAcEhb_leaf_c::create() {
         case 2:  mType = 2; break;
         case 3:
         case 4:
-        case 5:  rotation.z = -0x8000; break;
+        case 5:  rotation.z.set(-0x8000); break;
         default: break;
     }
 
diff --git a/src/REL/d/a/e/d_a_e_sm.cpp b/src/REL/d/a/e/d_a_e_sm.cpp
index ebfb4beb..851066b2 100644
--- a/src/REL/d/a/e/d_a_e_sm.cpp
+++ b/src/REL/d/a/e/d_a_e_sm.cpp
@@ -1,7 +1,84 @@
 #include "d/a/e/d_a_e_sm.h"
 
+#include "c/c_lib.h"
+#include "c/c_math.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_base.h"
+#include "d/a/obj/d_a_obj_bomb.h"
+#include "d/col/bg/d_bg_pc.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_s_gnd_chk.h"
+#include "d/col/bg/d_bg_s_lin_chk.h"
+#include "d/col/c/c_cc_d.h"
+#include "d/col/cc/d_cc_d.h"
+#include "d/col/cc/d_cc_s.h"
+#include "d/d_camera.h"
+#include "d/d_sc_game.h"
+#include "d/flag/sceneflag_manager.h"
+#include "d/flag/storyflag_manager.h"
+#include "f/f_base.h"
+#include "f/f_profile_name.h"
+#include "m/m3d/m_fanm.h"
+#include "m/m_angle.h"
+#include "m/m_color.h"
+#include "m/m_mtx.h"
+#include "m/m_quat.h"
+#include "m/m_vec.h"
+#include "nw4r/g3d/res/g3d_resanmclr.h"
+#include "nw4r/g3d/res/g3d_resanmtexpat.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "nw4r/g3d/res/g3d_resnode.h"
+#include "rvl/MTX/mtx.h"
+#include "rvl/MTX/mtxvec.h"
+#include "s/s_Math.h"
+#include "toBeSorted/blur_and_palette_manager.h"
+#include "toBeSorted/d_emitter.h"
+#include "toBeSorted/small_sound_mgr.h"
+#include "toBeSorted/time_area_mgr.h"
+
 SPECIAL_ACTOR_PROFILE(E_SM, dAcEsm_c, fProfile::E_SM, 0xEB, 0, 4098);
 
+static dCcD_SrcSph sSphSrc = {
+    /* mObjInf */
+    {/* mObjAt */ {AT_TYPE_DAMAGE, 0xD, {0, 0, 0}, 0, 0, 0, 0, 0, 0},
+     /* mObjTg */ {~(AT_TYPE_BUGNET | AT_TYPE_BEETLE | AT_TYPE_0x8000 | AT_TYPE_WIND), 0x3303, {0, 3, 0x40F}, 8, 0},
+     /* mObjCo */ {0xC5}},
+    /* mSphInf */
+    {50.f},
+};
+
+void dAcEsm_c::fn_187_5D0() {
+    if (mStateMgr.isState(StateID_Absorption)) {
+        fn_187_6C20(0);
+    }
+}
+
+bool dAcEsm_c::createHeap() {
+    void *rresData = getOarcResFile("Sm");
+    TRY_CREATE(mMdl.create3(*this, rresData, "sm", "awa", 0x123));
+
+    nw4r::g3d::ResFile rres(rresData);
+    nw4r::g3d::ResMdl mdl(rres.GetResMdl("sm"));
+    nw4r::g3d::ResAnmTexPat texPat(rres.GetResAnmTexPat("sm"));
+
+    TRY_CREATE(mAnmTexPat.create(mdl, texPat, &heap_allocator, nullptr, 1));
+    mMdl.getModel().setAnm(mAnmTexPat);
+
+    nw4r::g3d::ResAnmClr anmClr = rres.GetResAnmClr("attack");
+    if (mType == SM_YELLOW) {
+        anmClr = rres.GetResAnmClr("Spark");
+    }
+    TRY_CREATE(mAnmMatClr.create(mdl, anmClr, &heap_allocator, nullptr, 1));
+
+    mMdl.getModel().setAnm(mAnmMatClr);
+    mScnCallback.attach(mMdl.getModel());
+
+    return true;
+}
+
 STATE_DEFINE(dAcEsm_c, BaseMother);
 STATE_DEFINE(dAcEsm_c, Wait);
 STATE_DEFINE(dAcEsm_c, Walk);
@@ -13,33 +90,1368 @@ STATE_DEFINE(dAcEsm_c, Absorption);
 STATE_DEFINE(dAcEsm_c, Fusion);
 STATE_DEFINE(dAcEsm_c, Dead);
 
+bool dAcEsm_c::sSomeArrayInit = false;
+bool dAcEsm_c::sSomeArray[9];
+
+int dAcEsm_c::actorCreate() {
+    // Check for Batreaux being human and on Skyloft/Waterfall cave
+    if (StoryflagManager::sInstance->getCounterOrFlag(360) &&
+        (dScGame_c::isCurrentStage("F000") || dScGame_c::isCurrentStage("D000"))) {
+        return FAILED;
+    }
+
+    mType = GetType();
+    field_0xBBF = GetParam_s4_0xF();
+    shift8_0xFF = GetParam_s8_0xFF();
+
+    field_0xB74 = GetParam_s16_0xFF();
+    field_0xB78 = rotation.z;
+    if (field_0xB74 == 0.f) {
+        field_0xB74 = 400.f;
+    }
+    field_0xBC6 = GetParam_s24_0x7();
+
+    mOrigRotZ = rotation.z;
+
+    if (field_0xB78 <= 0.f) {
+        field_0xB78 = 0.f;
+    } else {
+        field_0xB78 = 200.f * field_0xB78;
+    }
+
+    mStartingPos.set(position.x, position.y, position.z);
+    mHomePos1.set(position.x, position.y, position.z);
+    mEffPos.set(position.x, position.y, position.z);
+
+    CREATE_ALLOCATOR(dAcEsm_c);
+
+    rotation.z = angle.x = 0;
+
+    mBombRef.unlink();
+
+    setActorProperty(0x1);
+    // Ignore these bounding box sets. `fixBoundBox` completely overwrites them with the scale
+    switch ((int)mScale.x) {
+        default:
+        case SM_SMALL: {
+            boundingBox.Set(mVec3_c(-250.f, -250.f, -250.f), mVec3_c(250.f, 375.f, 250.f));
+            mScale.set(0.8f, 0.8f, 0.8f);
+        } break;
+        case SM_LARGE: {
+            boundingBox.Set(mVec3_c(-500.f, -500.f, -500.f), mVec3_c(500.f, 750.f, 500.f));
+            mScale.set(0.4f, 0.4f, 0.4f);
+        } break;
+        case SM_MASSIVE: {
+            boundingBox.Set(mVec3_c(-800.f, -800.f, -800.f), mVec3_c(800.f, 1200.f, 800.f));
+            mScale.set(0.25f, 0.25f, 0.25f);
+        } break;
+        case SM_TINY: {
+            boundingBox.Set(mVec3_c(-150.f, -150.f, -150.f), mVec3_c(150.f, 225.f, 150.f));
+            mScale.set(1.2f, 1.2f, 1.2f);
+        } break;
+    }
+
+    updateBoundingBox();
+
+    mScale.CopyTo(mScaleTarget);
+    mScale.CopyTo(mScaleCopy2);
+
+    mObjAcch.Set(this, 1, &mAcchCir);
+    mAcchCir.SetWall(mScaleTarget.y * 100.f, mScaleTarget.x * 100.f);
+    mStts.SetRank(10);
+    mObjAcch.SetGndThinCellingOff();
+    mObjAcch.mField_0x390 = 1;
+
+    forwardMaxSpeed = -40.f;
+
+    mSph.Set(sSphSrc);
+
+    mSph.SetStts(mStts);
+
+    position.CopyTo(poscopy2);
+    position.CopyTo(mPosCopy1);
+    position.CopyTo(poscopy3);
+    poscopy3.y += 50.f;
+
+    mRotCopy.set(rotation);
+
+    field_0xB98 = 0;
+    field_0xB58 = 1.f;
+    field_0xB90 = -1;
+
+    // This is really weird...
+    if (!sSomeArrayInit) {
+        sSomeArrayInit = true;
+        bool *parr = getArray();
+        for (int i = 0; i < 8; i++) {
+            *parr++ = false;
+        }
+        *parr++ = false;
+    }
+
+    static todoStruct00::InternalData data0 = {0, 100.f, nullptr};
+    static todoStruct00::InternalData data1 = {1, 130.f, &data0};
+    field_0x9f8.Set(this, &data1, &mMdl.getModel(), 1);
+
+    mLightInfo.SetColor(mColor(0xCC, 0xFF, 0xFF, 0xFF));
+    mLightInfo.SetScale(0.f);
+
+    BlurAndPaletteManager::GetPInstance()->fn_800225F0(&mLightInfo);
+    if (field_0xBBF == 1) {
+        rotation.x = 0x8000;
+        field_0xBCC = 1;
+    }
+
+    mRotUnk.clear();
+
+    mEffArr[0].init(this);
+    mEffArr[1].init(this);
+
+    if (field_0xBBF == 1) {
+        mStateMgr.changeState(StateID_Wait);
+    } else {
+        mStateMgr.changeState(StateID_Walk);
+    }
+
+    mHealth = 100;
+
+    if (field_0xBBF != 1) {
+        forwardAccel = -3.f;
+    }
+    calcVelocity();
+    position += velocity;
+    position += mStts.GetCcMove();
+
+    mObjAcch.CrrPos(*dBgS::GetInstance());
+    fn_187_4CC0();
+
+    f32 anim_frame;
+    switch (mType) {
+        // SM_RED
+        default: {
+            targetFiTextId = 59;
+            anim_frame = 0.f;
+            mSph.SetAtModifier(AT_MOD_FIRE);
+            mType = SM_RED;
+        } break;
+        case SM_GREEN_ALT:
+        case SM_GREEN:     {
+            targetFiTextId = 62;
+            anim_frame = 3.f;
+            mType = SM_GREEN;
+        } break;
+        case SM_YELLOW_ALT:
+        case SM_YELLOW:     {
+            targetFiTextId = 61;
+            anim_frame = 2.f;
+            mSph.SetAtModifier(AT_MOD_ELECTRIC);
+            mType = SM_YELLOW;
+        } break;
+
+        case SM_BLUE: {
+            targetFiTextId = 60;
+            anim_frame = 1.f;
+        } break;
+    }
+
+    if (field_0xBBF != 6) {
+        mSplashFx.init(this, 100.f, mScaleTarget.x * 2.f, 0.f);
+        mSplashFx.setIsSmall(1);
+    }
+
+    mAnmTexPat.setFrame(anim_frame, 0);
+
+    setInteractionFlags(0x40);
+
+    fn_187_44C0();
+
+    mSph.SetAtDamage(4);
+
+    return SUCCEEDED;
+}
+
+int dAcEsm_c::actorPostCreate() {
+    switch ((u32)field_0xBC6) {
+        case 1: {
+            mTimeArea.setField0x08(0);
+            if (dTimeAreaMgr_c::GetInstance()->fn_800B9B60(getRoomId(), GetPosition())) {
+                mTimeArea.setField0x00(1.f);
+                field_0xB8C = 1.f;
+                fn_80030700();
+            } else {
+                mTimeArea.setField0x00(0.f);
+                field_0xB8C = 0.f;
+                fn_800306d0();
+            }
+        } break;
+        case 2: {
+            mTimeArea.setField0x08(1);
+            if (dTimeAreaMgr_c::GetInstance()->fn_800B9B60(getRoomId(), GetPosition())) {
+                field_0xB8C = 0.f;
+                mTimeArea.setField0x00(0.f);
+                fn_800306d0();
+            } else {
+                field_0xB8C = 1.f;
+                mTimeArea.setField0x00(1.f);
+                fn_80030700();
+            }
+        } break;
+    }
+
+    if (field_0xBBF == 2 || field_0xBBF == 3) {
+        mScale.set(0.1f, 0.1f, 0.1f);
+        field_0xBBF = 3;
+    }
+
+    if (field_0xBBF == 1 || field_0xBBF == 3) {
+        clearActorProperty(1);
+        fn_800306d0();
+        FUN_8002d860(0);
+    }
+
+    return SUCCEEDED;
+}
+
+int dAcEsm_c::doDelete() {
+    BlurAndPaletteManager::GetPInstance()->fn_800226E0(&mLightInfo);
+    return SUCCEEDED;
+}
+
+int dAcEsm_c::actorExecute() {
+    mLightInfo.SetScale(0.f);
+    if (shift8_0xFF != 0xFF && !SceneflagManager::sInstance->checkBoolFlag(roomid, shift8_0xFF)) {
+        return SUCCEEDED;
+    }
+
+    if (dAcPy_c::GetLink()->checkActionFlagsCont(0x400000)) {
+        return SUCCEEDED;
+    }
+
+    dAcBomb_c *bomb = mBombRef.get();
+    if (mBombRef.isLinked() && bomb) {
+        mVec3_c target;
+        GetPosition().CopyTo(target);
+        if (!checkSize(SM_MASSIVE) && !checkSize(SM_LARGE)) {
+            target.y += mScaleTarget.y * 60.f;
+        }
+
+        cLib::addCalcPos2(&bomb->GetPosition(), target, 0.8f, 20.f + GetSpeed() * 1.5f);
+
+        field_0xB6C = 0.5f;
+
+        if (field_0xBC5 != 2) {
+            mMdl.setAnm("attack", m3d::PLAY_MODE_4, 4.f);
+            field_0xBC5 = 2;
+        }
+
+        if (0 == sLib::calcTimer(&mTimer_0xBAE)) {
+            fn_187_4B50();
+        }
+    }
+
+    if (!mStateMgr.isState(dAcEsm_c::StateID_Dead)) {
+        if (mHealth != 0 && mScaleTarget.x > 0.25f) {
+            mHealth = 100;
+        }
+
+        if (field_0xBC6 == 1 || field_0xBC6 == 2) {
+            int timeCheck = 0;
+            if (mHealth != 0) {
+                if (field_0xBBF == 3 || field_0xBBF == 1 || mStateMgr.isState(StateID_Absorption) ||
+                    mObjAcch.ChkGndHit()) {
+                    timeCheck = mTimeArea.check(getRoomId(), GetPosition(), 0, 10.f, 0.2f);
+                }
+            }
+
+            if (timeCheck != 0) {
+                if (field_0xBBF == 3) {
+                    if (checkInteractionFlags(4)) {
+                        fn_800306d0();
+                    }
+                    return SUCCEEDED;
+                }
+
+                u16 effectID;
+                mVec3_c effScale(1.f, 1.f, 1.f);
+                if (checkSize(SM_TINY)) {
+                    effScale.set(1.5f, 1.5f, 1.5f);
+                    effectID = PARTICLE_RESOURCE_ID_MAPPING_463_;
+                } else if (checkSize(SM_SMALL)) {
+                    effectID = PARTICLE_RESOURCE_ID_MAPPING_463_;
+                } else if (checkSize(SM_LARGE)) {
+                    effectID = PARTICLE_RESOURCE_ID_MAPPING_465_;
+                } else {
+                    effectID = PARTICLE_RESOURCE_ID_MAPPING_464_;
+                }
+
+                dJEffManager_c::spawnEffect(effectID, mEffPos, nullptr, &effScale, nullptr, nullptr, 0, 0);
+
+                if (timeCheck > 0) {
+                    playSound(SE_TIMESLIP_TIMESLIP);
+                    fn_800306d0();
+                } else {
+                    playSound(SE_TIMESLIP_TIMESLIP_REV);
+                    fn_80030700();
+                }
+            }
+
+            if (field_0xBBF == 3 && mTimeArea.isNearZero()) {
+                if (checkInteractionFlags(4)) {
+                    fn_800306d0();
+                }
+                return SUCCEEDED;
+            }
+
+            if (field_0xB8C < 1.f) {
+                if (mStateMgr.isState(StateID_Absorption) || mHealth == 0) {
+                    fn_187_5730();
+                    fillUpperParams2Byte();
+                    deleteRequest();
+                }
+                forwardSpeed = 0.f;
+
+                // TODO: Maybe Inline - Common Pattern. Check GetCcMove
+                calcVelocity();
+                position += velocity;
+                position += mStts.GetCcMove();
+
+                mObjAcch.CrrPos(*dBgS::GetInstance());
+                fn_187_44C0();
+                return SUCCEEDED;
+            }
+        }
+
+        if (field_0xBBF == 3 || field_0xBBF == 1) {
+            if (isWithinPlayerRadius(field_0xB74) || field_0xB94 != 0) {
+                if (field_0xBBF == 3) {
+                    if (!(field_0xBC6 == 1 || field_0xBC6 == 2) || !mTimeArea.isNearZero()) {
+                        mTimer_0xBC4 = 6;
+                        mStateMgr.changeState(StateID_BirthJump);
+                        field_0xBB8 = 0;
+                        fn_80030700();
+                        field_0xBC2 = 2;
+                        fn_187_5390();
+                    }
+                } else {
+                    mStateMgr.changeState(StateID_BirthJump);
+                    field_0xBB8 = 0;
+                }
+                field_0xBBF = 0;
+                FUN_8002d860(2);
+                fn_80030700();
+                rotation.y = angle.y = getXZAngleToPlayer();
+            }
+            if (field_0xBBF == 3) {
+                return SUCCEEDED;
+            }
+        }
+    }
+
+    mStateMgr.executeState();
+
+    if (mStateMgr.isState(StateID_Absorption)) {
+        mSph.SetTgType(~(AT_TYPE_COMMON0 | AT_TYPE_0x800000 | AT_TYPE_SWORD));
+    } else {
+        mSph.SetTgType(~AT_TYPE_COMMON0);
+
+        if (mType == SM_RED) {
+            mAnmMatClr.setFrame(0.f, 0);
+        }
+        if (mType == SM_YELLOW && !mSph.ChkTgElectric()) {
+            mAnmMatClr.setFrame(0.f, 0);
+        }
+    }
+
+    if (0 == sLib::calcTimer(&mTimer_0xBC4)) {
+        calcVelocity();
+        position += velocity;
+        position += mStts.GetCcMove();
+    }
+
+    if (!mStateMgr.isState(StateID_Absorption)) {
+        mObjAcch.CrrPos(*dBgS::GetInstance());
+    }
+
+    if (field_0xBBF != 6) {
+        mSplashFx.execute(mObjAcch.GetWtrGroundH(), mObjAcch.GetGroundH());
+    }
+
+    if (!mStateMgr.isState(StateID_Dead)) {
+        if (field_0xBBF != 6 && dBgS_WtrChk::CheckPos(&GetPosition(), true, 500.0f, -500.0f) &&
+            std::abs(mObjAcch.GetGroundH() - dBgS_WtrChk::GetWaterHeight()) > 200.0f &&
+            (GetPosition().y < dBgS_WtrChk::GetWaterHeight() - 100.0f)) {
+            mHealth = 0;
+            fn_187_4540(2);
+        }
+
+        if (mObjAcch.ChkGndHit() && fn_187_4C50() && mHealth != 0) {
+            mHealth = 0;
+            fn_187_4540(2);
+        }
+    }
+
+    if (mHealth != 0) {
+        fn_187_3F60();
+        mAcchCir.SetWall(mScaleTarget.y * 100.f, mScaleTarget.x * 120.f);
+    }
+
+    fn_187_4CC0();
+
+    if (mHealth == 0 || mStateMgr.isState(StateID_Dead)) {
+        return SUCCEEDED;
+    }
+
+    if (mType == SM_YELLOW && mSph.ChkTgElectric()) {
+        fn_187_5940();
+    }
+
+    mHitPos.set(0.f, 0.f, 0.f);
+
+    if (0 == sLib::calcTimer(&mDamageTimer)) {
+        field_0xB94 = fn_8002fde0(mSph, nullptr);
+        if (field_0xB94 != 0) {
+            if (mSph.ChkTgHit()) {
+                if (field_0xB94 == 7) {
+                    field_0xB6C = 0.5f;
+                    forwardSpeed = 0.f;
+                } else {
+                    int val = 0; // IDK what this would have been
+                    field_0xB6C = 1.5f + 0.1f * val;
+                    field_0xB68 = -0.5f + 0.01f * val;
+                }
+            }
+        }
+
+        if (!(field_0xB94 >= 6 && field_0xB94 <= 10 || field_0xB94 == 0)) {
+            field_0xB98 = 0;
+
+            if (!fn_187_4B50() && mSph.ChkTgHit()) {
+                int hitType = mSph.GetTgAtHitType();
+                // const cast required... Maybe the const/non-const funcs are flipped?
+                const mVec3_c &hitPos = const_cast<const dCcD_Sph *>(&mSph)->GetTgHitPos();
+                hitPos.CopyTo(mHitPos);
+
+                switch (hitType) {
+                    case AT_TYPE_SWORD:
+                        if (mSph.ChkTgElectric()) {
+                            break;
+                        }
+                    case AT_TYPE_0x800000:
+                        field_0xB98 = fn_187_52A0();
+                        dJEffManager_c::spawnHitMarkEffect(6, mSph, nullptr, true);
+                        if (field_0xB98 != 7) {
+                            fn_187_61B0(0);
+                            fn_187_4540(field_0xB94);
+                        }
+                        break;
+                    default: {
+                        dAcObjBase_c *tgActor = mSph.GetTgActor();
+                        if (tgActor->profile_name == fProfile::OBJ_FIRE_PILLAR) {
+                            mHealth = 0;
+                            fn_187_4540(2);
+                        } else {
+                            mHealth = 100;
+                            playSound(SE_ESm_NO_DMG);
+                            fn_187_61B0(7);
+                        }
+
+                    } break;
+                    case AT_TYPE_BOMB:
+                    case AT_TYPE_BUBBLE:
+                    case 0:              {
+                        if (mStateMgr.isState(StateID_Absorption)) {
+                            fn_187_5730();
+                        }
+                        mHealth = 0;
+                        fn_187_4540(2);
+
+                    } break;
+                }
+            }
+        }
+
+        if (field_0xB94 == 7 && field_0xB80 < 1.f) {
+            field_0xB80 = 4.f;
+        }
+    }
+
+    if (mHealth != 0 && field_0xBC8 == 0 && field_0xBA0 == 0 && field_0xB90 < 0) {
+        // Check to make sure the chu is slow enough/or on the ground
+        if ((!mStateMgr.isState(StateID_BirthJump) || mObjAcch.ChkGndHit() || velocity.y <= -6.f) && field_0xBB6 == 0) {
+            // Check to make sure chu isnt in a "death"-like state.
+            if (!(mStateMgr.isState(StateID_Absorption) || mStateMgr.isState(StateID_Dead) ||
+                  mStateMgr.isState(StateID_Fusion))) {
+                // CHECK FOR FUSION - Another ESm
+                if (mSph.ChkCoHit() && mSph.GetCoActor()->profile_name == fProfile::E_SM) {
+                    // The other chu to interact with
+                    dAcEsm_c *pOther = static_cast<dAcEsm_c *>(mSph.GetCoActor());
+
+                    // Some checks to make sure the other chu can be interacted with
+                    if (!fn_187_4B50() && pOther->field_0xBC8 == 0 && pOther->mHealth != 0 &&
+                        pOther->field_0xBA0 == 0 && pOther->field_0xB90 < 0 && pOther->field_0xBB6 == 0) {
+                        if (!pOther->mStateMgr.isState(StateID_BirthJump) || pOther->mObjAcch.ChkGndHit() ||
+                            pOther->velocity.y <= -6.f) {
+                            // Check for non-fusion/absorption status and if the other Chu is smaller than [this] chu
+                            if (!(pOther->mStateMgr.isState(StateID_Absorption) ||
+                                  pOther->mStateMgr.isState(StateID_Fusion)) &&
+                                mScaleTarget.x >= pOther->mScaleTarget.x) {
+                                // Merging of properties
+                                mScaleTarget.CopyTo(mScaleCopy2);
+                                mScaleCopy2 += pOther->mScaleTarget;
+
+                                GetPosition().CopyTo(mPosCopy1);
+                                GetPosition().CopyTo(pOther->mPosCopy1);
+
+                                if (mScaleCopy2.x > 1.2f) {
+                                    mScaleCopy2.set(1.2f, 1.2f, 1.2f);
+                                }
+
+                                pOther->mScaleCopy2.set(0.01f, 0.01f, 0.01f);
+
+                                pOther->field_0xBC8 = 1;
+                                pOther->mDamageTimer = 8;
+                                pOther->mStateMgr.changeState(StateID_Fusion);
+                                playSound(SE_ESm_UNITE);
+                                mStateMgr.changeState(StateID_Fusion);
+                            }
+                        }
+                    }
+                }
+                // CHECK FOR BOMB REFERENCE
+                if (!mBombRef.get()) {
+                    f32 lookRadius = 200.f;
+                    lookRadius *= mScaleTarget.x;
+                    if (lookRadius < 80.f) {
+                        lookRadius = 80.f;
+                    }
+
+                    dAcBomb_c *bomb = getBombWithinRadius(lookRadius);
+
+                    if (bomb != nullptr && std::abs(bomb->GetPosition().y - mHomePos1.y) < 0.7f * lookRadius) {
+                        if (bomb->mActorCarryInfo.tryAttachWithRef(bomb, this, &mBombRef, 1, false)) {
+                            mTimer_0xBAE = 160;
+                            playSound(SE_ESm_BRING_IN);
+                            clearActorProperty(1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (mSph.ChkTgElectric()) {
+        fn_187_4B50();
+    }
+    s8 var = 0;
+    f32 radius = 150.f + var;
+    nw4r::g3d::ResNode node = mMdl.getModel().getResMdl().GetResNode("sm");
+
+    mMtx_c nodeMtx;
+    mMdl.getModel().getNodeWorldMtx(node.GetID(), nodeMtx);
+    mVec3_c center(0.f, 0.f, 0.f);
+    center.y = 90.f;
+
+    MTXMultVec(nodeMtx, center, mHomePos1);
+
+    position.CopyTo(poscopy3);
+    position.CopyTo(poscopy2);
+    poscopy2.y += 130.f * mScaleTarget.y;
+    poscopy3.y += 260.f * mScaleTarget.y;
+
+    mSph.SetC(mHomePos1);
+    if (mSph.ChkTgElectric()) {
+        playSoundEffect1(SE_ESm_ELEC_LV);
+    }
+
+    radius *= mScaleTarget.x;
+    if (radius < 43.f) {
+        radius = 43.f;
+    }
+    mSph.SetR(radius);
+    dCcS::GetInstance()->Set(&mSph);
+
+    f32 speedTarget = forwardSpeed;
+    speedTarget -= field_0xB80;
+    if (speedTarget < 0.f) {
+        speedTarget = 0.f;
+    }
+    sLib::addCalcScaledDiff(&forwardSpeed, speedTarget, 0.3f, 1.f);
+    sLib::addCalcScaled(&field_0xB80, 0.3f, 1.f);
+
+    if (field_0xBCB == 0) {
+        playSoundEffect1(SE_ESm_MOVE);
+    } else {
+        playSoundEffect1(SE_ESm_MOVE_HI);
+    }
+
+    if (field_0xBC8 == 0 && !mStateMgr.isState(StateID_Absorption)) {
+        fn_80030c20(3, 700.f, 50.f, -200.f, 200.f);
+    }
+
+    if (field_0xBBF != 3 && mScaleTarget.z != mScale.z) {
+        cLib::addCalcPos2(&mScale, mScaleTarget, 0.3f, 0.3f);
+    }
+
+    return SUCCEEDED;
+}
+
+int dAcEsm_c::draw() {
+    if (fn_187_5AC0()) {
+        return SUCCEEDED;
+    }
+    if (dAcPy_c::GetLink()->checkActionFlagsCont(0x400000)) {
+        return SUCCEEDED;
+    }
+    if (mScale.squareMagXZ() < 0.0004f) {
+        return SUCCEEDED;
+    }
+    if (shift8_0xFF != 0xFF && !SceneflagManager::sInstance->checkBoolFlag(roomid, shift8_0xFF)) {
+        return SUCCEEDED;
+    }
+
+    if (field_0xBBF == 3) {
+        return SUCCEEDED;
+    }
+
+    drawModelType1(&mMdl.getModel());
+
+    if (mHealth == 0) {
+        return SUCCEEDED;
+    }
+
+    s8 var = 0;
+    mQuat_c q(mVec3_c(0.f, 50.f, 0.f), mScale.x * (var + 240.f));
+    drawShadow(mShadowCircle, nullptr, mWorldMtx, &q, -1, -1, -1, -1, -1, position.y - mObjAcch.GetGroundH());
+    return SUCCEEDED;
+}
+
 void dAcEsm_c::initializeState_BaseMother() {}
 void dAcEsm_c::executeState_BaseMother() {}
 void dAcEsm_c::finalizeState_BaseMother() {}
-void dAcEsm_c::initializeState_Wait() {}
-void dAcEsm_c::executeState_Wait() {}
+
+void dAcEsm_c::initializeState_Wait() {
+    Set_0xBBC(1);
+}
+void dAcEsm_c::executeState_Wait() {
+    field_0xBA6 += (s16)(1000.f + field_0xB70 / mScaleTarget.x);
+}
 void dAcEsm_c::finalizeState_Wait() {}
-void dAcEsm_c::initializeState_Walk() {}
-void dAcEsm_c::executeState_Walk() {}
+
+void dAcEsm_c::initializeState_Walk() {
+    if (field_0xBC5 != 2) {
+        mMdl.setAnm("awa", m3d::PLAY_MODE_4, 4.f);
+        field_0xBC5 = 0;
+        mMdl.setFrame(cM::rndF(mMdl.getAnm().getEndFrame() - 1.f));
+    }
+
+    mVec3_c endPos;
+    mStartingPos.CopyTo(mPosCopy1);
+    mStartingPos.CopyTo(endPos);
+
+    endPos.y += 10.f;
+    if (dBgS_ObjLinChk::LineCross(&mHomePos1, &endPos, nullptr)) {
+        mStartingPos.set(position.x, position.y, position.z);
+    }
+
+    if (mType == SM_YELLOW) {
+        field_0xBC1 = 60.f + cM::rndF(60.f);
+    } else {
+        field_0xBC1 = 30.f + cM::rndF(30.f);
+    }
+
+    field_0xBB8 = 0;
+    field_0xB98 = 0;
+    rotation.x = 0;
+
+    Set_0xBBC(2);
+    field_0xBAA = angle.y;
+    field_0xBA8 = 0;
+    field_0xBCB = 0;
+    forwardAccel = -3.f;
+}
+void dAcEsm_c::executeState_Walk() {
+    field_0xBA6 += (s16)(1000.f + field_0xB70 / mScaleTarget.x);
+    if (sLib::calcTimer(&field_0xBB6)) {
+        return;
+    }
+    if (fn_187_42C0()) {
+        return;
+    }
+    fn_187_5810();
+    mMdl.setRate(1.f);
+    field_0xBCB = 0;
+
+    if (field_0xB78 == 0.f) {
+    } else {
+    }
+}
 void dAcEsm_c::finalizeState_Walk() {}
-void dAcEsm_c::initializeState_BirthJump() {}
+
+void dAcEsm_c::initializeState_BirthJump() {
+    clearActorProperty(1);
+    field_0xBA6 = 0;
+    field_0xB54 = 0.1f;
+    field_0xB68 = 0.f;
+
+    forwardSpeed = 0.f;
+    field_0xBB8 = 3;
+    field_0xB90 = -1;
+
+    if (field_0xBCE == 0 && mTimer_0xBC4 == 0 && mType == SM_YELLOW) {
+        fn_187_4450();
+    }
+}
 void dAcEsm_c::executeState_BirthJump() {}
 void dAcEsm_c::finalizeState_BirthJump() {}
+
 void dAcEsm_c::initializeState_Shake() {}
 void dAcEsm_c::executeState_Shake() {}
 void dAcEsm_c::finalizeState_Shake() {}
+
 void dAcEsm_c::initializeState_Attack() {}
 void dAcEsm_c::executeState_Attack() {}
 void dAcEsm_c::finalizeState_Attack() {}
+
 void dAcEsm_c::initializeState_Electrical() {}
 void dAcEsm_c::executeState_Electrical() {}
 void dAcEsm_c::finalizeState_Electrical() {}
+
 void dAcEsm_c::initializeState_Absorption() {}
-void dAcEsm_c::executeState_Absorption() {}
+void dAcEsm_c::executeState_Absorption() {
+    mMdl.getModel().getResMdl().GetResNode("mouth_ue");
+}
 void dAcEsm_c::finalizeState_Absorption() {}
+
 void dAcEsm_c::initializeState_Fusion() {}
 void dAcEsm_c::executeState_Fusion() {}
 void dAcEsm_c::finalizeState_Fusion() {}
+
 void dAcEsm_c::initializeState_Dead() {}
 void dAcEsm_c::executeState_Dead() {}
 void dAcEsm_c::finalizeState_Dead() {}
+
+// . . .
+void dAcEsm_c::fn_187_3F60() {
+    f32 target = nw4r::math::SinIdx(field_0xBA4) * field_0xB6C;
+    field_0xBA4 += (s16)(3000.f / mScaleTarget.x);
+
+    sLib::addCalcScaledDiff(&field_0xB5C, field_0xB68, 0.3f, 1.f);
+
+    if (mHealth != 0) {
+        sLib::addCalcScaledDiff(&field_0xB58, 1.f + target, 0.1f, 3.f);
+    } else {
+        sLib::addCalcScaled(&field_0xB58, 0.1f, 3.f);
+    }
+
+    sLib::addCalcScaledDiff(&field_0xB50, 0.015f + field_0xB54, 0.5f, 0.5f);
+    sLib::addCalcScaled(&field_0xB70, 0.01f, 1000.0f);
+    sLib::addCalcScaled(&field_0xB6C, 0.1f, 0.1f);
+    sLib::addCalcScaled(&field_0xB54, 0.03f, 0.03f);
+}
+
+bool dAcEsm_c::fn_187_4090() {
+    mVec3_c pos(position.x, position.y + 20.f, position.z);
+    if (velocity.y <= 0.f && dBgS_ObjGndChk::CheckPos(pos) && dBgS_ObjGndChk::GetGroundHeight() + 5.f > position.y) {
+        forwardSpeed = 0.f;
+        field_0xB6C = 1.5f;
+        if (field_0xB84) {
+            field_0xB6C = field_0xB84 * 0.1f + 0.7f;
+        }
+        field_0xB84 = 0.f;
+        field_0xBA4 = 0xC180;
+        field_0xB54 = 0.f;
+        field_0xB50 = 0.f;
+        field_0xB70 = 0.f;
+
+        playSound(SE_ESm_LAND);
+
+        if (field_0xBA0 == 0) {
+            if (fn_800301b0(position, rotation.y, true, 10.f) == 3 /* TODO: Enum?*/) {
+                int code = dBgS::GetInstance()->GetSpecialCode(dBgS_ObjGndChk::GetInstance());
+                if (code != POLY_ATTR_SAND_SHALLOW && code != POLY_ATTR_SAND_MED) {
+                    mHealth = 0;
+                    fn_187_4540(2);
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+    return false;
+}
+
+void dAcEsm_c::fn_187_4200() {
+    if (mType == SM_BLUE || field_0xBCC != 0 | field_0xBA0 != 0) {
+        return;
+    }
+    mVec3_c pos(position.x, position.y + 20.f, position.z);
+
+    if (dBgS_ObjGndChk::CheckPos(pos) && position.y - dBgS_ObjGndChk::GetGroundHeight() >= 700.f) {
+        if (field_0xBA0 == 0) {
+            field_0xBA0 = 1;
+        }
+    }
+}
+
+bool dAcEsm_c::fn_187_42C0() {
+    if (sLib::calcTimer(&field_0xBAC)) {
+        return false;
+    }
+
+    if (mSph.ChkAtHit() && mSph.GetAtActor()->profile_name == fProfile::PLAYER) {
+        if (fn_187_4B50()) {
+            return true;
+        }
+
+        if (sValueFromPlayer > 30) {
+            sValueFromPlayer = 0;
+        }
+
+        if (mHealth != 0 && !fn_187_6B10() && !ChkCrossPlayer(0.f) && !mStateMgr.isState(StateID_Absorption) &&
+            !mStateMgr.isState(StateID_BirthJump)) {
+            mStateMgr.changeState(StateID_Absorption);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void dAcEsm_c::fn_187_4450() {
+    if (mType == SM_YELLOW) {
+        mSph.OnTgElectric();
+        mAnmMatClr.setRate(1.f, 0);
+    }
+    mSph.OffAt_0x40();
+    mSph.OnAtSet();
+}
+
+void dAcEsm_c::fn_187_44C0() {
+    if (mType == SM_YELLOW) {
+        mSph.ClrTgElectric();
+        mAnmMatClr.setRate(0.f, 0);
+        mAnmMatClr.setFrame(0.f, 0);
+    }
+    mSph.OnAt_0x40();
+}
+
+void dAcEsm_c::fn_187_4540(int param0) {
+    const dAcPy_c *player = dAcPy_c::GetLink();
+    mAng3_c rot = GetAngle();
+
+    fn_187_44C0();
+    if (mStateMgr.isState(StateID_Dead)) {
+        return;
+    }
+
+    if ((param0 != 0 && mScaleTarget.x <= 0.25f) || mHealth == 0) {
+        if (param0 != 0 && param0 != 6 && param0 != 2 && param0 != 7) {
+            mHealth = 0;
+        }
+
+        // NOTE: Unused Return Value
+        mStateMgr.isState(StateID_Absorption);
+
+        fn_187_61B0(0);
+        mStateMgr.changeState(StateID_Dead);
+        return;
+    }
+
+    if (param0 != 0) {
+        if (mScaleTarget.x == 1.2f) {
+            mScaleTarget.set(1.6f, 1.6f, 1.6f);
+        }
+        mScaleTarget *= 0.5f;
+        mScale *= 0.5f;
+
+        rot.y = (s16)cLib::targetAngleY(position, player->position) + cM::rndFX(1024.f);
+
+        if (field_0xB98 != 2) {
+            rot.y = fn_187_5150(false);
+        }
+        rot.y = mOrigRotZ;
+
+        mVec3_c spawnPos;
+        mHitPos.CopyTo(spawnPos);
+        if (field_0xB98 == 1 || field_0xB98 == 2) {
+            position.CopyTo(spawnPos);
+        }
+
+        f32 scale = 0.9999f;
+        f32 upper = 30.f;
+        f32 lower = 20.f;
+        f32 v = 0.f;
+        f32 lowest = 10.f;
+        u8 timer = 8;
+        u8 bce = 1;
+        u8 bb8 = 0;
+        f32 f = 16384.f;
+
+        dAcEsm_c *pChild = static_cast<dAcEsm_c *>(
+            create(fProfile::E_SM, roomid, (params & ~0xFF) | mType, &spawnPos, &rot, nullptr, 0)
+        );
+        if (pChild == nullptr) {
+            return;
+        }
+
+        if (field_0xB98 == 2) {
+            mVec3_c temp0 = mScaleTarget;
+            mVec3_c temp1 = mScale;
+            temp0 *= scale;
+            temp1 *= scale;
+            temp0.CopyTo(pChild->mScaleTarget);
+            temp1.CopyTo(pChild->mScale);
+        } else {
+            mScaleTarget.CopyTo(pChild->mScaleTarget);
+            pChild->mScale.set(mScale.x, mScale.y, mScale.z);
+        }
+        pChild->mStartingPos.set(mStartingPos.x, mStartingPos.y, mStartingPos.z);
+        pChild->mDamageTimer = timer;
+        pChild->field_0xBB2 = timer;
+        pChild->field_0xB98 = field_0xB98;
+        pChild->field_0xBCE = bce;
+        pChild->mStateMgr.changeState(StateID_BirthJump);
+
+        if (field_0xB98 == 0) {
+            mAng ang = (f + cM::rndFX(4096.f));
+            rot.y -= mAng(ang);
+        } else {
+            rot.y = fn_187_51F0(true);
+            const f32 y = sSmDataArr[field_0xB98].field_0x04.y;
+            if (y != v) {
+                pChild->velocity.y = y;
+
+                pChild->velocity.y *= mScaleTarget.y;
+                if (field_0xB98 != 2) {
+                    if (pChild->velocity.y < lower) {
+                        pChild->velocity.y = lower;
+                    }
+                } else {
+                    if (pChild->velocity.y < upper) {
+                        pChild->velocity.y = upper;
+                    }
+                }
+            }
+
+            pChild->field_0xB84 = pChild->velocity.y;
+            pChild->forwardSpeed = mScaleTarget.x * sSmDataArr[field_0xB98].field_0x04.x;
+            if (pChild->forwardSpeed != v && pChild->forwardSpeed < lowest) {
+                pChild->forwardSpeed = lowest;
+            }
+            pChild->field_0xBB8 = bb8;
+        }
+    }
+
+    mSph.OnCoSet();
+    if (field_0xB98 != 2) {
+        angle.y = rot.y;
+    }
+    if (field_0xB98 != 0) {
+        field_0xBCE = 1;
+        mDamageTimer = 8;
+        field_0xBB2 = 8;
+    }
+    fn_187_6C20(1);
+    if (field_0xB98 != 0) {
+        if (sSmDataArr[field_0xB98].field_0x10.y) {
+            velocity.y = sSmDataArr[field_0xB98].field_0x10.y;
+            velocity.y *= mScaleTarget.y;
+            if (field_0xB98 != 2) {
+                if (velocity.y < 20.f) {
+                    velocity.y = 20.f;
+                }
+            } else {
+                if (velocity.y < 30.f) {
+                    velocity.y = 30.f;
+                }
+            }
+        }
+
+        field_0xB84 = velocity.y;
+        forwardSpeed = sSmDataArr[field_0xB98].field_0x10.y * mScaleTarget.x;
+        if (forwardSpeed && forwardSpeed < 10.f) {
+            forwardSpeed = 10.f;
+        }
+        field_0xBB8 = 0;
+        if (field_0xB98 == 2) {
+            mTimer_0xBC4 = 20;
+        }
+        playSound(SE_ESm_JUMP);
+    }
+}
+
+bool dAcEsm_c::fn_187_4B50() {
+    if (mStateMgr.isState(StateID_Dead)) {
+        return false;
+    }
+
+    if (mBombRef.isLinked()) {
+        dAcBomb_c *pBomb = mBombRef.get();
+        if (pBomb) {
+            pBomb->On_0xA3C(0x4);
+            pBomb->Off_0xA3C(0x800000);
+            mBombRef.unlink();
+        }
+
+        if (mStateMgr.isState(StateID_Absorption)) {
+            fn_187_5730();
+        }
+        mStateMgr.changeState(StateID_Dead);
+        return true;
+    }
+
+    return false;
+}
+
+bool dAcEsm_c::fn_187_4C50() {
+    int attr = dBgS::GetInstance()->GetSpecialCode(mObjAcch.GetGnd());
+
+    return (attr == POLY_ATTR_LAVA || attr == POLY_ATTR_SAND_DEEP_INSTANT || attr == POLY_ATTR_SAND_DEEP_SLOW);
+}
+
+void dAcEsm_c::Set_0xBBC(u8 val) {
+    field_0xBBC = val;
+}
+
+void dAcEsm_c::fn_187_4CC0() {
+    mVec3_c scale = mScale;
+    if (field_0xBC6 == 1 || field_0xBC6 == 2) {
+        field_0xB8C = mTimeArea.getDistMaybe();
+        scale.multScalar(field_0xB8C);
+    }
+
+    if (mObjAcch.ChkWallHit(nullptr)) {
+        sLib::addCalcAngle(angle.y.ref(), mAcchCir.GetWallAngleY(), 4, 0x200);
+    }
+    sLib::addCalcAngle(rotation.y.ref(), angle.y, 2, 0x800);
+    sLib::addCalcAngle(mRotUnk.x.ref(), mTargetRotX, 4, 0x800);
+    sLib::addCalcAngle(mRotUnk.z.ref(), mTargetRotZ, 4, 0x800);
+
+    mWorldMtx.transS(position.x, position.y, position.z);
+    mWorldMtx.XrotM(mRotUnk.x);
+    mWorldMtx.ZrotM(mRotUnk.z);
+    mWorldMtx.ZXYrotM(rotation.x, rotation.y, rotation.z);
+
+    f32 s = 1.f - 0.2f * field_0xB5C;
+    f32 z = 150.f * mScaleTarget.x;
+#define _WORLD_MTX_TRANS(x, y, z)                                                                                      \
+    {                                                                                                                  \
+        const f32 _x = x;                                                                                              \
+        const f32 _z = z;                                                                                              \
+        const f32 _y = y;                                                                                              \
+        mMtx_c m;                                                                                                      \
+        MTXTrans(m, _x, _y, _z);                                                                                       \
+        mWorldMtx += m;                                                                                                \
+    }
+#define _WORLD_MTX_SCALE(x, y, z)                                                                                      \
+    {                                                                                                                  \
+        const f32 _x = x;                                                                                              \
+        const f32 _z = z;                                                                                              \
+        const f32 _y = y;                                                                                              \
+        mMtx_c m;                                                                                                      \
+        MTXScale(m, _x, _y, _z);                                                                                       \
+        mWorldMtx += m;                                                                                                \
+    }
+
+    _WORLD_MTX_TRANS(0.f, 0.f, z);
+    _WORLD_MTX_SCALE(s, s - field_0xB5C, 1.f + field_0xB5C);
+    _WORLD_MTX_TRANS(0.f, 0.f, -z);
+    _WORLD_MTX_TRANS(0.f, 0.f, field_0xB48);
+    _WORLD_MTX_SCALE(scale.y / field_0xB58, scale.x * field_0xB58, scale.y / field_0xB58);
+    _WORLD_MTX_TRANS(0.f, 0.f, -field_0xB48);
+    mRotCopy.z = field_0xBA6;
+    _WORLD_MTX_TRANS(20.f, 0.f, 20.f);
+    mWorldMtx.ZrotM(mRotCopy.z);
+    mWorldMtx.XrotM(mRotCopy.z);
+    _WORLD_MTX_SCALE(1.f - field_0xB50, 1.f + field_0xB50, 1.f - field_0xB50);
+    mWorldMtx.XrotM(-mRotCopy.z);
+    mWorldMtx.ZrotM(-mRotCopy.z);
+    _WORLD_MTX_TRANS(-20.f, -0.f, -20.f);
+    _WORLD_MTX_TRANS(20.f, 0.f, -20.f);
+    mWorldMtx.ZrotM(mRotCopy.z);
+    mWorldMtx.YrotM(mRotCopy.z);
+    _WORLD_MTX_SCALE(1.f - field_0xB50, 1.f + field_0xB50, 1.f - field_0xB50);
+    mWorldMtx.YrotM(-mRotCopy.z);
+    mWorldMtx.ZrotM(-mRotCopy.z);
+    _WORLD_MTX_TRANS(-20.f, -0.f, 20.f);
+    _WORLD_MTX_TRANS(-20.f, 0.f, 20.f);
+    mWorldMtx.ZrotM(mRotCopy.z);
+    _WORLD_MTX_SCALE(1.f - field_0xB50, 1.f + field_0xB50, 1.f - field_0xB50);
+    mWorldMtx.ZrotM(-mRotCopy.z);
+    _WORLD_MTX_TRANS(20.f, -0.f, -20.f);
+    _WORLD_MTX_TRANS(-20.f, 0.f, -20.f);
+    mWorldMtx.XrotM(mRotCopy.z);
+    _WORLD_MTX_SCALE(1.f - field_0xB50, 1.f + field_0xB50, 1.f - field_0xB50);
+    mWorldMtx.XrotM(-mRotCopy.z);
+#undef _WORLD_MTX_TRANS
+#undef _WORLD_MTX_SCALE
+
+    mMdl.play();
+    mMdl.getModel().setLocalMtx(mWorldMtx);
+    mMdl.getModel().calc(false);
+    mWorldMtx.getTranslation(mEffPos);
+    updateBoundingBox();
+}
+// . . .
+
+bool dAcEsm_c::checkSize(dAcEsm_c::SmSize_e size) const {
+    bool ret = false;
+
+    switch (size) {
+        default:
+        case SM_SMALL: {
+            if (mScaleTarget.x > 0.4f && mScaleTarget.x <= 0.8f) {
+                ret = true;
+            }
+        } break;
+        case SM_LARGE: {
+            if (mScaleTarget.x > 0.25f && mScaleTarget.x <= 0.4f) {
+                ret = true;
+            }
+        } break;
+        case SM_MASSIVE: {
+            if (mScaleTarget.x <= 0.25f) {
+                ret = true;
+            }
+        } break;
+        case SM_TINY: {
+            if (mScaleTarget.x > 0.8f && mScaleTarget.x <= 1.2f) {
+                ret = true;
+            }
+        } break;
+    }
+    return ret;
+}
+
+// . . .
+void dAcEsm_c::fn_187_5940() {
+    mMdl.getModel().getResMdl().GetResNode("center");
+}
+void dAcEsm_c::updateBoundingBox() {
+    f32 min = -200.f / mScale.x;
+    f32 max = 200.f / mScale.x;
+    boundingBox.Set(mVec3_c(min, min, min), mVec3_c(max, 250.f / mScale.x, max));
+}
+
+void dAcEsm_c::fn_187_61B0(u8 param0) {
+    if (param0 == 0 && field_0xB98 == 0) {
+        return;
+    }
+
+    const dAcPy_c *player = dAcPy_c::GetLink();
+
+    // Yellowish
+    mColor clr1(0xFF, 0xC8, 0x32, 0xFF);
+    // Redish
+    mColor clr2(0xC8, 0x32, 0x00, 0xFF);
+
+    mAng3_c ang(0, 0, 0);
+    mMtx_c mtx_trans = mWorldMtx;
+    mVec3_c scale;
+
+    if (mType == SM_BLUE) {
+        // Blue/purple
+        clr1 = mColor(0x64, 0x64, 0xFF, 0xFF);
+        // Purple
+        clr2 = mColor(0x50, 0x50, 0x96, 0xFF);
+    } else if (mType == SM_YELLOW) {
+        // Yellow
+        clr1 = mColor(0xFF, 0xFF, 0x00, 0xFF);
+        // Darker Yellow
+        clr2 = mColor(0x96, 0x96, 0x00, 0xFF);
+    } else if (mType == SM_GREEN) {
+        // Light Green
+        clr1 = mColor(0x00, 0xBE, 0x73, 0xFF);
+        // Darker Blue-Green
+        clr2 = mColor(0x00, 0x73, 0x69, 0xFF);
+    }
+
+    switch (param0) {
+        case 0: {
+            mMtx_c mtx_scale;
+            ang.set(0, 0, 0);
+            ang.z += player->vt_0x258();
+            MTXTrans(mtx_trans, mHitPos.x, mHitPos.y, mHitPos.z);
+            mtx_trans.YrotM(rotation.y);
+            mtx_trans.ZYXrotM(ang);
+            MTXScale(mtx_scale, mScaleTarget.x, mScaleTarget.x, mScaleTarget.x);
+
+            mtx_trans += mtx_scale;
+            for (int i = 0; i <= 2; ++i) {
+                dEmitterBase_c *emitter =
+                    dJEffManager_c::spawnEffect(sEmitterResArr[param0 + i], mtx_trans, &clr1, &clr2, 0, 0);
+                if (emitter == nullptr) {
+                    continue;
+                }
+                switch (i) {
+                    case 0: {
+                        if (checkSize(SM_LARGE)) {
+                            emitter->setRate(20.0f);
+                            scale.set(2.f, 2.f, 2.f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        } else if (checkSize(SM_MASSIVE)) {
+                            emitter->setRate(15.0f);
+                            scale.set(2.5f, 2.5f, 2.5f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        }
+                    } break;
+                    case 1: {
+                        if (checkSize(SM_LARGE)) {
+                            scale.set(1.14f, 1.3f, 1.14f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        } else if (checkSize(SM_MASSIVE)) {
+                            scale.set(1.43f, 2.67f, 1.43f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        }
+                    } break;
+                    case 2: {
+                        if (checkSize(SM_LARGE)) {
+                            scale.set(1.12f, 1.12f, 1.12f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        } else if (checkSize(SM_MASSIVE)) {
+                            scale.set(1.22f, 1.22f, 1.22f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        }
+                    } break;
+                }
+            }
+        } break;
+        case 3: {
+            mMtx_c mtx_scale;
+            MTXTrans(mtx_trans, position.x, position.y, position.z);
+            MTXScale(mtx_scale, mScaleTarget.x, mScaleTarget.y, mScaleTarget.z);
+            mtx_trans += mtx_scale;
+
+            if (mEffArr[0].createEffect(sEmitterResArr[3], mtx_trans, &clr1, &clr2)) {
+                if (checkSize(SM_LARGE)) {
+                    mEffArr[0].setRate(12.0f);
+                    scale.set(1.7f, 1.7f, 1.7f);
+                    scale *= mScaleTarget.x;
+                    mEffArr[0].setParticleScale(scale);
+                } else if (checkSize(SM_MASSIVE)) {
+                    mEffArr[0].setRate(7.0f);
+                    scale.set(2.5f, 2.5f, 2.5f);
+                    scale *= mScaleTarget.x;
+                    mEffArr[0].setParticleScale(scale);
+                }
+            }
+
+        } break;
+        case 4: {
+            mMtx_c mtx_scale;
+            MTXTrans(mtx_trans, position.x, position.y, position.z);
+            mtx_trans.YrotM(rotation.y);
+            MTXScale(mtx_scale, mScaleTarget.x, mScaleTarget.y, mScaleTarget.z);
+            mtx_trans += mtx_scale;
+            dJEffManager_c::spawnEffect(PARTICLE_RESOURCE_ID_MAPPING_280_, mtx_trans, &clr1, &clr2, 0, 0);
+
+            for (int i = 4; i <= 5; ++i) {
+                dEmitterBase_c *emitter = dJEffManager_c::spawnEffect(sEmitterResArr[i], mtx_trans, &clr1, &clr2, 0, 0);
+                if (emitter == nullptr) {
+                    continue;
+                }
+                switch (i) {
+                    case 4: {
+                        if (checkSize(SM_LARGE)) {
+                            emitter->setRate(5.0f);
+                            scale.set(1.17f, 1.17f, 1.17f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        } else if (checkSize(SM_MASSIVE)) {
+                            emitter->setRate(3.0f);
+                            scale.set(1.25f, 1.25f, 1.25f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        }
+                    } break;
+                    case 5: {
+                        if (checkSize(SM_LARGE)) {
+                            emitter->setRate(20.0f);
+                            scale.set(1.5f, 1.5f, 1.5f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        } else if (checkSize(SM_MASSIVE)) {
+                            emitter->setRate(15.0f);
+                            scale.set(2.f, 2.f, 2.f);
+                            scale *= mScaleTarget.x;
+                            emitter->setParticleScale(scale);
+                        }
+                    } break;
+                }
+            }
+        } break;
+        case 7: {
+            mScaleTarget.CopyTo(scale);
+            if (checkSize(SM_LARGE) || checkSize(SM_MASSIVE)) {
+                scale *= 2.f;
+            }
+            mMtx_c mtx_scale;
+            MTXTrans(mtx_trans, mHitPos.x, mHitPos.y, mHitPos.z);
+            mtx_trans.YrotM(rotation.y);
+            MTXScale(mtx_scale, scale.x, scale.y, scale.z);
+            mtx_trans += mtx_scale;
+            dJEffManager_c::spawnEffect(sEmitterResArr[param0], mtx_trans, &clr1, &clr2, 0, 0);
+        } break;
+    }
+
+    return;
+}
+
+bool dAcEsm_c::fn_187_6B10() {
+    const dAcPy_c *player = dAcPy_c::GetLink();
+    if (mStateMgr.isState(StateID_Dead)) {
+        return true;
+    }
+    if (fn_187_5AC0() || player->getRidingMinecartActor() ||
+        player->getRidingActorType() == dAcPy_c::RIDING_TRUCK_MINECART || player->isRecovering() ||
+        player->isRidingBall() || player->checkActionFlags(0x1000000) || player->checkActionFlags(0x40)) {
+        return true;
+    }
+
+    return false;
+}
+
+void dAcEsm_c::fn_187_6C20(bool param0) {
+    fn_187_5730();
+    if (!param0) {
+        fn_187_4540(0);
+    }
+
+    mSph.SetAtFlagsUpper(0);
+    sTimer = 0;
+    setInteractionFlags(4);
+    fn_187_44C0();
+    field_0xBAC = 60;
+
+    if (!param0) {
+        dCamera_c *cam = dScGame_c::getCamera(0);
+        angle.y = cLib::targetAngleY(cam->getPositionMaybe(), cam->getField_0x78());
+        angle.addY(cM::rndFX(16384.f));
+    }
+
+    field_0xBCE = 1;
+    mStateMgr.changeState(StateID_BirthJump);
+}
+
+const u16 dAcEsm_c::sEmitterResArr[8] = {PARTICLE_RESOURCE_ID_MAPPING_283_, PARTICLE_RESOURCE_ID_MAPPING_284_,
+                                         PARTICLE_RESOURCE_ID_MAPPING_285_, PARTICLE_RESOURCE_ID_MAPPING_278_,
+                                         PARTICLE_RESOURCE_ID_MAPPING_281_, PARTICLE_RESOURCE_ID_MAPPING_282_,
+                                         PARTICLE_RESOURCE_ID_MAPPING_280_, PARTICLE_RESOURCE_ID_MAPPING_279_};
+
+const dAcEsm_c::SmData_c dAcEsm_c::sSmDataArr[8] = {
+    {     0,      0,  mVec3_c(0.f,  0.f, 0.f),  mVec3_c(0.f,  0.f, 0.f)},
+    {0x4000, 0xC000, mVec3_c(25.f, 30.f, 0.f), mVec3_c(25.f, 30.f, 0.f)},
+    {     0,      0,  mVec3_c(0.f, 40.f, 0.f),  mVec3_c(0.f,  0.f, 0.f)},
+    {0x4000, 0xC000, mVec3_c(20.f, 35.f, 0.f), mVec3_c(10.f, 25.f, 0.f)},
+    {0xC000, 0x4000, mVec3_c(20.f, 35.f, 0.f), mVec3_c(10.f, 25.f, 0.f)},
+    {0x4000, 0xC000, mVec3_c(20.f, 35.f, 0.f), mVec3_c(10.f, 25.f, 0.f)},
+    {0xC000, 0x4000, mVec3_c(20.f, 35.f, 0.f), mVec3_c(10.f, 25.f, 0.f)},
+    {     0,      0,  mVec3_c(0.f, 40.f, 0.f),  mVec3_c(0.f,  0.f, 0.f)},
+};
diff --git a/src/REL/d/a/npc/d_a_npc_saltalk.cpp b/src/REL/d/a/npc/d_a_npc_saltalk.cpp
index 1c15362a..3c608b62 100644
--- a/src/REL/d/a/npc/d_a_npc_saltalk.cpp
+++ b/src/REL/d/a/npc/d_a_npc_saltalk.cpp
@@ -16,12 +16,6 @@ SPECIAL_ACTOR_PROFILE(NPC_SLTK, dAcNpcSltk_c, fProfile::NPC_SLTK, 0x63, 0, 0);
 
 STATE_VIRTUAL_DEFINE(dAcNpcSltk_c, Wait);
 
-#pragma explicit_zero_data on
-int rot0 = 0;
-int rot1 = 0;
-int rot2 = 0;
-#pragma explicit_zero_data off
-
 int dAcNpcSltk_c::create() {
     return dAcBase_c::create();
 }
@@ -50,9 +44,7 @@ int dAcNpcSltk_c::actorCreate() {
         }
     }
 
-    rotation.x = rot0;
-    rotation.y = rot1;
-    rotation.z = rot2;
+    rotation.set(0, 0, 0);
 
     field_0x758 = getParam2() * 100;
     field_0x75C = getParam3() * 100;
diff --git a/src/REL/d/a/obj/d_a_obj_dungeon_ship.cpp b/src/REL/d/a/obj/d_a_obj_dungeon_ship.cpp
index 9e16849e..cdd7d2ec 100644
--- a/src/REL/d/a/obj/d_a_obj_dungeon_ship.cpp
+++ b/src/REL/d/a/obj/d_a_obj_dungeon_ship.cpp
@@ -106,10 +106,6 @@ ok:
     return true;
 }
 
-#pragma explicit_zero_data on
-static u32 rotX_init = 0;
-#pragma explicit_zero_data off
-
 int dAcODungeonShip_c::create() {
     if (!StoryflagManager::sInstance->getCounterOrFlag(271)) {
         return FAILED;
@@ -158,7 +154,7 @@ int dAcODungeonShip_c::create() {
     clearActorProperty(0x1);
     mAppearEventFromParam = (params >> 0x18);
     field_0x849 = rotation.x;
-    rotation.x = rotX_init;
+    rotation.x = 0;
     updateMatrix();
     mBg.Move();
     return SUCCEEDED;
@@ -171,9 +167,6 @@ int dAcODungeonShip_c::doDelete() {
     return SUCCEEDED;
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_682_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_683_;
-
 int dAcODungeonShip_c::actorExecute() {
     field_0x850++;
     field_0x86C++;
@@ -196,7 +189,9 @@ int dAcODungeonShip_c::actorExecute() {
     mAnmMatClr.play();
     mMdl.calc(false);
     if (field_0x8D8) {
-        mEffects[0].createContinuousEffect(PARTICLE_RESOURCE_ID_MAPPING_682_, position, &rotation, nullptr, nullptr, nullptr);
+        mEffects[0].createContinuousEffect(
+            PARTICLE_RESOURCE_ID_MAPPING_682_, position, &rotation, nullptr, nullptr, nullptr
+        );
     }
 
     if (field_0x8D9) {
diff --git a/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp b/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp
index a0ed45dd..f7b39a39 100644
--- a/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp
+++ b/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp
@@ -155,7 +155,7 @@ UNKTYPE dAcOivyRope_c::fn_256_4C80(UNKTYPE) {}
 UNKTYPE dAcOivyRope_c::fn_256_4CA0(UNKTYPE) {}
 
 int dAcOivyRope_c::createBase() {
-    rotation.set(0, 0, 0);
+    rotation = 0;
     f32 temp = 2000.f - 750.f;
     mDistance = 2000.f;
     mOldDistance = 2000.f;
diff --git a/src/REL/d/a/obj/d_a_obj_seat_sword.cpp b/src/REL/d/a/obj/d_a_obj_seat_sword.cpp
index a889ad49..61ae95e3 100644
--- a/src/REL/d/a/obj/d_a_obj_seat_sword.cpp
+++ b/src/REL/d/a/obj/d_a_obj_seat_sword.cpp
@@ -174,7 +174,7 @@ void dAcOSeatSword_c::registerInEvent() {
         vec.rotY(rotation.y);
         vec += position;
         player->setPosRot(vec, ang, 0, 1, 0);
-        mField_0x7E8 = 0;
+        mField_0x7E8.set(0);
         updateSwordMdl();
     }
 }
@@ -212,7 +212,6 @@ void dAcOSeatSword_c::initializeState_Get() {
 void dAcOSeatSword_c::executeState_Get() {}
 void dAcOSeatSword_c::finalizeState_Get() {}
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_76_;
 void dAcOSeatSword_c::actorExecuteCommon() {
     if (checkPlayerHasSword()) {
         return;
diff --git a/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp b/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp
index eac5d5a1..0a2200b8 100644
--- a/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp
+++ b/src/REL/d/a/obj/d_a_obj_tower_gearD101.cpp
@@ -127,7 +127,8 @@ void dAcOTowerGearD101_c::initTransform() {
     mMdl.setLocalMtx(field_0x3C4);
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_585_;
 void dAcOTowerGearD101_c::playVisualEffect() {
-    mEffects.createContinuousEffect(PARTICLE_RESOURCE_ID_MAPPING_585_, field_0x3F4, &rotation, nullptr, nullptr, nullptr);
+    mEffects.createContinuousEffect(
+        PARTICLE_RESOURCE_ID_MAPPING_572_, field_0x3F4, &rotation, nullptr, nullptr, nullptr
+    );
 }
diff --git a/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp b/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp
index 2c584c5d..8398f3d0 100644
--- a/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp
+++ b/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp
@@ -593,11 +593,10 @@ void dAcOTowerHandD101_c::executeState_RemainOpen() {
 }
 void dAcOTowerHandD101_c::finalizeState_RemainOpen() {}
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_573;
 void dAcOTowerHandD101_c::initializeState_Close() {
     mMdl.getAnm().setPlayState(m3d::PLAY_MODE_1);
     mMdl.setRate(getCloseRate());
-    mEffects.createEffect(PARTICLE_RESOURCE_ID_MAPPING_573, position, nullptr, nullptr, nullptr, nullptr);
+    mEffects.createEffect(PARTICLE_RESOURCE_ID_MAPPING_573_, position, nullptr, nullptr, nullptr, nullptr);
     playSound(0xC0C);
 }
 void dAcOTowerHandD101_c::executeState_Close() {
diff --git a/src/REL/d/a/obj/d_a_obj_tubo.cpp b/src/REL/d/a/obj/d_a_obj_tubo.cpp
index 8b6481de..ec396692 100644
--- a/src/REL/d/a/obj/d_a_obj_tubo.cpp
+++ b/src/REL/d/a/obj/d_a_obj_tubo.cpp
@@ -40,11 +40,6 @@ void float_ordering() {
     f32 f[] = {15.f, .4f, .4f, 5.f};
 }
 
-#pragma explicit_zero_data on
-u8 dAcOtubo_c::sUnk0 = 1;
-u32 dAcOtubo_c::sUnk1 = 0;
-#pragma explicit_zero_data off
-
 SPECIAL_ACTOR_PROFILE(OBJ_TUBO, dAcOtubo_c, fProfile::OBJ_TUBO, 0x194, 0, 130);
 
 STATE_DEFINE(dAcOtubo_c, Wait);
@@ -449,7 +444,6 @@ void dAcOtubo_c::finalizeState_Rebirth() {
     setActorProperty(0x1);
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_109_, PARTICLE_RESOURCE_ID_MAPPING_209_;
 extern "C" void fn_80022BE0(void *, const mVec3_c &);
 
 void dAcOtubo_c::destroy() {
@@ -637,7 +631,7 @@ void dAcOtubo_c::attemptDestroy() {
     }
 
     if (mObjAcch.ChkWallHit(nullptr) && sLib::absDiff(mAcchCir.GetWallAngleY(), angle.y) > mAng::deg2short(70.f)) {
-        attemptDestroyOnWall(&sUnk1, &sUnk0);
+        attemptDestroyOnWall();
         angle.y = mAcchCir.GetWallAngleY();
         forwardSpeed *= 0.5f;
         return;
@@ -681,8 +675,8 @@ void dAcOtubo_c::attemptDestroy() {
     }
 }
 
-void dAcOtubo_c::attemptDestroyOnWall(u32 *, const u8 *unk) {
-    if (*unk && sLib::absDiff(mAcchCir.GetWallAngleY(), angle.y) > mAng::deg2short(70.f) && 15.f < forwardSpeed) {
+void dAcOtubo_c::attemptDestroyOnWall(const u32 &param0, const bool &param1) {
+    if (param1 && sLib::absDiff(mAcchCir.GetWallAngleY(), angle.y) > mAng::deg2short(70.f) && 15.f < forwardSpeed) {
         destroy();
     }
 }
diff --git a/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp b/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp
index 367f48e2..52890a43 100644
--- a/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp
+++ b/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp
@@ -18,10 +18,11 @@
 #include "m/m_vec.h"
 #include "s/s_Math.h"
 #include "toBeSorted/blur_and_palette_manager.h"
-#include "toBeSorted/dowsing_target.h"
 #include "toBeSorted/d_emitter.h"
+#include "toBeSorted/dowsing_target.h"
 #include "toBeSorted/small_sound_mgr.h"
 
+
 void float_ordering() {
     const f32 arr[] = {5.f, 15.f, 7.f, 0.5f, 0.1f};
 }
@@ -261,8 +262,6 @@ bool dAcOTumbleWeed_c::checkInvalidGround() const {
            code == POLY_ATTR_SAND_DEEP_SLOW;
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_743_;
-
 void dAcOTumbleWeed_c::doBreak() {
     playSound(SE_TWeed_CUT);
     mVec3_c pos = getPosition();
diff --git a/src/REL/d/a/obj/d_a_obj_utajima_island.cpp b/src/REL/d/a/obj/d_a_obj_utajima_island.cpp
index 6ca9731a..23c2c3b5 100644
--- a/src/REL/d/a/obj/d_a_obj_utajima_island.cpp
+++ b/src/REL/d/a/obj/d_a_obj_utajima_island.cpp
@@ -48,8 +48,7 @@ int dAcOutajimaIsland_c::actorCreate() {
     s32 v = getParm2() * 30;
     field_0x5BC = mAng::fromDeg(v);
     field_0x5BE.x = field_0x5BC;
-    field_0x5BE.z = 0x88;
-    field_0x5BE.y = 0x88;
+    field_0x5BE.y = field_0x5BE.z = mAng(0x88);
 
     movePlatforms();
     CREATE_ALLOCATOR(dAcOutajimaIsland_c);
diff --git a/src/REL/d/t/d_t_dowsing.cpp b/src/REL/d/t/d_t_dowsing.cpp
index fa099174..5700258a 100644
--- a/src/REL/d/t/d_t_dowsing.cpp
+++ b/src/REL/d/t/d_t_dowsing.cpp
@@ -16,7 +16,7 @@ int dTgDowsing_c::create() {
     }
     mUntriggerStoryFlag = getUntriggerStoryFlag();
     mTriggerStoryFlag = getTriggerStoryFlag();
-    rotation.z = 0;
+    rotation.z.set(0);
     bool doThing = getDowsingOptionNum() <= DOWSING_MAX && (1 << getDowsingOptionNum() & 0xC3F) != 0;
 
     mDowsingTarget.initialize(!doThing ? DowsingTarget::SLOT_QUEST : DowsingTarget::SLOT_STORY_EVENT, 0, nullptr, 0);
diff --git a/src/REL/d/t/d_t_gekotag.cpp b/src/REL/d/t/d_t_gekotag.cpp
index ed714cda..a2d54041 100644
--- a/src/REL/d/t/d_t_gekotag.cpp
+++ b/src/REL/d/t/d_t_gekotag.cpp
@@ -8,12 +8,6 @@
 #include "m/m_angle.h"
 #include "s/s_Math.h"
 
-#pragma explicit_zero_data on
-static u32 initialRotX = 0;
-static u32 initialRotY = 0;
-static u32 initialRotZ = 0;
-#pragma explicit_zero_data off
-
 SPECIAL_ACTOR_PROFILE(GEKO_TAG, dTgGekoTag, fProfile::GEKO_TAG, 0xEE, 0, 0);
 
 STATE_DEFINE(dTgGekoTag, Wait);
@@ -74,7 +68,8 @@ void dTgGekoTag::doExecute() {
     gekoParmTmp = (gekoParmTmp & 0xFFFF00FF) | (params & 0xFF00);
     u32 gekoParm = gekoParmTmp | ((mGekoParam != 0 ? 3 : 1) << 16);
 
-    mAng3_c gekoRot = mAng3_c(initialRotX, initialRotY, initialRotZ);
+    mAng3_c gekoRot;
+    gekoRot.clear();
     gekoRot.y = cM::rndF(65535.0f);
     int numFullGekoRefs = 0;
     for (int i = 0; i < mNumGeko; i++) {
diff --git a/src/REL/d/t/d_t_reaction.cpp b/src/REL/d/t/d_t_reaction.cpp
index 7c7849d4..9c55a906 100644
--- a/src/REL/d/t/d_t_reaction.cpp
+++ b/src/REL/d/t/d_t_reaction.cpp
@@ -14,9 +14,6 @@
 SPECIAL_ACTOR_PROFILE(TAG_REACTION, dTgReaction_c, fProfile::TAG_REACTION, 0x0151, 0, 0);
 
 STATE_DEFINE(dTgReaction_c, Wait);
-#pragma explicit_zero_data on
-const u32 fZero = 0;
-#pragma explicit_zero_data off
 const f32 dTgReaction_c::sRadius = 100.0f;
 const f32 dTgReaction_c::sHeight = 100.0f;
 
@@ -29,10 +26,6 @@ dCcD_SrcCyl dTgReaction_c::sCcSrc = {
 };
 // clang-format on
 
-#pragma explicit_zero_data on
-static u32 initialRotX = 0;
-#pragma explicit_zero_data off
-
 bool dTgReaction_c::createHeap() {
     return true;
 }
@@ -55,8 +48,8 @@ int dTgReaction_c::create() {
     }
 
     field_0x4E0 = rotation.x & 0xFF;
-    angle.x = initialRotX;
-    rotation.x = angle.x;
+    rotation.x = angle.x = 0;
+
     if (field_0x4E0 < 0xFF && !SceneflagManager::sInstance->checkBoolFlag(roomid, field_0x4E0)) {
         return FAILED;
     }
diff --git a/src/REL/d/t/d_t_ship_window.cpp b/src/REL/d/t/d_t_ship_window.cpp
index 7b650421..922accf3 100644
--- a/src/REL/d/t/d_t_ship_window.cpp
+++ b/src/REL/d/t/d_t_ship_window.cpp
@@ -1,28 +1,20 @@
 #include "d/t/d_t_ship_window.h"
 
-#include "toBeSorted/event_manager.h"
 #include "d/flag/sceneflag_manager.h"
-
+#include "toBeSorted/event_manager.h"
 
 SPECIAL_ACTOR_PROFILE(TAG_SHIP_WINDOW, dTgShipWindow_c, fProfile::TAG_SHIP_WINDOW, 0x0228, 0, 0);
 
 STATE_DEFINE(dTgShipWindow_c, On);
 STATE_DEFINE(dTgShipWindow_c, Off);
 
-// sDefaultRotX got placed in .data despite being zero.
-// There is a handy pragma for this but it's probably not
-// the correct solution.
-#pragma explicit_zero_data on
-u32 dTgShipWindow_c::sDefaultRotX = 0;
-#pragma explicit_zero_data off
-
 int dTgShipWindow_c::create() {
     mInitialStateFlag = params & 0xFF;
     mOutputStateFlagBase = (params >> 8) & 0xFF;
     mOffEventId = (params >> 16) & 0xFF;
     mOnEventId = (params >> 24) & 0xFF;
     mAlwaysPlayEvent = rotation.x & 1;
-    rotation.x = sDefaultRotX;
+    rotation.x = 0;
     if (SceneflagManager::sInstance->checkBoolFlag(roomid, mInitialStateFlag)) {
         SceneflagManager::sInstance->setFlag(roomid, mOutputStateFlagBase);
         mStateMgr.changeState(StateID_On);
@@ -75,8 +67,8 @@ void dTgShipWindow_c::executeState_Off() {
     }
 
     if ((mHasPlayedOffEvent == 0 || mAlwaysPlayEvent == 0) &&
-        (mOutputStateFlagBase >= 0xFF || !SceneflagManager::sInstance->checkBoolFlag(roomid, mOutputStateFlagBase + 1)
-        )) {
+        (mOutputStateFlagBase >= 0xFF ||
+         !SceneflagManager::sInstance->checkBoolFlag(roomid, mOutputStateFlagBase + 1))) {
         if (mOffEventId != 0xFF) {
             {
                 // this works but I don't like it
@@ -115,8 +107,8 @@ void dTgShipWindow_c::executeState_On() {
     }
 
     if ((mHasPlayedOnEvent == 0 || mAlwaysPlayEvent == 0) &&
-        (mOutputStateFlagBase >= 0xFF || !SceneflagManager::sInstance->checkBoolFlag(roomid, mOutputStateFlagBase + 2)
-        )) {
+        (mOutputStateFlagBase >= 0xFF ||
+         !SceneflagManager::sInstance->checkBoolFlag(roomid, mOutputStateFlagBase + 2))) {
         if (mOnEventId != 0xFF) {
             {
                 // this works but I don't like it
diff --git a/src/REL/d/t/d_t_sw_area.cpp b/src/REL/d/t/d_t_sw_area.cpp
index 90d96210..52f8c20d 100644
--- a/src/REL/d/t/d_t_sw_area.cpp
+++ b/src/REL/d/t/d_t_sw_area.cpp
@@ -1,19 +1,12 @@
 #include "d/t/d_t_sw_area.h"
+
 #include "d/a/d_a_player.h"
-#include "toBeSorted/area_math.h"
 #include "d/flag/sceneflag_manager.h"
 #include "d/flag/storyflag_manager.h"
+#include "toBeSorted/area_math.h"
 
 SPECIAL_ACTOR_PROFILE(SW_AREA_TAG, dTgSwArea_c, fProfile::SW_AREA_TAG, 0x292, 0, 0);
 
-// sDefaultRotX got placed in .data despite being zero.
-// There is a handy pragma for this but it's probably not
-// the correct solution.
-#pragma explicit_zero_data on
-u32 dTgSwArea_c::sDefaultRotX = 0;
-u32 dTgSwArea_c::sDefaultRotZ = 0;
-#pragma explicit_zero_data off
-
 int dTgSwArea_c::create() {
     setSceneflag = getSetSceneflag();
     unsetSceneflag = getUnsetSceneflag();
@@ -21,8 +14,8 @@ int dTgSwArea_c::create() {
 
     setStoryflag = getSetStoryflag();
     unsetStoryflag = getUnsetStoryflag();
-    rotation.x = sDefaultRotX;
-    rotation.z = sDefaultRotZ;
+    rotation.x = 0;
+    rotation.z = 0;
 
     matrixCreateFromPosRotYScale(area, position, rotation.y, mScale, nullptr, 0.0f);
     return SUCCEEDED;
diff --git a/src/d/a/d_a_base.cpp b/src/d/a/d_a_base.cpp
index 10272512..ecf7193f 100644
--- a/src/d/a/d_a_base.cpp
+++ b/src/d/a/d_a_base.cpp
@@ -12,8 +12,10 @@
 #include "d/d_stage.h"
 #include "d/flag/enemyflag_manager.h"
 #include "egg/core/eggAllocator.h"
+#include "egg/math/eggMath.h"
 #include "f/f_base.h"
 #include "f/f_list_nd.h"
+#include "m/m_angle.h"
 #include "m/m_vec.h"
 #include "toBeSorted/event.h"
 #include "toBeSorted/event_manager.h"
@@ -359,13 +361,15 @@ dAcBase_c *dAcBase_c::findActor(char *objName, dAcBase_c *parent) {
 // searches for actor based on groupType
 // 8002d0a0
 FORCE_INLINE dAcBase_c *findActor(dAcBase_c *parent) {
+    dAcBase_c *foundActor;
     if (!parent) {
-        return (dAcBase_c *)fManager_c::searchBaseByGroupType(2, nullptr);
-    }
-    if (parent->group_type == 2) {
-        return (dAcBase_c *)fManager_c::searchBaseByGroupType(2, parent);
+        foundActor = (dAcBase_c *)fManager_c::searchBaseByGroupType(dBase_c::ACTOR, nullptr);
+    } else if (parent->group_type == 2) {
+        foundActor = (dAcBase_c *)fManager_c::searchBaseByGroupType(dBase_c::ACTOR, parent);
+    } else {
+        foundActor = nullptr;
     }
-    return nullptr;
+    return foundActor;
 }
 
 // control flow sucks ;-;
@@ -374,11 +378,7 @@ FORCE_INLINE dAcBase_c *findActor(dAcBase_c *parent) {
 dAcBase_c *dAcBase_c::searchActor(dAcBase_c *parent) {
     dAcBase_c *foundActor = ::findActor(parent);
 
-    if (!foundActor) {
-        return (dAcBase_c *)fManager_c::searchBaseByGroupType(STAGE, parent);
-    }
-
-    return foundActor;
+    return foundActor ? foundActor : (dAcBase_c *)fManager_c::searchBaseByGroupType(STAGE, parent);
 }
 
 // 8002d130
@@ -420,22 +420,21 @@ bool dAcBase_c::getDistanceToActor(dAcBase_c *actor, f32 distThresh, f32 *outDis
 bool dAcBase_c::getDistanceAndAngleToActor(
     dAcBase_c *actor, f32 distThresh, s16 yAngle, s16 xAngle, f32 *outDist, s16 *outDiffAngleY, s16 *outDiffAngleX
 ) {
-    f32 distSquared = 3.402823e+38f;
-    s32 angleToActorY, angleToActorX;
+    f32 distSquared = EGG::Math<f32>::epsilon();
     bool isWithinRange = false;
 
-    angleToActorY = 0;
-    angleToActorX = 0;
+    mAng angleToActorY(0), angleToActorX(0);
 
     if (actor != nullptr) {
         distSquared = PSVECSquareDistance(position, actor->position);
-        angleToActorY = cLib::targetAngleY(position, actor->position);
-        angleToActorX = cLib::targetAngleX(position, actor->position);
+        angleToActorY.set(cLib::targetAngleY(position, actor->position));
+        angleToActorX.set(cLib::targetAngleX(position, actor->position));
 
-        // These casts are nuts wild ^^'
-        if ((distSquared <= distThresh * distThresh) && (labs(s16(rotation.y.mVal - (s16)angleToActorY)) <= yAngle) &&
-            (labs(s16(rotation.x.mVal - (s16)angleToActorX)) <= xAngle)) {
-            isWithinRange = true;
+        if ((distSquared <= distThresh * distThresh)) {
+            if ((labs(mAng(rotation.y.diff(angleToActorY))) <= yAngle) &&
+                (labs(mAng(rotation.x.diff(angleToActorX))) <= xAngle)) {
+                isWithinRange = true;
+            }
         }
     }
 
@@ -513,7 +512,7 @@ void dAcBase_c::FUN_8002d7d0() {}
 void dAcBase_c::FUN_8002d7f0() {}
 void dAcBase_c::FUN_8002d810() {}
 void dAcBase_c::FUN_8002d830() {}
-void dAcBase_c::FUN_8002d860() {}
+void dAcBase_c::FUN_8002d860(UNKWORD) {}
 
 // 8002d880
 SoundSource *dAcBase_c::getSoundSource() {
diff --git a/src/d/a/d_a_insect.cpp b/src/d/a/d_a_insect.cpp
index 2c18e1ed..db7c66fb 100644
--- a/src/d/a/d_a_insect.cpp
+++ b/src/d/a/d_a_insect.cpp
@@ -17,8 +17,6 @@
 #include "toBeSorted/d_emitter.h"
 #include "toBeSorted/small_sound_mgr.h"
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_394_;
-
 void dAcOInsect_c::kill() {
     dJEffManager_c::spawnEffect(PARTICLE_RESOURCE_ID_MAPPING_394_, position, nullptr, nullptr, nullptr, nullptr, 0, 0);
     playSound(SE_Insect_DISAPPEAR);
diff --git a/src/d/a/obj/d_a_obj_switch.cpp b/src/d/a/obj/d_a_obj_switch.cpp
index 3bedebf6..f8145bbe 100644
--- a/src/d/a/obj/d_a_obj_switch.cpp
+++ b/src/d/a/obj/d_a_obj_switch.cpp
@@ -145,8 +145,6 @@ int dAcOsw_c::doDelete() {
     return SUCCEEDED;
 }
 
-extern "C" u16 PARTICLE_RESOURCE_ID_MAPPING_754_;
-
 int dAcOsw_c::actorExecute() {
     mStateMgr.executeState();
     if (mCanBeSeen) {
@@ -154,7 +152,9 @@ int dAcOsw_c::actorExecute() {
         if (field_0x5A0.field_0x00 <= 0.0f) {
             if (mScale.x >= 1.0f) {
                 if (!mHidden) {
-                    dJEffManager_c::spawnEffect(PARTICLE_RESOURCE_ID_MAPPING_754_, position, &rotation, nullptr, nullptr, nullptr, 0, 0);
+                    dJEffManager_c::spawnEffect(
+                        PARTICLE_RESOURCE_ID_MAPPING_754_, position, &rotation, nullptr, nullptr, nullptr, 0, 0
+                    );
                     playSound(SE_TIMESLIP_TIMESLIP_REV);
                     mHidden = true;
                 }
@@ -167,7 +167,9 @@ int dAcOsw_c::actorExecute() {
         } else {
             if (mScale.x <= 0.0f) {
                 if (!mShown) {
-                    dJEffManager_c::spawnEffect(PARTICLE_RESOURCE_ID_MAPPING_754_, position, &rotation, nullptr, nullptr, nullptr, 0, 0);
+                    dJEffManager_c::spawnEffect(
+                        PARTICLE_RESOURCE_ID_MAPPING_754_, position, &rotation, nullptr, nullptr, nullptr, 0, 0
+                    );
                     playSound(SE_TIMESLIP_TIMESLIP);
                     mShown = true;
                 }
diff --git a/src/d/a/obj/d_a_obj_tbox.cpp b/src/d/a/obj/d_a_obj_tbox.cpp
index 111ea6bf..6f63a834 100644
--- a/src/d/a/obj/d_a_obj_tbox.cpp
+++ b/src/d/a/obj/d_a_obj_tbox.cpp
@@ -17,6 +17,7 @@
 #include "d/flag/sceneflag_manager.h"
 #include "d/flag/storyflag_manager.h"
 #include "d/flag/tboxflag_manager.h"
+#include "d/t/d_t_siren.h"
 #include "m/m3d/m_fanm.h"
 #include "m/m3d/m_scnleaf.h"
 #include "m/m_mtx.h"
@@ -785,13 +786,9 @@ f32 dAcTbox_c::getSomeRate() {
 bool dAcTbox_c::isValidGroupIndex(int idx) {
     return 0 <= idx && idx < 15;
 }
-extern "C" void *SIREN_TAG;
-extern "C" bool hasCollectedAllTears(void *SIREN_TAG);
+
 bool dAcTbox_c::hasCollectedAllTears() {
-    if (SIREN_TAG == nullptr) {
-        return false;
-    }
-    return ::hasCollectedAllTears(SIREN_TAG);
+    return dTgSiren_c::hasCollectedAllTears();
 }
 
 bool dAcTbox_c::getGroundHeight(f32 *height, const mVec3_c &pos) {
@@ -945,9 +942,7 @@ bool dAcTbox_c::createHeap() {
         fn_8026B380(fxPos);
         mMtx_c fxTransform;
         fxTransform.transS(fxPos);
-        // TODO address calculations here, otherwise this function
-        // matches surprisingly well
-        fxTransform.ZXYrotM(rotation.x, rotation.y, rotation.z);
+        fxTransform.ZXYrotM(GetRotation());
         mOpenFxMdl.setLocalMtx(fxTransform);
         mOpenFxMdl.setScale(fn_8026B3C0());
     }
@@ -988,8 +983,8 @@ int dAcTbox_c::create() {
         case 3:  field_0x120A = 3; break;
         default: field_0x120A = 3; break;
     }
-    rotation.z = 0;
-    rotation.x = 0;
+    rotation.z.set(0);
+    rotation.x.set(0);
 
     // This part of the code checks if there's another chest with similar properties
     // and only keeps one of them.
@@ -1102,7 +1097,6 @@ int dAcTbox_c::create() {
         field_0x0D48.addCc(mCcD2, s4);
     }
     field_0x0D48.SetStts(mStts);
-    // TODO figure out the right fields
     mCcD1.SetTg_0x4C(-1);
     mCcD2.SetTg_0x4C(-1);
     mMdl1.setAnm(sAnmNames[mVariant], m3d::PLAY_MODE_4);
@@ -1151,14 +1145,13 @@ int dAcTbox_c::create() {
     field_0x11EC = 1.0f;
     field_0x11FC = 0;
 
-    field_0x4E8.r = 0;
-    field_0x4E8.g = 0;
-    field_0x4E8.b = 0;
+    mLightInfo.mClr.r = 0;
+    mLightInfo.mClr.g = 0;
+    mLightInfo.mClr.b = 0;
 
-    field_0x4EC = 0.0f;
-    field_0x4DC.x = position.x;
-    field_0x4DC.z = position.z;
-    field_0x4DC.y = position.y + 100.0f;
+    mLightInfo.SetScale(0.f);
+    mLightInfo.SetPosition(position);
+    mLightInfo.mPos.y += 100.0f;
 
     return SUCCEEDED;
 }
@@ -1933,7 +1926,6 @@ void dAcTbox_c::executeState_LoadArchive() {
 }
 void dAcTbox_c::finalizeState_LoadArchive() {}
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_209_;
 extern "C" const bool isPouchItem(u16);
 extern "C" dAcItem_c *giveItem3(u16 item, s32);
 
@@ -2239,22 +2231,22 @@ void dAcTbox_c::unsetShouldCloseFlag() {
 void dAcTbox_c::fn_8026D370() {
     if (isNotSmall()) {
         field_0x11F0 = 1;
-        BlurAndPaletteManager::GetInstance().fn_800223A0(&field_0x4DC);
+        BlurAndPaletteManager::GetInstance().fn_800223A0(&mLightInfo);
     }
 }
 
 void dAcTbox_c::fn_8026D3C0() {
     if (mAnmChr.isStop() && mAnmTexSrt1.isStop(0) && mAnmMatClr2.isStop(0)) {
         field_0x11F0 = 0;
-        BlurAndPaletteManager::GetInstance().fn_80022440(&field_0x4DC);
+        BlurAndPaletteManager::GetInstance().fn_80022440(&mLightInfo);
     } else {
         mAnmChr.play();
         mAnmTexSrt1.play();
         mAnmMatClr2.play();
-        field_0x4E8.r = 0xAA;
-        field_0x4E8.g = 0x96;
-        field_0x4E8.b = 0x96;
-        field_0x4EC = 125.0f;
+        mLightInfo.mClr.r = 0xAA;
+        mLightInfo.mClr.g = 0x96;
+        mLightInfo.mClr.b = 0x96;
+        mLightInfo.SetScale(125.0f);
     }
 }
 
@@ -2373,10 +2365,10 @@ void dAcTbox_c::unregisterDowsing() {
     }
 }
 
-extern "C" u16 PARTICLE_RESOURCE_ID_MAPPING_208_;
-
 void dAcTbox_c::spawnAppearEffect() {
-    dJEffManager_c::spawnEffect(PARTICLE_RESOURCE_ID_MAPPING_208_, position, &rotation, nullptr, nullptr, nullptr, 0, 0);
+    dJEffManager_c::spawnEffect(
+        PARTICLE_RESOURCE_ID_MAPPING_208_, position, &rotation, nullptr, nullptr, nullptr, 0, 0
+    );
 }
 
 bool dAcTbox_c::checkIsClear() const {
@@ -2393,17 +2385,26 @@ bool dAcTbox_c::checkIsClear() const {
         mVec3_c(-50.0f, 500.0f, -50.0f),
     };
     mVec3_c points[4];
+
+    mVec3_c *offs = offsets;
+    mVec3_c *pnt = points;
     for (u32 i = 0; i <= 3; i++) {
-        fn_8026DAD0(&offsets[i], &points[i]);
+        fn_8026DAD0(offs, pnt);
+        offs++;
+        pnt++;
     }
     static const int fsIdxes[] = {0, 0, 1, 1};
+
     bool isClear = true;
-    for (u32 i = 0; isClear && i <= 3;) {
+    u32 i = 0;
+    const int *idx = fsIdxes;
+    while (isClear && i <= 3) {
         // @bug should this be points[i] instead?
-        if (isBelowGroundAtPos(fs[fsIdxes[i]], points[0])) {
+        if (isBelowGroundAtPos(fs[*idx], points[0])) {
             isClear = false;
         } else {
             i++;
+            idx++;
         }
     }
 
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 b86b6f09..06dab84c 100644
--- a/src/d/a/obj/d_a_obj_water_spout.cpp
+++ b/src/d/a/obj/d_a_obj_water_spout.cpp
@@ -60,8 +60,6 @@ int dAcOwaterSpout_c::draw() {
     return SUCCEEDED;
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_213_;
-
 void dAcOwaterSpout_c::initializeState_Wait() {
     if (params == 1) {
         return;
diff --git a/src/d/col/c/c_m3d_g_pla.cpp b/src/d/col/c/c_m3d_g_pla.cpp
index 77baea9d..9a447434 100644
--- a/src/d/col/c/c_m3d_g_pla.cpp
+++ b/src/d/col/c/c_m3d_g_pla.cpp
@@ -30,10 +30,7 @@ bool cM3dGPla::getCrossYLessD(const mVec3_c &point, f32 *out) const {
 
 mAng cM3dGPla::GetAngle(mAng ang) const {
     mAng angleY = GetAngleY();
-
-    angleY = angleY - ang;
-
-    return cM::atan2s(GetXZDist() * angleY.cos(), mNormal.y);
+    return cM::atan2s(GetXZDist() * mAng(angleY - ang).cos(), mNormal.y);
 }
 
 mAng cM3dGPla::GetNegativeAngle(mAng ang) const {
diff --git a/src/d/d_cs_base.cpp b/src/d/d_cs_base.cpp
index fbd75427..8e2609ce 100644
--- a/src/d/d_cs_base.cpp
+++ b/src/d/d_cs_base.cpp
@@ -9,8 +9,16 @@
 SPECIAL_BASE_PROFILE(C_BASE, dCsBase_c, fProfile::C_BASE, 0x2C0, 0x06F9);
 
 dCsBase_c::dCsBase_c()
-    : mpCurrLyt(nullptr), field_0x6F0(0.0f), field_0x6F4(0.0f), field_0x6F8(0.0f), field_0x6FC(0.0f), field_0x700(0),
-      field_0x702(0), field_0x703(0), field_0x704(0), field_0x705(0) {
+    : mpCurrLyt(nullptr),
+      field_0x6F0(0.0f),
+      field_0x6F4(0.0f),
+      field_0x6F8(0.0f),
+      field_0x6FC(0.0f),
+      field_0x700(0),
+      field_0x702(0),
+      field_0x703(0),
+      field_0x704(0),
+      field_0x705(0) {
     sInstance = this;
 }
 
@@ -28,10 +36,6 @@ static const char *sLytNames[] = {
     "P1_Cat.brlyt",
 };
 
-#pragma explicit_zero_data on
-int dCsBase_c::sfield0x700Init = 0;
-#pragma explicit_zero_data off
-
 int dCsBase_c::create() {
     void *data = LayoutArcManager::GetInstance()->getLoadedData("cursor");
     mResAcc.attach(data, "arc");
@@ -51,7 +55,7 @@ int dCsBase_c::create() {
     field_0x6F8 = 0.0f;
     field_0x6FC = 0.0f;
 
-    field_0x700 = sfield0x700Init;
+    field_0x700 = 0;
     field_0x702 = 0;
     field_0x703 = 0;
 
diff --git a/src/d/lyt/meter/d_lyt_meter_dowsing.cpp b/src/d/lyt/meter/d_lyt_meter_dowsing.cpp
index f7850755..ca57a874 100644
--- a/src/d/lyt/meter/d_lyt_meter_dowsing.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_dowsing.cpp
@@ -14,8 +14,8 @@
 #include "nw4r/lyt/lyt_group.h"
 #include "nw4r/math/math_types.h"
 #include "sized_string.h"
-#include "toBeSorted/dowsing_target.h"
 #include "toBeSorted/d_emitter.h"
+#include "toBeSorted/dowsing_target.h"
 #include "toBeSorted/file_manager.h"
 #include "toBeSorted/small_sound_mgr.h"
 
@@ -395,16 +395,14 @@ void dLytMeterDowsing_c::executeState_Wait() {
         mStateMgr.changeState(StateID_DemoMove);
     } else if (field_0x5505 != 0) {
         mStateMgr.changeState(StateID_MenuSelectingIn);
-    } else if (field_0x550A != 0 &&
-               (!dLytMeter_c::GetMain()->fn_800D5380(0) || dLytMeter_c::GetMain()->fn_800D5650() ||
-                dLytMeter_c::GetMain()->fn_800D5680())) {
+    } else if (field_0x550A != 0 && (!dLytMeter_c::GetMain()->fn_800D5380(0) || dLytMeter_c::GetMain()->fn_800D5650() ||
+                                     dLytMeter_c::GetMain()->fn_800D5680())) {
         mStateMgr.changeState(StateID_Reset);
     } else if (!dLytMeter_c::GetInstance()->checkAllFlags(METER_BTN_C)) {
         mStateMgr.changeState(StateID_ToUnuse);
     } else if (dLytMeter_c::GetInstance()->getMeterField_0x1377F() != 0 && field_0x550A == 0 &&
                dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->fn_800D5650() &&
-               !dLytMeter_c::GetMain()->fn_800D5680() &&
-               getSelectedDowsingSlot() != DowsingTarget::SLOT_LOOK &&
+               !dLytMeter_c::GetMain()->fn_800D5680() && getSelectedDowsingSlot() != DowsingTarget::SLOT_LOOK &&
                getSelectedDowsingSlot() != DowsingTarget::SLOT_NONE &&
                LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52) {
         mAnm[DOWSING_ANIM_IN].setBackwardsOnce();
@@ -553,9 +551,8 @@ void dLytMeterDowsing_c::initializeState_ToUse() {
     mAnm[DOWSING_ANIM_INPUT_0].setAnimEnable(true);
 
     if (FileManager::GetInstance()->getDowsingSlotIdx() != 8 &&
-        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 &&
-        dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->fn_800D5650() &&
-        !dLytMeter_c::GetMain()->fn_800D5680()) {
+        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 && dLytMeter_c::GetMain()->fn_800D5380(0) &&
+        !dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680()) {
         mAnm[DOWSING_ANIM_RESET].setAnimEnable(true);
         mAnm[DOWSING_ANIM_RESET].setBackwardsOnce();
         mAnm[DOWSING_ANIM_RESET].setToStart();
@@ -563,9 +560,8 @@ void dLytMeterDowsing_c::initializeState_ToUse() {
 }
 void dLytMeterDowsing_c::executeState_ToUse() {
     if (FileManager::GetInstance()->getDowsingSlotIdx() != 8 &&
-        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 &&
-        dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->fn_800D5650() &&
-        !dLytMeter_c::GetMain()->fn_800D5680()) {
+        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 && dLytMeter_c::GetMain()->fn_800D5380(0) &&
+        !dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680()) {
         if (mAnm[DOWSING_ANIM_INPUT_0].isStop2()) {
             if (!mAnm[DOWSING_ANIM_RESET].isEnabled() || mAnm[DOWSING_ANIM_RESET].isStop2()) {
                 mStateMgr.changeState(StateID_Wait);
@@ -598,9 +594,8 @@ void dLytMeterDowsing_c::initializeState_ToUnuse() {
     mAnm[DOWSING_ANIM_INPUT_0].setAnimEnable(true);
 
     if (FileManager::GetInstance()->getDowsingSlotIdx() != 8 &&
-        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 &&
-        dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->fn_800D5650() &&
-        !dLytMeter_c::GetMain()->fn_800D5680()) {
+        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 && dLytMeter_c::GetMain()->fn_800D5380(0) &&
+        !dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680()) {
         mAnm[DOWSING_ANIM_RESET].setAnimEnable(true);
         mAnm[DOWSING_ANIM_RESET].setForwardOnce();
         mAnm[DOWSING_ANIM_RESET].setToStart();
@@ -636,8 +631,7 @@ void dLytMeterDowsing_c::executeState_Unuse() {
         mLyt.calc();
         mAnm[DOWSING_ANIM_INPUT_0].setAnimEnable(false);
         mStateMgr.changeState(StateID_DemoMove);
-    } else if (!dLytMeter_c::GetMain()->fn_800D5680() &&
-               dLytMeter_c::GetInstance()->getMeterField_0x13774() == 0 &&
+    } else if (!dLytMeter_c::GetMain()->fn_800D5680() && dLytMeter_c::GetInstance()->getMeterField_0x13774() == 0 &&
                dLytMeter_c::GetInstance()->checkAllFlags(METER_BTN_C)) {
         if (field_0x54D8 <= 0) {
             mStateMgr.changeState(StateID_ToUse);
@@ -707,7 +701,7 @@ void dLytMeterDowsing_c::initializeState_DemoMove() {
         mAnm[i + DOWSING_ANIM_ITEM_ONOFF_OFFSET].setAnimEnable(false);
     }
 }
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_970_;
+
 void dLytMeterDowsing_c::executeState_DemoMove() {
     mDemoFrame++;
     if (mDemoFrame == 15) {
@@ -1015,8 +1009,7 @@ bool dLytMeterDowsing_c::execute() {
         }
         if (mAnm[DOWSING_ANIM_CALL].isEnabled()) {
             mAnm[DOWSING_ANIM_CALL].play();
-            if (dLytMeter_c::GetInstance()->checkAllFlags(METER_BTN_C) &&
-                mAnm[DOWSING_ANIM_CALL].getFrame() == 1.0f) {
+            if (dLytMeter_c::GetInstance()->checkAllFlags(METER_BTN_C) && mAnm[DOWSING_ANIM_CALL].getFrame() == 1.0f) {
                 SmallSoundManager::GetInstance()->playSound(SE_S_C_BUTTON_BLINK);
             }
         }
@@ -1119,9 +1112,8 @@ void dLytMeterDowsing_c::fn_800FE110() {
 
 void dLytMeterDowsing_c::fn_800FE220() {
     if (getSelectedDowsingSlot() != DowsingTarget::SLOT_NONE &&
-        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 &&
-        dLytMeter_c::GetMain()->fn_800D5380(0) && !dLytMeter_c::GetMain()->fn_800D5650() &&
-        !dLytMeter_c::GetMain()->fn_800D5680()) {
+        LytDoButtonRelated::get(LytDoButtonRelated::DO_BUTTON_C) == 0x52 && dLytMeter_c::GetMain()->fn_800D5380(0) &&
+        !dLytMeter_c::GetMain()->fn_800D5650() && !dLytMeter_c::GetMain()->fn_800D5680()) {
         mAnm[DOWSING_ANIM_RESET].setAnimEnable(true);
         mAnm[DOWSING_ANIM_RESET].setForwardOnce();
         mAnm[DOWSING_ANIM_RESET].setToStart();
diff --git a/src/d/lyt/meter/d_lyt_meter_heart.cpp b/src/d/lyt/meter/d_lyt_meter_heart.cpp
index 7ee24c48..96b685c2 100644
--- a/src/d/lyt/meter/d_lyt_meter_heart.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_heart.cpp
@@ -282,7 +282,7 @@ void dLytMeterHeart_c::realizeHeartsState() {
         }
     }
 }
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_972_;
+
 void dLytMeterHeart_c::executeInternal() {
     if (mEffectHeartIdx >= 0) {
         nw4r::math::MTX34 mtx = mpHeartPanes[mEffectHeartIdx]->GetGlobalMtx();
diff --git a/src/d/lyt/meter/d_lyt_meter_item_select.cpp b/src/d/lyt/meter/d_lyt_meter_item_select.cpp
index 7055a566..701d7649 100644
--- a/src/d/lyt/meter/d_lyt_meter_item_select.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_item_select.cpp
@@ -1393,7 +1393,7 @@ void dLytMeterItemSelect_c::initializeState_DemoMove() {
 
     SmallSoundManager::GetInstance()->playSound(SE_S_GET_ITEM_SET);
 }
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_740_;
+
 void dLytMeterItemSelect_c::executeState_DemoMove() {
     mDemoMoveTimer++;
     if (mDemoMoveTimer == 15) {
@@ -1410,7 +1410,9 @@ void dLytMeterItemSelect_c::executeState_DemoMove() {
 
                 nw4r::math::MTX34 mtx = mpPanes[i + ITEM_SELECT_PANE_ICON_OFFSET]->GetGlobalMtx();
                 mVec3_c pos(mtx._03, mtx._13, 0.0f);
-                dJEffManager_c::spawnUIEffect(PARTICLE_RESOURCE_ID_MAPPING_740_, pos, nullptr, nullptr, nullptr, nullptr);
+                dJEffManager_c::spawnUIEffect(
+                    PARTICLE_RESOURCE_ID_MAPPING_740_, pos, nullptr, nullptr, nullptr, nullptr
+                );
 
                 if (mIsBocoburinLocked[i]) {
                     mIsBocoburinLocked[i] = false;
@@ -2237,7 +2239,6 @@ bool dLytMeterItemSelect_c::execute() {
     return true;
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_717_;
 void dLytMeterItemSelect_c::fn_800EF580() {
     nw4r::math::MTX34 mtx = mpPanes[11]->GetGlobalMtx();
     mVec3_c pos(mtx._03, mtx._13, 0.0f);
@@ -2481,8 +2482,7 @@ bool dLytMeterItemSelect_c::fn_800F0030() const {
     if (!StoryflagManager::sInstance->getCounterOrFlag(58) &&
             !(EventManager::isInEvent() && EventManager::isCurrentEvent("ItemGetGorgeous")) ||
         (mpOwnerPane == nullptr || !mpOwnerPane->IsVisible() || dLytMeter_c::GetMain()->fn_800D5650() ||
-         dLytMeter_c::GetMain()->fn_800D5680() ||
-         !dLytMeter_c::GetMain()->getItemSelectNotHiddenByAreaCaption())) {
+         dLytMeter_c::GetMain()->fn_800D5680() || !dLytMeter_c::GetMain()->getItemSelectNotHiddenByAreaCaption())) {
         // If we don't have a B-Wheel and we're not currently in the ItemGetGorgeous event,
         // or (random other conditions), return false
         return false;
diff --git a/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp b/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp
index b1f600fd..9b3147dd 100644
--- a/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_minus_btn.cpp
@@ -7,6 +7,7 @@
 #include "d/lyt/d_lyt_control_game.h"
 #include "d/lyt/d_lyt_util_items.h"
 #include "d/lyt/meter/d_lyt_meter.h"
+#include "m/m_angle.h"
 #include "nw4r/lyt/lyt_group.h"
 #include "nw4r/math/math_types.h"
 #include "sized_string.h"
@@ -520,7 +521,7 @@ void dLytMeterMinusBtn_c::executeState_Unuse() {
     }
 }
 void dLytMeterMinusBtn_c::finalizeState_Unuse() {}
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_971_;
+
 void dLytMeterMinusBtn_c::initializeState_DemoMove() {
     mDemoFrame = 0;
     mSlotToDemo = -1;
@@ -767,7 +768,7 @@ bool dLytMeterMinusBtn_c::build(d2d::ResAccIf_c *resAcc) {
     }
 
     for (s32 i = 0; i < 4; i++) {
-        mEffectsRot[i].setR(0);
+        mEffectsRot[i] = 0;
         mSlotForEffect[i] = -1;
         mEffects[i].init(dLytControlGame_c::getInstance());
     }
@@ -1004,7 +1005,7 @@ bool dLytMeterMinusBtn_c::demoRelated(s32 arg) {
         field_0x4E8C = arg;
         mDemoFrame = 0;
         for (s32 i = 0; i < 4; i++) {
-            mEffectsRot[i].setR(0);
+            mEffectsRot[i].set(0);
             mSlotForEffect[i] = -1;
         }
         mArrowRotation = 0.0f;
@@ -1038,8 +1039,7 @@ bool dLytMeterMinusBtn_c::fn_800F7600() const {
 bool dLytMeterMinusBtn_c::fn_800F7760() const {
     if (!StoryflagManager::sInstance->getCounterOrFlag(30) ||
         (mpOwnerPane == nullptr || !mpOwnerPane->IsVisible() || dLytMeter_c::GetMain()->fn_800D5650() ||
-         dLytMeter_c::GetMain()->fn_800D5680() ||
-         !dLytMeter_c::GetMain()->getMinusBtnNotHiddenByAreaCaption())) {
+         dLytMeter_c::GetMain()->fn_800D5680() || !dLytMeter_c::GetMain()->getMinusBtnNotHiddenByAreaCaption())) {
         return false;
     }
 
diff --git a/src/d/lyt/meter/d_lyt_meter_timer.cpp b/src/d/lyt/meter/d_lyt_meter_timer.cpp
index 085479cf..8362c7f7 100644
--- a/src/d/lyt/meter/d_lyt_meter_timer.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_timer.cpp
@@ -382,9 +382,6 @@ void LytMeterTimerPart1_c::initColors() {
     }
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_135_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_136_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_137_;
 void LytMeterTimerPart1_c::createEffect(s32 fruitIndex) {
     nw4r::math::MTX34 mtx = mpPanes[fruitIndex]->GetGlobalMtx();
     mVec3_c pos;
@@ -993,7 +990,6 @@ void LytMeterTimerPart2_c::initColors() {
     }
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_174_;
 void LytMeterTimerPart2_c::createSingleFruitEffect() {
     nw4r::math::MTX34 mtx = mpPane->GetGlobalMtx();
     mVec3_c pos;
@@ -1005,7 +1001,7 @@ void LytMeterTimerPart2_c::createSingleFruitEffect() {
         &mColors2[TIMER_02_COLOR_01_00]
     );
 }
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_206_;
+
 void LytMeterTimerPart2_c::createFruitCompleteEffect() {
     nw4r::math::MTX34 mtx = mpPane->GetGlobalMtx();
     mVec3_c pos;
diff --git a/src/m/m_angle.cpp b/src/m/m_angle.cpp
index fe53b0c1..ab60e415 100644
--- a/src/m/m_angle.cpp
+++ b/src/m/m_angle.cpp
@@ -3,7 +3,7 @@
 #include "math.h"
 
 /** 80575c08 */
-mAng3_c mAng3_c::Zero = mAng3_c(0, 0, 0);
+mAng3_c mAng3_c::Zero(0, 0, 0);
 
 const f32 mAng::sHalfCircleDeg = 360.0f / 2;
 const f32 mAng::sAngToDeg = 360.0f / (1 << 16);
diff --git a/src/toBeSorted/attention.cpp b/src/toBeSorted/attention.cpp
index 69492d38..d7b17d1f 100644
--- a/src/toBeSorted/attention.cpp
+++ b/src/toBeSorted/attention.cpp
@@ -418,8 +418,8 @@ void AttentionGroup::fn_800964B0() {
 extern "C" f32 lbl_8057CD9C;
 
 f32 AttentionManager::targetScore(dAcObjBase_c *target, dAcObjBase_c *origin) {
-    s32 angle = cLib::targetAngleY(target->position, origin->position);
-    f32 viewAngle = fabsf(lbl_8057CD9C * (s16)(angle - origin->rotation.y.mVal));
+    s16 angle = cLib::targetAngleY(target->position, origin->position) - origin->rotation.y.mVal;
+    f32 viewAngle = fabsf(angle * lbl_8057CD9C);
     if (viewAngle > 0.5f) {
         return viewAngle;
     }
diff --git a/src/toBeSorted/d_emitter.cpp b/src/toBeSorted/d_emitter.cpp
index e003f3e3..f4d133ee 100644
--- a/src/toBeSorted/d_emitter.cpp
+++ b/src/toBeSorted/d_emitter.cpp
@@ -701,7 +701,6 @@ void dMassObjEmitter_c::remove() {
 }
 
 extern "C" u32 sNumMassObjEmitters; // should be const?
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_119_;
 extern "C" dMassObjEmitter_c *CURRENT_EFFECT_MANAGER_INIT;
 
 const u32 dJEffManager_c::moreInts[] = {3, 5, 7, 8, 12, 13, 14, 1, 9, 11};
@@ -1206,18 +1205,6 @@ s32 dJEffManager_c::polyAttrsToGroundEffectIdx(s32 polyAttr0, s32 polyAttr1) {
     return result;
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_89_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_90_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_87_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_88_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_429_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_416_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_417_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_418_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_419_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_893_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_894_;
-
 dEmitterBase_c *dJEffManager_c::spawnGroundEffect(
     const mVec3_c &pos, u8 polyAttr0, u8 polyAttr1, const mVec3_c &v1, s32 unk, f32 scale, f32 groundHeightMaybe
 ) {
@@ -1262,8 +1249,6 @@ void dWaterEffect_c::init(dAcObjBase_c *base, f32 height, f32 scale, f32 f3) {
     mDepth = f3;
 }
 
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_91_;
-extern "C" const u16 PARTICLE_RESOURCE_ID_MAPPING_127_;
 void dWaterEffect_c::execute(f32 water, f32 ground) {
     dAcObjBase_c *ac = getActor();
     bool b = getActorGroundPos(ac) < water && ground < water;