From a045e898ed25bcb19435aeb98ac22f38cc24fcb9 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 03:49:06 +0100 Subject: [PATCH 01/21] Update StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 318 ++++++++++++++++++++++++++++++- 1 file changed, 317 insertions(+), 1 deletion(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index e7ca6be6a..8cb734236 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -1,5 +1,321 @@ #include "Game/Enemy/StinkBugSmall.hpp" +#include "Game/Enemy/StinkBugBase.hpp" +#include "Game/Enemy/WalkerStateBindStarPointer.hpp" +#include "Game/LiveActor/HitSensor.hpp" +#include "Game/LiveActor/LiveActor.hpp" +#include "Game/Util/ActorMovementUtil.hpp" +#include "Game/Util/ActorSensorUtil.hpp" +#include "Game/Util/ActorStateUtil.hpp" +#include "Game/Util/ActorSwitchUtil.hpp" +#include "Game/Util/EffectUtil.hpp" +#include "Game/Util/LiveActorUtil.hpp" +#include "Game/Util/MathUtil.hpp" +#include "Game/Util/ObjUtil.hpp" +#include "Game/Util/PlayerUtil.hpp" +#include "Game/Util/SoundUtil.hpp" +#include +#include +#include -StinkBugSmall::StinkBugSmall(const char* pName) : StinkBugBase(pName) {} +StinkBugSmall::StinkBugSmall(const char* pName) : StinkBugBase(pName), + mScaleController(nullptr), mBindStarPointer(nullptr), + mStateBaseInterface(nullptr) {} StinkBugSmall::~StinkBugSmall() {} +s32 StinkBugSmall::tryForceFall(){ + const LiveActor* pActor = this; + if(!MR::isValidSwitchA(pActor) || !MR::isOnSwitchA(pActor)){ + return 0; + } + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)){ + return 0; + } + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)){ + return 0; + } + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance); + return 1; +} + +s32 StinkBugSmall::tryDPDSwoon(){ + const LiveActor* pActor = this; + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ + return 0; + } + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)){ + return 0; + } + + if(!mBindStarPointer->tryStartPointBind()){ + return 0; + } + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance); + return 1; +} + +s32 StinkBugSmall::isShakeChance() const { + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ + return 0; + } + if(!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance)){ + return 0; + } + if(MR::isPlayerHipDropFalling()){ + return 0; + } + return MR::isPlayerHipDropLand() == 0; +} + +void StinkBugSmall::kill(){ + if(MR::isValidSwitchDead(this)){ + MR::onSwitchDead(this); + } + if(!MR::isValidSwitchDead(this)){ + MR::appearStarPiece(this, this->mPosition, 3, 10.0f, 40.0f, 0); + MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1); + } + MR::emitEffect(this, "Death"); + MR::startSound(this, "SE_EM_EXPLODE_S", -1, -1); + LiveActor::kill(); +} + +bool StinkBugSmall::exeHipDropDown(){ + if (MR::isFirstStep(this)){ + MR::startBck(this, "Death", 0); + MR::startBrk(this, "Death"); + if(!unk196){ + MR::invalidateCollisionParts(this); + } + MR::invalidateHitSensors(this); + MR::invalidateClipping(this); + MR::startSound(this, "SE_EM_STOMPED_S", -1, -1); + MR::startSound(this, "SE_EV_STINKBUG_S_STOMPED", -1, -1); + } + this->mVelocity.zero(); + bool result = MR::isBckStopped(this); + if(result){ + return this->exeHipDropDown(); + } + else{ + return result; + } + return result; +} + +s32 StinkBugSmall::isNrvEnableStarPieceAttack() const { + bool Inerves = LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + if(Inerves){ + return 1; + } + return 0; +} + +bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pReceiver, HitSensor* pSender){ + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ + return false; + } + if(MR::isPlayerElementModeInvincible() && (MR::isMsgFloorTouch(msg) || MR::isMsgWallTouch(msg) || MR::isMsgCeilTouch(msg))){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + return true; + } + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)){ + return false; + } + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)){ + return false; + } + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)){ + return false; + } + { + if(MR::isMsgFloorTouch(msg)) { + if(MR::isOnPlayer(LiveActor::getSensor("body"))){ + if(StinkBugSmall::isShakeChance()){ + MR::sendMsgEnemyAttackFlip(pReceiver, pSender); + } + else { + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); + return true; + } + } + } + } + return false; +} + +bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pReceiver, HitSensor* pSender){ + if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ + return false; + } + if(LiveActor::getSensor("body")){ + return false; + } + if(MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + return true; + } + else if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { + if(MR::isMsgStarPieceReflect(msg) && LiveActor::getSensor("body")){ + if(StinkBugSmall::isNrvEnableStarPieceAttack()){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + return true; + } + } + if(!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && + !LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && + MR::isMsgPlayerSpinAttack(msg) && + LiveActor::getSensor("body")){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + return true; + } + } + return false; +} + + +void StinkBugSmall::exeWait(){ + if(MR::isFirstStep(this) && this->mScale.x != 0.0f){ + MR::tryStartBck(this, "Search", 0); + } + StinkBugBase::fixInitPos(); + if(StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); + } + else if(this->mScale.x != 0.0f){ + if(MR::isGreaterStep(this, 1)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance); + } + } +} +void StinkBugSmall::exeSearch(){ + if(MR::isFirstStep(this)){ + MR::tryStartBck(this, "Search", 0); + } + StinkBugBase::fixInitPos(); + if(StinkBugBase::tryTurnSearch(1.0)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); + } + else if (StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)) { + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); + } +} +void StinkBugSmall::exeDashSign(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "RushStart", 0); + MR::startSound(this, "SE_EV_STINKBUG_S_FIND", -1, -1); + } + MR::startLevelSound(this, "SE_EM_STINKBUG_S_DASH_SIGN", -1, -1, -1); + StinkBugBase::fixInitPos(); + StinkBugBase::tryTurnDashSign(3.0f); + if(MR::isBckStopped(this)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance); + } +} +void StinkBugSmall::exeDash(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "Rush", 0); + MR::validateHitSensors(this); + } + MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_DASH", -1, -1, -1); + if(MR::isNear(this, this->mPosition, this->mScale.y) && !MR::isBindedWall(this)){ + return StinkBugBase::setDashVelocity(20.0f); + } + this->mVelocity.zero(); + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashEnd::sInstance); + return MR::startSound(this, "SE_EM_STINKBUG_S_DASH_END", -1, -1); +} +void StinkBugSmall::exeDashEnd(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "RushStop", 0); + } + this->mVelocity.zero(); + if(MR::isBckStopped(this)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + } +} +void StinkBugSmall::exeBack(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "Back", 0); + MR::invalidateHitSensor(this, "head"); + } + MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_BACK", -1, -1, -1); + if(MR::isNear(this, this->mPosition, 10.0f)){ + return LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); + } + TVec3f tvf; + MR::normalize(&tvf); + MR::turnVecToPlane(&tvf, tvf, this->mGravity); + this->mVelocity.scale(5.0); +} +void StinkBugSmall::exeAttack(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "Attack", 0); + } + this->mVelocity.zero(); + if(MR::isBckStopped(this)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + } +} +void StinkBugSmall::exeSpinReaction(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "SpinAction", 0); + } + MR::startSound(this, "SE_EM_GUARD_S", -1, -1); + this->mVelocity.zero(); + if(MR::isBckStopped(this)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + } +} +void StinkBugSmall::exeShakeStart(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "repel", 0); + } + if(MR::isStep(this, 40)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance); + } +} +void StinkBugSmall::exePanic(){ + if(MR::isFirstStep(this)){ + MR::startBck(this, "Loss", 0); + MR::invalidateHitSensor(this, "head"); + } + MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, 15); + MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, -1); + this->mVelocity.zero(); + if(MR::isOnPlayer(LiveActor::getSensor("body"))){ + if(MR::isStep(this, 90)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance); + } + } + else { + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvRecover::sInstance); + } +} +void StinkBugSmall::exeRecover(){ + this->mVelocity.zero(); + MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_PANID", -1, -1, -1); + if(MR::isStep(this, 60)){ + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + } +} +void StinkBugSmall::exeDPDSwoon(){ + if(MR::isFirstStep(this)){ + MR::deleteEffectAll(this); + } + if(MR::isEffectValid(this, "RushSmoke")){ + MR::deleteEffect(this, "RushSmoke"); + } + MR::updateActorStateAndNextNerve(this, mStateBaseInterface, &NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); +} +void StinkBugSmall::exeForceFall(){ + if(MR::isFirstStep(this)){ + this->mVelocity.zero(); + MR::calcGravity(this); + MR::onBind(this); + } + JMAVECScaleAdd(this->mGravity, this->mVelocity, this->mVelocity, 2.0f); +} From 49312851954f7943bb18440b9eb6ab12f64c0885 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 03:51:59 +0100 Subject: [PATCH 02/21] Update StinkBugSmall.hpp --- include/Game/Enemy/StinkBugSmall.hpp | 63 ++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 4 deletions(-) diff --git a/include/Game/Enemy/StinkBugSmall.hpp b/include/Game/Enemy/StinkBugSmall.hpp index c528a3691..96ce7d2bc 100644 --- a/include/Game/Enemy/StinkBugSmall.hpp +++ b/include/Game/Enemy/StinkBugSmall.hpp @@ -1,14 +1,69 @@ #pragma once -#include "Game/NameObj/NameObj.hpp" +#include "Game/Enemy/AnimScaleController.hpp" +#include "Game/Enemy/WalkerStateBindStarPointer.hpp" +#include "Game/LiveActor/ActorStateBase.hpp" +#include "Game/LiveActor/HitSensor.hpp" +#include "Game/LiveActor/Nerve.hpp" #include "Game/Enemy/StinkBugBase.hpp" +#include "Game/Util/JMapInfo.hpp" +#include "revolution/types.h" +#include class StinkBugSmall : public StinkBugBase { public: StinkBugSmall(const char*); virtual ~StinkBugSmall(); - -private: - u8 mPad[(0xC8) - sizeof(StinkBugBase)]; + virtual void init(const JMapInfoIter& rIter); + virtual s32 tryDPDSwoon(); + virtual s32 tryForceFall(); + virtual s32 isShakeChance() const; + virtual s32 isNrvEnableStarPieceAttack() const; + virtual bool receiveMsgPlayerAttack(u32 msg, HitSensor* pReceiver, HitSensor* pSender); + virtual bool receiveOtherMsg(u32 msg, HitSensor* pReceiver, HitSensor* pSender); + virtual void attackSensor(HitSensor* mSensor, HitSensor* mSensor2); + virtual void calcAndSetBaseMtx(); + virtual void initAfterPlacement(); + virtual void kill(); + virtual void control(); + void exeWait(); + void exeSearch(); + void exeDashSign(); + void exeDash(); + void exeDashEnd(); + void exeBack(); + bool exeHipDropDown(); + void exeAttack(); + void exeSpinReaction(); + void exeShakeStart(); + void exePanic(); + void exeRecover(); + void exeDPDSwoon(); + void exeForceFall(); + void exeShake(); + void exeDashSignEnd(); + /* Offset 188 */ AnimScaleController *mScaleController; + /* Offset 192 */ ActorStateBaseInterface *mStateBaseInterface; + /* Offset 196 */ bool unk196; + /* Offset 200 */ WalkerStateBindStarPointer *mBindStarPointer; }; + +namespace NrvStinkBugSmall { + NEW_NERVE(StinkBugSmallNrvWait, StinkBugSmall, Wait); + NEW_NERVE(StinkBugSmallNrvSearch, StinkBugSmall, Search); + NEW_NERVE(StinkBugSmallNrvDashSign, StinkBugSmall, DashSign); + NEW_NERVE(StinkBugSmallNrvDashSignEnd, StinkBugSmall, DashSignEnd); + NEW_NERVE(StinkBugSmallNrvDash, StinkBugSmall, Dash); + NEW_NERVE(StinkBugSmallNrvDashEnd, StinkBugSmall, DashEnd); + NEW_NERVE(StinkBugSmallNrvBack, StinkBugSmall, Back); + NEW_NERVE(StinkBugSmallNrvHipDropDown, StinkBugSmall, HipDropDown); + NEW_NERVE(StinkBugSmallNrvAttack, StinkBugSmall, Attack); + NEW_NERVE(StinkBugSmallNrvSpinReaction, StinkBugSmall, SpinReaction); + NEW_NERVE(StinkBugSmallNrvShakeStart, StinkBugSmall, ShakeStart); + NEW_NERVE(StinkBugSmallNrvShake, StinkBugSmall, Shake); + NEW_NERVE(StinkBugSmallNrvPanic, StinkBugSmall, Panic); + NEW_NERVE(StinkBugSmallNrvRecover, StinkBugSmall, Recover); + NEW_NERVE(StinkBugSmallNrvDPDSwoon, StinkBugSmall, DPDSwoon); + NEW_NERVE(StinkBugSmallNrvForceFall, StinkBugSmall, ForceFall); +} From 5fff752e02a58a59acf29545cd0b3afbc2edf11b Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 04:06:32 +0100 Subject: [PATCH 03/21] formatting on StinkBugSmall.hpp --- include/Game/Enemy/StinkBugSmall.hpp | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/include/Game/Enemy/StinkBugSmall.hpp b/include/Game/Enemy/StinkBugSmall.hpp index 96ce7d2bc..f764d04a5 100644 --- a/include/Game/Enemy/StinkBugSmall.hpp +++ b/include/Game/Enemy/StinkBugSmall.hpp @@ -1,16 +1,15 @@ #pragma once #include "Game/Enemy/AnimScaleController.hpp" +#include "Game/Enemy/StinkBugBase.hpp" #include "Game/Enemy/WalkerStateBindStarPointer.hpp" #include "Game/LiveActor/ActorStateBase.hpp" #include "Game/LiveActor/HitSensor.hpp" #include "Game/LiveActor/Nerve.hpp" -#include "Game/Enemy/StinkBugBase.hpp" #include "Game/Util/JMapInfo.hpp" #include "revolution/types.h" #include - class StinkBugSmall : public StinkBugBase { public: StinkBugSmall(const char*); @@ -43,10 +42,10 @@ class StinkBugSmall : public StinkBugBase { void exeForceFall(); void exeShake(); void exeDashSignEnd(); - /* Offset 188 */ AnimScaleController *mScaleController; - /* Offset 192 */ ActorStateBaseInterface *mStateBaseInterface; - /* Offset 196 */ bool unk196; - /* Offset 200 */ WalkerStateBindStarPointer *mBindStarPointer; + /* Offset 188 */ AnimScaleController* mScaleController; + /* Offset 192 */ ActorStateBaseInterface* mStateBaseInterface; + /* Offset 196 */ bool unk196; + /* Offset 200 */ WalkerStateBindStarPointer* mBindStarPointer; }; namespace NrvStinkBugSmall { @@ -66,4 +65,4 @@ namespace NrvStinkBugSmall { NEW_NERVE(StinkBugSmallNrvRecover, StinkBugSmall, Recover); NEW_NERVE(StinkBugSmallNrvDPDSwoon, StinkBugSmall, DPDSwoon); NEW_NERVE(StinkBugSmallNrvForceFall, StinkBugSmall, ForceFall); -} +} // namespace NrvStinkBugSmall From 06ef6a26e85bc89dfc242ab03b0abb638ec81d02 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 04:07:07 +0100 Subject: [PATCH 04/21] formatting on StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 231 +++++++++++++++---------------- 1 file changed, 112 insertions(+), 119 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index 8cb734236..0e219d315 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -17,36 +17,37 @@ #include #include -StinkBugSmall::StinkBugSmall(const char* pName) : StinkBugBase(pName), - mScaleController(nullptr), mBindStarPointer(nullptr), - mStateBaseInterface(nullptr) {} -StinkBugSmall::~StinkBugSmall() {} +StinkBugSmall::StinkBugSmall(const char* pName) + : StinkBugBase(pName), mScaleController(nullptr), mBindStarPointer(nullptr), mStateBaseInterface(nullptr) { +} +StinkBugSmall::~StinkBugSmall() { +} -s32 StinkBugSmall::tryForceFall(){ +s32 StinkBugSmall::tryForceFall() { const LiveActor* pActor = this; - if(!MR::isValidSwitchA(pActor) || !MR::isOnSwitchA(pActor)){ + if (!MR::isValidSwitchA(pActor) || !MR::isOnSwitchA(pActor)) { return 0; } - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)){ + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { return 0; } - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)){ + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) { return 0; } LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance); return 1; } -s32 StinkBugSmall::tryDPDSwoon(){ +s32 StinkBugSmall::tryDPDSwoon() { const LiveActor* pActor = this; - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return 0; } - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)){ + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { return 0; } - - if(!mBindStarPointer->tryStartPointBind()){ + + if (!mBindStarPointer->tryStartPointBind()) { return 0; } LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance); @@ -54,23 +55,23 @@ s32 StinkBugSmall::tryDPDSwoon(){ } s32 StinkBugSmall::isShakeChance() const { - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return 0; } - if(!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance)){ + if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance)) { return 0; } - if(MR::isPlayerHipDropFalling()){ + if (MR::isPlayerHipDropFalling()) { return 0; } return MR::isPlayerHipDropLand() == 0; } -void StinkBugSmall::kill(){ - if(MR::isValidSwitchDead(this)){ +void StinkBugSmall::kill() { + if (MR::isValidSwitchDead(this)) { MR::onSwitchDead(this); } - if(!MR::isValidSwitchDead(this)){ + if (!MR::isValidSwitchDead(this)) { MR::appearStarPiece(this, this->mPosition, 3, 10.0f, 40.0f, 0); MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1); } @@ -79,11 +80,11 @@ void StinkBugSmall::kill(){ LiveActor::kill(); } -bool StinkBugSmall::exeHipDropDown(){ - if (MR::isFirstStep(this)){ +bool StinkBugSmall::exeHipDropDown() { + if (MR::isFirstStep(this)) { MR::startBck(this, "Death", 0); MR::startBrk(this, "Death"); - if(!unk196){ + if (!unk196) { MR::invalidateCollisionParts(this); } MR::invalidateHitSensors(this); @@ -93,157 +94,150 @@ bool StinkBugSmall::exeHipDropDown(){ } this->mVelocity.zero(); bool result = MR::isBckStopped(this); - if(result){ + if (result) { return this->exeHipDropDown(); - } - else{ + } else { return result; } return result; } s32 StinkBugSmall::isNrvEnableStarPieceAttack() const { - bool Inerves = LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); - if(Inerves){ + bool Inerves = LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || + LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + if (Inerves) { return 1; } return 0; } -bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pReceiver, HitSensor* pSender){ - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ +bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pReceiver, HitSensor* pSender) { + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return false; } - if(MR::isPlayerElementModeInvincible() && (MR::isMsgFloorTouch(msg) || MR::isMsgWallTouch(msg) || MR::isMsgCeilTouch(msg))){ - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); - return true; - } - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)){ - return false; - } - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)){ - return false; - } - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)){ - return false; - } - { - if(MR::isMsgFloorTouch(msg)) { - if(MR::isOnPlayer(LiveActor::getSensor("body"))){ - if(StinkBugSmall::isShakeChance()){ - MR::sendMsgEnemyAttackFlip(pReceiver, pSender); - } - else { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); - return true; - } + if (MR::isPlayerElementModeInvincible() && (MR::isMsgFloorTouch(msg) || MR::isMsgWallTouch(msg) || MR::isMsgCeilTouch(msg))) { + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + return true; + } + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; + } + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)) { + return false; + } + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)) { + return false; + } + { + if (MR::isMsgFloorTouch(msg)) { + if (MR::isOnPlayer(LiveActor::getSensor("body"))) { + if (StinkBugSmall::isShakeChance()) { + MR::sendMsgEnemyAttackFlip(pReceiver, pSender); + } else { + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); + return true; } } } - return false; + } + return false; } -bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pReceiver, HitSensor* pSender){ - if(LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)){ +bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pReceiver, HitSensor* pSender) { + if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return false; } - if(LiveActor::getSensor("body")){ + if (LiveActor::getSensor("body")) { return false; } - if(MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)){ + if (MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); return true; - } - else if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { - if(MR::isMsgStarPieceReflect(msg) && LiveActor::getSensor("body")){ - if(StinkBugSmall::isNrvEnableStarPieceAttack()){ + } else if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { + if (MR::isMsgStarPieceReflect(msg) && LiveActor::getSensor("body")) { + if (StinkBugSmall::isNrvEnableStarPieceAttack()) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); return true; } } - if(!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && - !LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && - MR::isMsgPlayerSpinAttack(msg) && - LiveActor::getSensor("body")){ - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); - return true; - } + if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && + !LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && MR::isMsgPlayerSpinAttack(msg) && + LiveActor::getSensor("body")) { + LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + return true; + } } return false; } - -void StinkBugSmall::exeWait(){ - if(MR::isFirstStep(this) && this->mScale.x != 0.0f){ +void StinkBugSmall::exeWait() { + if (MR::isFirstStep(this) && this->mScale.x != 0.0f) { MR::tryStartBck(this, "Search", 0); } StinkBugBase::fixInitPos(); - if(StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)){ + if (StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); - } - else if(this->mScale.x != 0.0f){ - if(MR::isGreaterStep(this, 1)){ + } else if (this->mScale.x != 0.0f) { + if (MR::isGreaterStep(this, 1)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance); } } } -void StinkBugSmall::exeSearch(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeSearch() { + if (MR::isFirstStep(this)) { MR::tryStartBck(this, "Search", 0); } StinkBugBase::fixInitPos(); - if(StinkBugBase::tryTurnSearch(1.0)){ + if (StinkBugBase::tryTurnSearch(1.0)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); - } - else if (StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)) { + } else if (StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); } } -void StinkBugSmall::exeDashSign(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeDashSign() { + if (MR::isFirstStep(this)) { MR::startBck(this, "RushStart", 0); MR::startSound(this, "SE_EV_STINKBUG_S_FIND", -1, -1); } MR::startLevelSound(this, "SE_EM_STINKBUG_S_DASH_SIGN", -1, -1, -1); StinkBugBase::fixInitPos(); StinkBugBase::tryTurnDashSign(3.0f); - if(MR::isBckStopped(this)){ + if (MR::isBckStopped(this)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance); } } -void StinkBugSmall::exeDash(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeDash() { + if (MR::isFirstStep(this)) { MR::startBck(this, "Rush", 0); MR::validateHitSensors(this); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_DASH", -1, -1, -1); - if(MR::isNear(this, this->mPosition, this->mScale.y) && !MR::isBindedWall(this)){ + if (MR::isNear(this, this->mPosition, this->mScale.y) && !MR::isBindedWall(this)) { return StinkBugBase::setDashVelocity(20.0f); } this->mVelocity.zero(); LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashEnd::sInstance); return MR::startSound(this, "SE_EM_STINKBUG_S_DASH_END", -1, -1); } -void StinkBugSmall::exeDashEnd(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeDashEnd() { + if (MR::isFirstStep(this)) { MR::startBck(this, "RushStop", 0); } this->mVelocity.zero(); - if(MR::isBckStopped(this)){ + if (MR::isBckStopped(this)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } -void StinkBugSmall::exeBack(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeBack() { + if (MR::isFirstStep(this)) { MR::startBck(this, "Back", 0); MR::invalidateHitSensor(this, "head"); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_BACK", -1, -1, -1); - if(MR::isNear(this, this->mPosition, 10.0f)){ + if (MR::isNear(this, this->mPosition, 10.0f)) { return LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); } TVec3f tvf; @@ -251,68 +245,67 @@ void StinkBugSmall::exeBack(){ MR::turnVecToPlane(&tvf, tvf, this->mGravity); this->mVelocity.scale(5.0); } -void StinkBugSmall::exeAttack(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeAttack() { + if (MR::isFirstStep(this)) { MR::startBck(this, "Attack", 0); } this->mVelocity.zero(); - if(MR::isBckStopped(this)){ + if (MR::isBckStopped(this)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } -void StinkBugSmall::exeSpinReaction(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeSpinReaction() { + if (MR::isFirstStep(this)) { MR::startBck(this, "SpinAction", 0); } MR::startSound(this, "SE_EM_GUARD_S", -1, -1); this->mVelocity.zero(); - if(MR::isBckStopped(this)){ + if (MR::isBckStopped(this)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } -void StinkBugSmall::exeShakeStart(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeShakeStart() { + if (MR::isFirstStep(this)) { MR::startBck(this, "repel", 0); } - if(MR::isStep(this, 40)){ + if (MR::isStep(this, 40)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance); } } -void StinkBugSmall::exePanic(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exePanic() { + if (MR::isFirstStep(this)) { MR::startBck(this, "Loss", 0); MR::invalidateHitSensor(this, "head"); } MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, 15); - MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, -1); + MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, -1); this->mVelocity.zero(); - if(MR::isOnPlayer(LiveActor::getSensor("body"))){ - if(MR::isStep(this, 90)){ + if (MR::isOnPlayer(LiveActor::getSensor("body"))) { + if (MR::isStep(this, 90)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance); } - } - else { + } else { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvRecover::sInstance); } } -void StinkBugSmall::exeRecover(){ +void StinkBugSmall::exeRecover() { this->mVelocity.zero(); MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_PANID", -1, -1, -1); - if(MR::isStep(this, 60)){ + if (MR::isStep(this, 60)) { LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } -void StinkBugSmall::exeDPDSwoon(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeDPDSwoon() { + if (MR::isFirstStep(this)) { MR::deleteEffectAll(this); } - if(MR::isEffectValid(this, "RushSmoke")){ + if (MR::isEffectValid(this, "RushSmoke")) { MR::deleteEffect(this, "RushSmoke"); } MR::updateActorStateAndNextNerve(this, mStateBaseInterface, &NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } -void StinkBugSmall::exeForceFall(){ - if(MR::isFirstStep(this)){ +void StinkBugSmall::exeForceFall() { + if (MR::isFirstStep(this)) { this->mVelocity.zero(); MR::calcGravity(this); MR::onBind(this); From 5728935662497588d88f69bf42188867a7140ace Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 09:35:57 +0100 Subject: [PATCH 05/21] Update StinkBugSmall.hpp --- include/Game/Enemy/StinkBugSmall.hpp | 49 +++++++++------------------- 1 file changed, 15 insertions(+), 34 deletions(-) diff --git a/include/Game/Enemy/StinkBugSmall.hpp b/include/Game/Enemy/StinkBugSmall.hpp index f764d04a5..27a10f12b 100644 --- a/include/Game/Enemy/StinkBugSmall.hpp +++ b/include/Game/Enemy/StinkBugSmall.hpp @@ -5,7 +5,6 @@ #include "Game/Enemy/WalkerStateBindStarPointer.hpp" #include "Game/LiveActor/ActorStateBase.hpp" #include "Game/LiveActor/HitSensor.hpp" -#include "Game/LiveActor/Nerve.hpp" #include "Game/Util/JMapInfo.hpp" #include "revolution/types.h" #include @@ -15,24 +14,24 @@ class StinkBugSmall : public StinkBugBase { StinkBugSmall(const char*); virtual ~StinkBugSmall(); virtual void init(const JMapInfoIter& rIter); - virtual s32 tryDPDSwoon(); - virtual s32 tryForceFall(); - virtual s32 isShakeChance() const; - virtual s32 isNrvEnableStarPieceAttack() const; - virtual bool receiveMsgPlayerAttack(u32 msg, HitSensor* pReceiver, HitSensor* pSender); - virtual bool receiveOtherMsg(u32 msg, HitSensor* pReceiver, HitSensor* pSender); - virtual void attackSensor(HitSensor* mSensor, HitSensor* mSensor2); - virtual void calcAndSetBaseMtx(); - virtual void initAfterPlacement(); + virtual bool receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver); + virtual bool receiveOtherMsg(u32 msg, HitSensor* pSender, HitSensor* pReceiver); + virtual void attackSensor(HitSensor* pSender, HitSensor* pReceiver); virtual void kill(); + virtual void initAfterPlacement(); virtual void control(); + virtual void calcAndSetBaseMtx(); + bool tryDPDSwoon(); + bool tryForceFall(); + bool isShakeChance() const; + bool isNrvEnableStarPieceAttack() const; void exeWait(); void exeSearch(); void exeDashSign(); void exeDash(); void exeDashEnd(); void exeBack(); - bool exeHipDropDown(); + void exeHipDropDown(); void exeAttack(); void exeSpinReaction(); void exeShakeStart(); @@ -42,27 +41,9 @@ class StinkBugSmall : public StinkBugBase { void exeForceFall(); void exeShake(); void exeDashSignEnd(); - /* Offset 188 */ AnimScaleController* mScaleController; - /* Offset 192 */ ActorStateBaseInterface* mStateBaseInterface; - /* Offset 196 */ bool unk196; - /* Offset 200 */ WalkerStateBindStarPointer* mBindStarPointer; -}; -namespace NrvStinkBugSmall { - NEW_NERVE(StinkBugSmallNrvWait, StinkBugSmall, Wait); - NEW_NERVE(StinkBugSmallNrvSearch, StinkBugSmall, Search); - NEW_NERVE(StinkBugSmallNrvDashSign, StinkBugSmall, DashSign); - NEW_NERVE(StinkBugSmallNrvDashSignEnd, StinkBugSmall, DashSignEnd); - NEW_NERVE(StinkBugSmallNrvDash, StinkBugSmall, Dash); - NEW_NERVE(StinkBugSmallNrvDashEnd, StinkBugSmall, DashEnd); - NEW_NERVE(StinkBugSmallNrvBack, StinkBugSmall, Back); - NEW_NERVE(StinkBugSmallNrvHipDropDown, StinkBugSmall, HipDropDown); - NEW_NERVE(StinkBugSmallNrvAttack, StinkBugSmall, Attack); - NEW_NERVE(StinkBugSmallNrvSpinReaction, StinkBugSmall, SpinReaction); - NEW_NERVE(StinkBugSmallNrvShakeStart, StinkBugSmall, ShakeStart); - NEW_NERVE(StinkBugSmallNrvShake, StinkBugSmall, Shake); - NEW_NERVE(StinkBugSmallNrvPanic, StinkBugSmall, Panic); - NEW_NERVE(StinkBugSmallNrvRecover, StinkBugSmall, Recover); - NEW_NERVE(StinkBugSmallNrvDPDSwoon, StinkBugSmall, DPDSwoon); - NEW_NERVE(StinkBugSmallNrvForceFall, StinkBugSmall, ForceFall); -} // namespace NrvStinkBugSmall + /* 0xBC */ AnimScaleController* mScaleController; + /* 0xC0 */ ActorStateBaseInterface* mStateBaseInterface; + /* 0xC4 */ WalkerStateBindStarPointer* mBindStarPointer; + /* 0xC8 */ bool unk_C8; +}; From 6e427bd231c792ecf75f6cc5e8fffc884abb274d Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 09:37:21 +0100 Subject: [PATCH 06/21] Update StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 229 +++++++++++++++---------------- 1 file changed, 114 insertions(+), 115 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index 0e219d315..93a27022d 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -2,7 +2,6 @@ #include "Game/Enemy/StinkBugBase.hpp" #include "Game/Enemy/WalkerStateBindStarPointer.hpp" #include "Game/LiveActor/HitSensor.hpp" -#include "Game/LiveActor/LiveActor.hpp" #include "Game/Util/ActorMovementUtil.hpp" #include "Game/Util/ActorSensorUtil.hpp" #include "Game/Util/ActorStateUtil.hpp" @@ -17,52 +16,71 @@ #include #include + +namespace NrvStinkBugSmall { + NEW_NERVE(StinkBugSmallNrvWait, StinkBugSmall, Wait); + NEW_NERVE(StinkBugSmallNrvSearch, StinkBugSmall, Search); + NEW_NERVE(StinkBugSmallNrvDashSign, StinkBugSmall, DashSign); + NEW_NERVE(StinkBugSmallNrvDashSignEnd, StinkBugSmall, DashSignEnd); + NEW_NERVE(StinkBugSmallNrvDash, StinkBugSmall, Dash); + NEW_NERVE(StinkBugSmallNrvDashEnd, StinkBugSmall, DashEnd); + NEW_NERVE(StinkBugSmallNrvBack, StinkBugSmall, Back); + NEW_NERVE(StinkBugSmallNrvHipDropDown, StinkBugSmall, HipDropDown); + NEW_NERVE(StinkBugSmallNrvAttack, StinkBugSmall, Attack); + NEW_NERVE(StinkBugSmallNrvSpinReaction, StinkBugSmall, SpinReaction); + NEW_NERVE(StinkBugSmallNrvShakeStart, StinkBugSmall, ShakeStart); + NEW_NERVE(StinkBugSmallNrvShake, StinkBugSmall, Shake); + NEW_NERVE(StinkBugSmallNrvPanic, StinkBugSmall, Panic); + NEW_NERVE(StinkBugSmallNrvRecover, StinkBugSmall, Recover); + NEW_NERVE(StinkBugSmallNrvDPDSwoon, StinkBugSmall, DPDSwoon); + NEW_NERVE(StinkBugSmallNrvForceFall, StinkBugSmall, ForceFall); +} // namespace NrvStinkBugSmall + + StinkBugSmall::StinkBugSmall(const char* pName) : StinkBugBase(pName), mScaleController(nullptr), mBindStarPointer(nullptr), mStateBaseInterface(nullptr) { } StinkBugSmall::~StinkBugSmall() { } -s32 StinkBugSmall::tryForceFall() { - const LiveActor* pActor = this; - if (!MR::isValidSwitchA(pActor) || !MR::isOnSwitchA(pActor)) { - return 0; +bool StinkBugSmall::tryForceFall() { + if (!MR::isValidSwitchA(this) || !MR::isOnSwitchA(this)) { + return false; } - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { - return 0; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; } - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) { - return 0; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) { + return false; } - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance); - return 1; + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance); + return true; } -s32 StinkBugSmall::tryDPDSwoon() { - const LiveActor* pActor = this; - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return 0; +bool StinkBugSmall::tryDPDSwoon() { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return false; } - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { - return 0; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; } if (!mBindStarPointer->tryStartPointBind()) { - return 0; + return false; } - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance); - return 1; + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance); + return true; } -s32 StinkBugSmall::isShakeChance() const { - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return 0; +bool StinkBugSmall::isShakeChance() const { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return false; } - if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance)) { - return 0; + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance)) { + return false; } if (MR::isPlayerHipDropFalling()) { - return 0; + return false; } return MR::isPlayerHipDropLand() == 0; } @@ -72,19 +90,19 @@ void StinkBugSmall::kill() { MR::onSwitchDead(this); } if (!MR::isValidSwitchDead(this)) { - MR::appearStarPiece(this, this->mPosition, 3, 10.0f, 40.0f, 0); + MR::appearStarPiece(this, mPosition, 3, 10.0f, 40.0f, 0); MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1); } MR::emitEffect(this, "Death"); MR::startSound(this, "SE_EM_EXPLODE_S", -1, -1); - LiveActor::kill(); + kill(); } -bool StinkBugSmall::exeHipDropDown() { +void StinkBugSmall::exeHipDropDown() { if (MR::isFirstStep(this)) { MR::startBck(this, "Death", 0); MR::startBrk(this, "Death"); - if (!unk196) { + if (!unk_C8) { MR::invalidateCollisionParts(this); } MR::invalidateHitSensors(this); @@ -92,81 +110,62 @@ bool StinkBugSmall::exeHipDropDown() { MR::startSound(this, "SE_EM_STOMPED_S", -1, -1); MR::startSound(this, "SE_EV_STINKBUG_S_STOMPED", -1, -1); } - this->mVelocity.zero(); - bool result = MR::isBckStopped(this); - if (result) { - return this->exeHipDropDown(); - } else { - return result; + mVelocity.zero(); + if (MR::isBckStopped(this)) { + return exeHipDropDown(); } - return result; } -s32 StinkBugSmall::isNrvEnableStarPieceAttack() const { - bool Inerves = LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || - LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); - if (Inerves) { - return 1; - } - return 0; +bool StinkBugSmall::isNrvEnableStarPieceAttack() const { + return isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } -bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pReceiver, HitSensor* pSender) { - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return false; - } +bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pReceiver) { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) return false; if (MR::isPlayerElementModeInvincible() && (MR::isMsgFloorTouch(msg) || MR::isMsgWallTouch(msg) || MR::isMsgCeilTouch(msg))) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); return true; } - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { - return false; - } - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)) { - return false; - } - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)) { - return false; - } - { - if (MR::isMsgFloorTouch(msg)) { - if (MR::isOnPlayer(LiveActor::getSensor("body"))) { - if (StinkBugSmall::isShakeChance()) { - MR::sendMsgEnemyAttackFlip(pReceiver, pSender); - } else { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); - return true; - } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) return false; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)) return false; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)) return false; + + + if (MR::isMsgFloorTouch(msg)) { + if (MR::isOnPlayer(getSensor("body"))) { + if (StinkBugSmall::isShakeChance()) { + MR::sendMsgEnemyAttackFlip(pReceiver, pSendder); + } else { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); + return true; } } } return false; } -bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pReceiver, HitSensor* pSender) { - if (LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return false; - } - if (LiveActor::getSensor("body")) { - return false; - } +bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver) { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) return false; + if (getSensor("body")) return false; if (MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); return true; - } else if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { - if (MR::isMsgStarPieceReflect(msg) && LiveActor::getSensor("body")) { + } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { + if (MR::isMsgStarPieceReflect(msg) && getSensor("body")) { if (StinkBugSmall::isNrvEnableStarPieceAttack()) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); return true; } } - if (!LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && - !LiveActor::isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && MR::isMsgPlayerSpinAttack(msg) && - LiveActor::getSensor("body")) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && + !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && MR::isMsgPlayerSpinAttack(msg) && + getSensor("body")) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); return true; } } @@ -174,15 +173,15 @@ bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pReceiver, HitSen } void StinkBugSmall::exeWait() { - if (MR::isFirstStep(this) && this->mScale.x != 0.0f) { + if (MR::isFirstStep(this) && mScale.x != 0.0f) { MR::tryStartBck(this, "Search", 0); } StinkBugBase::fixInitPos(); - if (StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); - } else if (this->mScale.x != 0.0f) { + if (StinkBugBase::isPlayerInTerritory(400.0f, 600.0f, 200.0f, 200.0f)) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); + } else if (mScale.x != 0.0f) { if (MR::isGreaterStep(this, 1)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance); } } } @@ -192,9 +191,9 @@ void StinkBugSmall::exeSearch() { } StinkBugBase::fixInitPos(); if (StinkBugBase::tryTurnSearch(1.0)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); } else if (StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); } } void StinkBugSmall::exeDashSign() { @@ -206,7 +205,7 @@ void StinkBugSmall::exeDashSign() { StinkBugBase::fixInitPos(); StinkBugBase::tryTurnDashSign(3.0f); if (MR::isBckStopped(this)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance); } } void StinkBugSmall::exeDash() { @@ -215,20 +214,20 @@ void StinkBugSmall::exeDash() { MR::validateHitSensors(this); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_DASH", -1, -1, -1); - if (MR::isNear(this, this->mPosition, this->mScale.y) && !MR::isBindedWall(this)) { + if (MR::isNear(this, mPosition, mScale.y) && !MR::isBindedWall(this)) { return StinkBugBase::setDashVelocity(20.0f); } - this->mVelocity.zero(); - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashEnd::sInstance); + mVelocity.zero(); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashEnd::sInstance); return MR::startSound(this, "SE_EM_STINKBUG_S_DASH_END", -1, -1); } void StinkBugSmall::exeDashEnd() { if (MR::isFirstStep(this)) { MR::startBck(this, "RushStop", 0); } - this->mVelocity.zero(); + mVelocity.zero(); if (MR::isBckStopped(this)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } void StinkBugSmall::exeBack() { @@ -237,21 +236,21 @@ void StinkBugSmall::exeBack() { MR::invalidateHitSensor(this, "head"); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_BACK", -1, -1, -1); - if (MR::isNear(this, this->mPosition, 10.0f)) { - return LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); + if (MR::isNear(this, mPosition, 10.0f)) { + return setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); } TVec3f tvf; MR::normalize(&tvf); - MR::turnVecToPlane(&tvf, tvf, this->mGravity); - this->mVelocity.scale(5.0); + MR::turnVecToPlane(&tvf, tvf, mGravity); + mVelocity.scale(5.0); } void StinkBugSmall::exeAttack() { if (MR::isFirstStep(this)) { MR::startBck(this, "Attack", 0); } - this->mVelocity.zero(); + mVelocity.zero(); if (MR::isBckStopped(this)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } void StinkBugSmall::exeSpinReaction() { @@ -259,9 +258,9 @@ void StinkBugSmall::exeSpinReaction() { MR::startBck(this, "SpinAction", 0); } MR::startSound(this, "SE_EM_GUARD_S", -1, -1); - this->mVelocity.zero(); + mVelocity.zero(); if (MR::isBckStopped(this)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } void StinkBugSmall::exeShakeStart() { @@ -269,7 +268,7 @@ void StinkBugSmall::exeShakeStart() { MR::startBck(this, "repel", 0); } if (MR::isStep(this, 40)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance); } } void StinkBugSmall::exePanic() { @@ -279,20 +278,20 @@ void StinkBugSmall::exePanic() { } MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, 15); MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, -1); - this->mVelocity.zero(); - if (MR::isOnPlayer(LiveActor::getSensor("body"))) { + mVelocity.zero(); + if (MR::isOnPlayer(getSensor("body"))) { if (MR::isStep(this, 90)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance); } } else { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvRecover::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvRecover::sInstance); } } void StinkBugSmall::exeRecover() { - this->mVelocity.zero(); + mVelocity.zero(); MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_PANID", -1, -1, -1); if (MR::isStep(this, 60)) { - LiveActor::setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } } void StinkBugSmall::exeDPDSwoon() { @@ -306,9 +305,9 @@ void StinkBugSmall::exeDPDSwoon() { } void StinkBugSmall::exeForceFall() { if (MR::isFirstStep(this)) { - this->mVelocity.zero(); + mVelocity.zero(); MR::calcGravity(this); MR::onBind(this); } - JMAVECScaleAdd(this->mGravity, this->mVelocity, this->mVelocity, 2.0f); + JMAVECScaleAdd(mGravity, mVelocity, mVelocity, 2.0f); } From 0020079439a19f1a4275f64f8da88674b5c6ebce Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 14:58:11 +0100 Subject: [PATCH 07/21] Update StinkBugSmall.hpp --- include/Game/Enemy/StinkBugSmall.hpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/include/Game/Enemy/StinkBugSmall.hpp b/include/Game/Enemy/StinkBugSmall.hpp index 27a10f12b..614a4dad8 100644 --- a/include/Game/Enemy/StinkBugSmall.hpp +++ b/include/Game/Enemy/StinkBugSmall.hpp @@ -14,17 +14,13 @@ class StinkBugSmall : public StinkBugBase { StinkBugSmall(const char*); virtual ~StinkBugSmall(); virtual void init(const JMapInfoIter& rIter); - virtual bool receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver); - virtual bool receiveOtherMsg(u32 msg, HitSensor* pSender, HitSensor* pReceiver); - virtual void attackSensor(HitSensor* pSender, HitSensor* pReceiver); virtual void kill(); - virtual void initAfterPlacement(); virtual void control(); + virtual void attackSensor(HitSensor* pSender, HitSensor* pReceiver); virtual void calcAndSetBaseMtx(); - bool tryDPDSwoon(); - bool tryForceFall(); - bool isShakeChance() const; - bool isNrvEnableStarPieceAttack() const; + virtual bool receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver); + virtual bool receiveOtherMsg(u32 msg, HitSensor* pSender, HitSensor* pReceiver); + virtual void initAfterPlacement(); void exeWait(); void exeSearch(); void exeDashSign(); @@ -41,9 +37,13 @@ class StinkBugSmall : public StinkBugBase { void exeForceFall(); void exeShake(); void exeDashSignEnd(); + bool tryDPDSwoon(); + bool tryForceFall(); + bool isShakeChance() const; + bool isNrvEnableStarPieceAttack() const; /* 0xBC */ AnimScaleController* mScaleController; /* 0xC0 */ ActorStateBaseInterface* mStateBaseInterface; - /* 0xC4 */ WalkerStateBindStarPointer* mBindStarPointer; - /* 0xC8 */ bool unk_C8; + /* 0xC4 */ u8 _C4; + /* 0xC8 */ WalkerStateBindStarPointer* mBindStarPointer; }; From 61be2821d3dba4483ca59bef0fe6dcd74d9234dc Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 14:58:44 +0100 Subject: [PATCH 08/21] Update StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 86 +++++++++++++++++--------------- 1 file changed, 45 insertions(+), 41 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index 93a27022d..9514e6ac1 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -16,7 +16,6 @@ #include #include - namespace NrvStinkBugSmall { NEW_NERVE(StinkBugSmallNrvWait, StinkBugSmall, Wait); NEW_NERVE(StinkBugSmallNrvSearch, StinkBugSmall, Search); @@ -36,7 +35,6 @@ namespace NrvStinkBugSmall { NEW_NERVE(StinkBugSmallNrvForceFall, StinkBugSmall, ForceFall); } // namespace NrvStinkBugSmall - StinkBugSmall::StinkBugSmall(const char* pName) : StinkBugBase(pName), mScaleController(nullptr), mBindStarPointer(nullptr), mStateBaseInterface(nullptr) { } @@ -82,7 +80,7 @@ bool StinkBugSmall::isShakeChance() const { if (MR::isPlayerHipDropFalling()) { return false; } - return MR::isPlayerHipDropLand() == 0; + return MR::isPlayerHipDropLand() == false; } void StinkBugSmall::kill() { @@ -90,7 +88,7 @@ void StinkBugSmall::kill() { MR::onSwitchDead(this); } if (!MR::isValidSwitchDead(this)) { - MR::appearStarPiece(this, mPosition, 3, 10.0f, 40.0f, 0); + MR::appearStarPiece(this, mPosition, 3, 10.0f, 40.0f, false); MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1); } MR::emitEffect(this, "Death"); @@ -100,9 +98,9 @@ void StinkBugSmall::kill() { void StinkBugSmall::exeHipDropDown() { if (MR::isFirstStep(this)) { - MR::startBck(this, "Death", 0); + MR::startBck(this, "Death", nullptr); MR::startBrk(this, "Death"); - if (!unk_C8) { + if (!_C4) { MR::invalidateCollisionParts(this); } MR::invalidateHitSensors(this); @@ -112,29 +110,34 @@ void StinkBugSmall::exeHipDropDown() { } mVelocity.zero(); if (MR::isBckStopped(this)) { - return exeHipDropDown(); + return kill(); } } bool StinkBugSmall::isNrvEnableStarPieceAttack() const { - return isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || - isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || - isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || - isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || - isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + return isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pReceiver) { - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) return false; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return false; + } if (MR::isPlayerElementModeInvincible() && (MR::isMsgFloorTouch(msg) || MR::isMsgWallTouch(msg) || MR::isMsgCeilTouch(msg))) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); return true; } - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) return false; - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)) return false; - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)) return false; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)) { + return false; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)) { + return false; + } - if (MR::isMsgFloorTouch(msg)) { if (MR::isOnPlayer(getSensor("body"))) { if (StinkBugSmall::isShakeChance()) { @@ -149,8 +152,10 @@ bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pRe } bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver) { - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) return false; - if (getSensor("body")) return false; + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) + return false; + if (getSensor("body")) + return false; if (MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); return true; @@ -162,9 +167,8 @@ bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSenso return true; } } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && - !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && MR::isMsgPlayerSpinAttack(msg) && - getSensor("body")) { + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && + MR::isMsgPlayerSpinAttack(msg) && getSensor("body")) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); return true; } @@ -174,10 +178,10 @@ bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSenso void StinkBugSmall::exeWait() { if (MR::isFirstStep(this) && mScale.x != 0.0f) { - MR::tryStartBck(this, "Search", 0); + MR::tryStartBck(this, "Search", nullptr); } - StinkBugBase::fixInitPos(); - if (StinkBugBase::isPlayerInTerritory(400.0f, 600.0f, 200.0f, 200.0f)) { + fixInitPos(); + if (isPlayerInTerritory(400.0f, 600.0f, 200.0f, 200.0f)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); } else if (mScale.x != 0.0f) { if (MR::isGreaterStep(this, 1)) { @@ -187,35 +191,35 @@ void StinkBugSmall::exeWait() { } void StinkBugSmall::exeSearch() { if (MR::isFirstStep(this)) { - MR::tryStartBck(this, "Search", 0); + MR::tryStartBck(this, "Search", nullptr); } - StinkBugBase::fixInitPos(); - if (StinkBugBase::tryTurnSearch(1.0)) { + fixInitPos(); + if (tryTurnSearch(1.0f)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); - } else if (StinkBugBase::isPlayerInTerritory(400.0, 600.0, 200.0, 200.0)) { + } else if (isPlayerInTerritory(400.0f, 600.0f, 200.0f, 200.0f)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); } } void StinkBugSmall::exeDashSign() { if (MR::isFirstStep(this)) { - MR::startBck(this, "RushStart", 0); + MR::startBck(this, "RushStart", nullptr); MR::startSound(this, "SE_EV_STINKBUG_S_FIND", -1, -1); } MR::startLevelSound(this, "SE_EM_STINKBUG_S_DASH_SIGN", -1, -1, -1); - StinkBugBase::fixInitPos(); - StinkBugBase::tryTurnDashSign(3.0f); + fixInitPos(); + tryTurnDashSign(3.0f); if (MR::isBckStopped(this)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance); } } void StinkBugSmall::exeDash() { if (MR::isFirstStep(this)) { - MR::startBck(this, "Rush", 0); + MR::startBck(this, "Rush", nullptr); MR::validateHitSensors(this); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_DASH", -1, -1, -1); if (MR::isNear(this, mPosition, mScale.y) && !MR::isBindedWall(this)) { - return StinkBugBase::setDashVelocity(20.0f); + return setDashVelocity(20.0f); } mVelocity.zero(); setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashEnd::sInstance); @@ -223,7 +227,7 @@ void StinkBugSmall::exeDash() { } void StinkBugSmall::exeDashEnd() { if (MR::isFirstStep(this)) { - MR::startBck(this, "RushStop", 0); + MR::startBck(this, "RushStop", nullptr); } mVelocity.zero(); if (MR::isBckStopped(this)) { @@ -232,7 +236,7 @@ void StinkBugSmall::exeDashEnd() { } void StinkBugSmall::exeBack() { if (MR::isFirstStep(this)) { - MR::startBck(this, "Back", 0); + MR::startBck(this, "Back", nullptr); MR::invalidateHitSensor(this, "head"); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_BACK", -1, -1, -1); @@ -242,11 +246,11 @@ void StinkBugSmall::exeBack() { TVec3f tvf; MR::normalize(&tvf); MR::turnVecToPlane(&tvf, tvf, mGravity); - mVelocity.scale(5.0); + mVelocity.scale(5.0f); } void StinkBugSmall::exeAttack() { if (MR::isFirstStep(this)) { - MR::startBck(this, "Attack", 0); + MR::startBck(this, "Attack", nullptr); } mVelocity.zero(); if (MR::isBckStopped(this)) { @@ -255,7 +259,7 @@ void StinkBugSmall::exeAttack() { } void StinkBugSmall::exeSpinReaction() { if (MR::isFirstStep(this)) { - MR::startBck(this, "SpinAction", 0); + MR::startBck(this, "SpinAction", nullptr); } MR::startSound(this, "SE_EM_GUARD_S", -1, -1); mVelocity.zero(); @@ -265,7 +269,7 @@ void StinkBugSmall::exeSpinReaction() { } void StinkBugSmall::exeShakeStart() { if (MR::isFirstStep(this)) { - MR::startBck(this, "repel", 0); + MR::startBck(this, "repel", nullptr); } if (MR::isStep(this, 40)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance); @@ -273,7 +277,7 @@ void StinkBugSmall::exeShakeStart() { } void StinkBugSmall::exePanic() { if (MR::isFirstStep(this)) { - MR::startBck(this, "Loss", 0); + MR::startBck(this, "Loss", nullptr); MR::invalidateHitSensor(this, "head"); } MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, 15); From 2b34b2442e6cb040905ffe6eea1fefbe35aaa916 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 19:26:24 +0100 Subject: [PATCH 09/21] Update StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index 9514e6ac1..53dc960e2 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -93,7 +93,7 @@ void StinkBugSmall::kill() { } MR::emitEffect(this, "Death"); MR::startSound(this, "SE_EM_EXPLODE_S", -1, -1); - kill(); + LiveActor::kill(); } void StinkBugSmall::exeHipDropDown() { @@ -110,7 +110,7 @@ void StinkBugSmall::exeHipDropDown() { } mVelocity.zero(); if (MR::isBckStopped(this)) { - return kill(); + kill(); } } @@ -219,11 +219,11 @@ void StinkBugSmall::exeDash() { } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_DASH", -1, -1, -1); if (MR::isNear(this, mPosition, mScale.y) && !MR::isBindedWall(this)) { - return setDashVelocity(20.0f); + setDashVelocity(20.0f); } mVelocity.zero(); setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashEnd::sInstance); - return MR::startSound(this, "SE_EM_STINKBUG_S_DASH_END", -1, -1); + MR::startSound(this, "SE_EM_STINKBUG_S_DASH_END", -1, -1); } void StinkBugSmall::exeDashEnd() { if (MR::isFirstStep(this)) { @@ -241,7 +241,7 @@ void StinkBugSmall::exeBack() { } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_BACK", -1, -1, -1); if (MR::isNear(this, mPosition, 10.0f)) { - return setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); } TVec3f tvf; MR::normalize(&tvf); From b029ec8402c6151cf45b0c21a18fd11e747ec107 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Sun, 12 Apr 2026 23:16:21 +0100 Subject: [PATCH 10/21] Update StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index 53dc960e2..f5396e3cf 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -152,10 +152,12 @@ bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pRe } bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver) { - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return false; - if (getSensor("body")) + } + if (getSensor("body")) { return false; + } if (MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); return true; @@ -313,5 +315,5 @@ void StinkBugSmall::exeForceFall() { MR::calcGravity(this); MR::onBind(this); } - JMAVECScaleAdd(mGravity, mVelocity, mVelocity, 2.0f); + mVelocity.scaleAdd(2.0f, mGravity, mVelocity); } From a4dc634398e3d9372dceb25cf7a7e5319a46bc96 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Mon, 13 Apr 2026 09:54:51 +0100 Subject: [PATCH 11/21] Re-arranged functions in the source file --- src/Game/Enemy/StinkBugSmall.cpp | 281 ++++++++++++++++--------------- 1 file changed, 142 insertions(+), 139 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index f5396e3cf..4e4dc7a37 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -38,145 +38,6 @@ namespace NrvStinkBugSmall { StinkBugSmall::StinkBugSmall(const char* pName) : StinkBugBase(pName), mScaleController(nullptr), mBindStarPointer(nullptr), mStateBaseInterface(nullptr) { } -StinkBugSmall::~StinkBugSmall() { -} - -bool StinkBugSmall::tryForceFall() { - if (!MR::isValidSwitchA(this) || !MR::isOnSwitchA(this)) { - return false; - } - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { - return false; - } - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) { - return false; - } - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance); - return true; -} - -bool StinkBugSmall::tryDPDSwoon() { - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return false; - } - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { - return false; - } - - if (!mBindStarPointer->tryStartPointBind()) { - return false; - } - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance); - return true; -} - -bool StinkBugSmall::isShakeChance() const { - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return false; - } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance)) { - return false; - } - if (MR::isPlayerHipDropFalling()) { - return false; - } - return MR::isPlayerHipDropLand() == false; -} - -void StinkBugSmall::kill() { - if (MR::isValidSwitchDead(this)) { - MR::onSwitchDead(this); - } - if (!MR::isValidSwitchDead(this)) { - MR::appearStarPiece(this, mPosition, 3, 10.0f, 40.0f, false); - MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1); - } - MR::emitEffect(this, "Death"); - MR::startSound(this, "SE_EM_EXPLODE_S", -1, -1); - LiveActor::kill(); -} - -void StinkBugSmall::exeHipDropDown() { - if (MR::isFirstStep(this)) { - MR::startBck(this, "Death", nullptr); - MR::startBrk(this, "Death"); - if (!_C4) { - MR::invalidateCollisionParts(this); - } - MR::invalidateHitSensors(this); - MR::invalidateClipping(this); - MR::startSound(this, "SE_EM_STOMPED_S", -1, -1); - MR::startSound(this, "SE_EV_STINKBUG_S_STOMPED", -1, -1); - } - mVelocity.zero(); - if (MR::isBckStopped(this)) { - kill(); - } -} - -bool StinkBugSmall::isNrvEnableStarPieceAttack() const { - return isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || - isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || - isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); -} - -bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pReceiver) { - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return false; - } - if (MR::isPlayerElementModeInvincible() && (MR::isMsgFloorTouch(msg) || MR::isMsgWallTouch(msg) || MR::isMsgCeilTouch(msg))) { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); - return true; - } - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { - return false; - } - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)) { - return false; - } - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)) { - return false; - } - - if (MR::isMsgFloorTouch(msg)) { - if (MR::isOnPlayer(getSensor("body"))) { - if (StinkBugSmall::isShakeChance()) { - MR::sendMsgEnemyAttackFlip(pReceiver, pSendder); - } else { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); - return true; - } - } - } - return false; -} - -bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver) { - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - return false; - } - if (getSensor("body")) { - return false; - } - if (MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); - return true; - } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { - if (MR::isMsgStarPieceReflect(msg) && getSensor("body")) { - if (StinkBugSmall::isNrvEnableStarPieceAttack()) { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); - return true; - } - } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && - MR::isMsgPlayerSpinAttack(msg) && getSensor("body")) { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); - return true; - } - } - return false; -} void StinkBugSmall::exeWait() { if (MR::isFirstStep(this) && mScale.x != 0.0f) { @@ -191,6 +52,7 @@ void StinkBugSmall::exeWait() { } } } + void StinkBugSmall::exeSearch() { if (MR::isFirstStep(this)) { MR::tryStartBck(this, "Search", nullptr); @@ -250,6 +112,25 @@ void StinkBugSmall::exeBack() { MR::turnVecToPlane(&tvf, tvf, mGravity); mVelocity.scale(5.0f); } + +void StinkBugSmall::exeHipDropDown() { + if (MR::isFirstStep(this)) { + MR::startBck(this, "Death", nullptr); + MR::startBrk(this, "Death"); + if (!_C4) { + MR::invalidateCollisionParts(this); + } + MR::invalidateHitSensors(this); + MR::invalidateClipping(this); + MR::startSound(this, "SE_EM_STOMPED_S", -1, -1); + MR::startSound(this, "SE_EV_STINKBUG_S_STOMPED", -1, -1); + } + mVelocity.zero(); + if (MR::isBckStopped(this)) { + kill(); + } +} + void StinkBugSmall::exeAttack() { if (MR::isFirstStep(this)) { MR::startBck(this, "Attack", nullptr); @@ -317,3 +198,125 @@ void StinkBugSmall::exeForceFall() { } mVelocity.scaleAdd(2.0f, mGravity, mVelocity); } + +void StinkBugSmall::kill() { + if (MR::isValidSwitchDead(this)) { + MR::onSwitchDead(this); + } + if (!MR::isValidSwitchDead(this)) { + MR::appearStarPiece(this, mPosition, 3, 10.0f, 40.0f, false); + MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1); + } + MR::emitEffect(this, "Death"); + MR::startSound(this, "SE_EM_EXPLODE_S", -1, -1); + LiveActor::kill(); +} + +bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver) { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return false; + } + if (getSensor("body")) { + return false; + } + if (MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + return true; + } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { + if (MR::isMsgStarPieceReflect(msg) && getSensor("body")) { + if (StinkBugSmall::isNrvEnableStarPieceAttack()) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + return true; + } + } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && + MR::isMsgPlayerSpinAttack(msg) && getSensor("body")) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + return true; + } + } + return false; +} + +bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pReceiver) { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return false; + } + if (MR::isPlayerElementModeInvincible() && (MR::isMsgFloorTouch(msg) || MR::isMsgWallTouch(msg) || MR::isMsgCeilTouch(msg))) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + return true; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance)) { + return false; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance)) { + return false; + } + + if (MR::isMsgFloorTouch(msg)) { + if (MR::isOnPlayer(getSensor("body"))) { + if (StinkBugSmall::isShakeChance()) { + MR::sendMsgEnemyAttackFlip(pReceiver, pSendder); + } else { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); + return true; + } + } + } + return false; +} + +bool StinkBugSmall::tryDPDSwoon() { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return false; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; + } + + if (!mBindStarPointer->tryStartPointBind()) { + return false; + } + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance); + return true; +} + +bool StinkBugSmall::tryForceFall() { + if (!MR::isValidSwitchA(this) || !MR::isOnSwitchA(this)) { + return false; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) { + return false; + } + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance); + return true; +} + +bool StinkBugSmall::isShakeChance() const { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return false; + } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance)) { + return false; + } + if (MR::isPlayerHipDropFalling()) { + return false; + } + return MR::isPlayerHipDropLand() == false; +} + +bool StinkBugSmall::isNrvEnableStarPieceAttack() const { + return isNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance) || + isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); +} + +StinkBugSmall::~StinkBugSmall() { +} From 914d21b11d879a14dff65b898ccb2419afc9c93a Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Thu, 16 Apr 2026 02:24:30 +0100 Subject: [PATCH 12/21] Update StinkBugSmall.hpp --- include/Game/Enemy/StinkBugSmall.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/include/Game/Enemy/StinkBugSmall.hpp b/include/Game/Enemy/StinkBugSmall.hpp index 614a4dad8..3f91f1116 100644 --- a/include/Game/Enemy/StinkBugSmall.hpp +++ b/include/Game/Enemy/StinkBugSmall.hpp @@ -3,7 +3,6 @@ #include "Game/Enemy/AnimScaleController.hpp" #include "Game/Enemy/StinkBugBase.hpp" #include "Game/Enemy/WalkerStateBindStarPointer.hpp" -#include "Game/LiveActor/ActorStateBase.hpp" #include "Game/LiveActor/HitSensor.hpp" #include "Game/Util/JMapInfo.hpp" #include "revolution/types.h" @@ -43,7 +42,8 @@ class StinkBugSmall : public StinkBugBase { bool isNrvEnableStarPieceAttack() const; /* 0xBC */ AnimScaleController* mScaleController; - /* 0xC0 */ ActorStateBaseInterface* mStateBaseInterface; - /* 0xC4 */ u8 _C4; - /* 0xC8 */ WalkerStateBindStarPointer* mBindStarPointer; + /* 0xC0 */ WalkerStateBindStarPointer* mBindStarPointer; + +private: + /* 0xC4 */ bool _C4; }; From e4874224824d972aab92b69450e5c6c6280d71ff Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Thu, 16 Apr 2026 02:25:29 +0100 Subject: [PATCH 13/21] Update StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 157 ++++++++++++++++++++++++++++--- 1 file changed, 143 insertions(+), 14 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index 4e4dc7a37..2ea6ed9de 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -1,21 +1,32 @@ #include "Game/Enemy/StinkBugSmall.hpp" +#include "Game/Enemy/AnimScaleController.hpp" #include "Game/Enemy/StinkBugBase.hpp" #include "Game/Enemy/WalkerStateBindStarPointer.hpp" #include "Game/LiveActor/HitSensor.hpp" +#include "Game/LiveActor/LiveActor.hpp" #include "Game/Util/ActorMovementUtil.hpp" #include "Game/Util/ActorSensorUtil.hpp" #include "Game/Util/ActorStateUtil.hpp" #include "Game/Util/ActorSwitchUtil.hpp" #include "Game/Util/EffectUtil.hpp" +#include "Game/Util/JMapInfo.hpp" +#include "Game/Util/JMapUtil.hpp" #include "Game/Util/LiveActorUtil.hpp" +#include "Game/Util/MapUtil.hpp" #include "Game/Util/MathUtil.hpp" +#include "Game/Util/MtxUtil.hpp" #include "Game/Util/ObjUtil.hpp" #include "Game/Util/PlayerUtil.hpp" #include "Game/Util/SoundUtil.hpp" +#include "Game/Util/StarPointerUtil.hpp" +#include "JSystem/JGeometry/TMatrix.hpp" +#include "revolution/mtx.h" #include #include #include +// all the return on void functions are used to exit the function, I have not found a way to do it otherwise. + namespace NrvStinkBugSmall { NEW_NERVE(StinkBugSmallNrvWait, StinkBugSmall, Wait); NEW_NERVE(StinkBugSmallNrvSearch, StinkBugSmall, Search); @@ -35,8 +46,50 @@ namespace NrvStinkBugSmall { NEW_NERVE(StinkBugSmallNrvForceFall, StinkBugSmall, ForceFall); } // namespace NrvStinkBugSmall -StinkBugSmall::StinkBugSmall(const char* pName) - : StinkBugBase(pName), mScaleController(nullptr), mBindStarPointer(nullptr), mStateBaseInterface(nullptr) { +StinkBugSmall::StinkBugSmall(const char* pName) : StinkBugBase(pName), mScaleController(nullptr), mBindStarPointer(nullptr), _C4(nullptr) { +} + +void StinkBugSmall::init(const JMapInfoIter& rIter) { + StinkBugBase::init(rIter); + MR::getJMapInfoArg0NoInit(rIter, &_B0); + MR::getJMapInfoArg1NoInit(rIter, &mRadius); + MR::getJMapInfoArg7NoInit(rIter, &_C4); + initHitSensor(3); + TVec3f v9; + if (_C4) { + v9.y = 10.0f * mScale.x; + v9.x = 0.0f; + v9.z = 0.0f; + MR::addHitSensorEnemy(this, "body", 8, 110.0f * mScale.x, v9); + } else { + MR::addBodyMessageSensorEnemy(this); + } + TVec3f v8; + v8.y = -30.0f * mScale.x; + v8.x = 0.0f; + v8.z = 0.0f; + MR::addHitSensorAtJointEnemyAttack(this, "head", "Face", 8u, 100.0f * mScale.x, v8); + if (!_C4) { + MR::initCollisionParts(this, "Switch", getSensor("body"), nullptr); + } + initBinder(200.0f * mScale.x, 200.0f * mScale.x, nullptr); + MR::setBinderExceptActor(this, this); + MR::setBinderIgnoreMovingCollision(this); + if (!MR::isValidSwitchDead(this)) { + MR::declareStarPiece(this, 3); + } + TVec3f v7; + v7.y = 50.0f * mScale.x; + v7.x = 0.0f; + v7.z = 0.0f; + MR::initStarPointerTarget(this, 130.0f * mScale.x, v7); + mScaleController = new AnimScaleController(nullptr); + mBindStarPointer = new WalkerStateBindStarPointer(this, mScaleController); + MR::useStageSwitchReadA(this, rIter); + MR::startBrk(this, "Death"); + MR::setBrkFrameAndStop(this, 0.0f); + initNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); + makeActorAppeared(); } void StinkBugSmall::exeWait() { @@ -82,12 +135,15 @@ void StinkBugSmall::exeDash() { MR::validateHitSensors(this); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_DASH", -1, -1, -1); - if (MR::isNear(this, mPosition, mScale.y) && !MR::isBindedWall(this)) { - setDashVelocity(20.0f); + if (MR::isNear(this, mPosition, mScale.y)) { + if (!MR::isBindedWall(this)) { + return; + } } mVelocity.zero(); setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashEnd::sInstance); MR::startSound(this, "SE_EM_STINKBUG_S_DASH_END", -1, -1); + setDashVelocity(20.0f); } void StinkBugSmall::exeDashEnd() { if (MR::isFirstStep(this)) { @@ -104,13 +160,14 @@ void StinkBugSmall::exeBack() { MR::invalidateHitSensor(this, "head"); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_BACK", -1, -1, -1); - if (MR::isNear(this, mPosition, 10.0f)) { + if (MR::isNear(this, _98, 10.0f)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); + } else { + TVec3f tvf = _98 - mPosition; + MR::normalize(&tvf); + MR::turnVecToPlane(&tvf, tvf, mGravity); + mVelocity.scale(5.0f, tvf); } - TVec3f tvf; - MR::normalize(&tvf); - MR::turnVecToPlane(&tvf, tvf, mGravity); - mVelocity.scale(5.0f); } void StinkBugSmall::exeHipDropDown() { @@ -164,7 +221,7 @@ void StinkBugSmall::exePanic() { MR::invalidateHitSensor(this, "head"); } MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, 15); - MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, -1); + MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_PANIC", -1, -1, -1); mVelocity.zero(); if (MR::isOnPlayer(getSensor("body"))) { if (MR::isStep(this, 90)) { @@ -188,7 +245,7 @@ void StinkBugSmall::exeDPDSwoon() { if (MR::isEffectValid(this, "RushSmoke")) { MR::deleteEffect(this, "RushSmoke"); } - MR::updateActorStateAndNextNerve(this, mStateBaseInterface, &NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + MR::updateActorStateAndNextNerve(this, mBindStarPointer, &NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } void StinkBugSmall::exeForceFall() { if (MR::isFirstStep(this)) { @@ -212,6 +269,79 @@ void StinkBugSmall::kill() { LiveActor::kill(); } +void StinkBugSmall::initAfterPlacement() { + TVec3f v8; + TVec3f v7; + MR::calcUpVec(&v8, this); + v8.scaleAdd(v7, mPosition, 50.0f); + MR::calcUpVec(&v7, this); + v7.x *= -200.0f; + v7.y *= -200.0f; + v7.z *= -200.0f; + HitSensor* pSensor = getSensor("body"); + MR::getFirstPolyOnLineToMapExceptSensor(&_98, nullptr, v8, v7, pSensor); + MR::resetPosition(this, _98); +} + +void StinkBugSmall::control() { + TVec3f v10(0.0f, 0.0f, 0.0f); + if (MR::isInDeath(this, v10)) { + kill(); + } else { + if (!tryDPDSwoon() && !tryForceFall() && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance)) { + MR::onBind(this); + if (MR::isBindedGround(this)) { + TVec3f v9 = *MR::getGroundNormal(this); + v9 = -v9; + mGravity.set(v9); + } else { + mGravity.set(mGravity); + } + f32 v6 = mGravity.dot(mVelocity); + JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, -v6); + JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, 2.0f); + } else { + MR::offBind(this); + } + } +} + +void StinkBugSmall::calcAndSetBaseMtx() { + TPos3f v9; + MR::calcMtxFromGravityAndZAxis(&v9, this, mGravity, _8C); + MtxPtr v2 = getBaseMtx(); + MR::blendMtx(v2, v9, 0.30000001f, v9); + MR::setBaseTRMtx(this, v9); + TVec3f scale; + JMathInlineVEC::PSVECMultiply(scale, mScaleController->_C, &scale); + + MR::setBaseScale(this, scale); +} + +void StinkBugSmall::attackSensor(HitSensor* pSender, HitSensor* pReceiver) { + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + if (_C4 && getSensor("body")) { + return; + } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance) && isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && + MR::isSensorPlayer(pSender) && MR::isSensorEnemyAttack(pReceiver)) { + if (MR::isPlayerDamaging()) { + MR::sendMsgPush(pReceiver, pSender); + return; + } + if (isHitHorn(pSender, pReceiver, mScale.x * 20.0f)) { + if (MR::sendMsgEnemyAttackStrong(pReceiver, pSender)) { + MR::emitEffectHitBetweenSensors(this, pSender, pReceiver, 0.0f, nullptr); + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance)) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance); + } + } + } + } + } +} + bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSensor* pReceiver) { if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return false; @@ -239,7 +369,7 @@ bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSenso return false; } -bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pReceiver) { +bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSender, HitSensor* pReceiver) { if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return false; } @@ -260,7 +390,7 @@ bool StinkBugSmall::receiveOtherMsg(u32 msg, HitSensor* pSendder, HitSensor* pRe if (MR::isMsgFloorTouch(msg)) { if (MR::isOnPlayer(getSensor("body"))) { if (StinkBugSmall::isShakeChance()) { - MR::sendMsgEnemyAttackFlip(pReceiver, pSendder); + MR::sendMsgEnemyAttackFlip(pReceiver, pSender); } else { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvPanic::sInstance); return true; @@ -277,7 +407,6 @@ bool StinkBugSmall::tryDPDSwoon() { if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { return false; } - if (!mBindStarPointer->tryStartPointBind()) { return false; } From b71009ad7a1558ab81156ea2e0e6762c85885fb0 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Thu, 16 Apr 2026 10:03:13 +0100 Subject: [PATCH 14/21] Update StinkBugSmall.hpp --- include/Game/Enemy/StinkBugSmall.hpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/include/Game/Enemy/StinkBugSmall.hpp b/include/Game/Enemy/StinkBugSmall.hpp index 3f91f1116..4b68558b4 100644 --- a/include/Game/Enemy/StinkBugSmall.hpp +++ b/include/Game/Enemy/StinkBugSmall.hpp @@ -3,10 +3,6 @@ #include "Game/Enemy/AnimScaleController.hpp" #include "Game/Enemy/StinkBugBase.hpp" #include "Game/Enemy/WalkerStateBindStarPointer.hpp" -#include "Game/LiveActor/HitSensor.hpp" -#include "Game/Util/JMapInfo.hpp" -#include "revolution/types.h" -#include class StinkBugSmall : public StinkBugBase { public: From 1493834c53e6ce8a86bb902bf52f51b7205e5566 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Thu, 16 Apr 2026 10:04:02 +0100 Subject: [PATCH 15/21] Update StinkBugSmall.cpp --- src/Game/Enemy/StinkBugSmall.cpp | 102 ++++++++++++------------------- 1 file changed, 40 insertions(+), 62 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index 2ea6ed9de..c4a0668e2 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -1,31 +1,4 @@ #include "Game/Enemy/StinkBugSmall.hpp" -#include "Game/Enemy/AnimScaleController.hpp" -#include "Game/Enemy/StinkBugBase.hpp" -#include "Game/Enemy/WalkerStateBindStarPointer.hpp" -#include "Game/LiveActor/HitSensor.hpp" -#include "Game/LiveActor/LiveActor.hpp" -#include "Game/Util/ActorMovementUtil.hpp" -#include "Game/Util/ActorSensorUtil.hpp" -#include "Game/Util/ActorStateUtil.hpp" -#include "Game/Util/ActorSwitchUtil.hpp" -#include "Game/Util/EffectUtil.hpp" -#include "Game/Util/JMapInfo.hpp" -#include "Game/Util/JMapUtil.hpp" -#include "Game/Util/LiveActorUtil.hpp" -#include "Game/Util/MapUtil.hpp" -#include "Game/Util/MathUtil.hpp" -#include "Game/Util/MtxUtil.hpp" -#include "Game/Util/ObjUtil.hpp" -#include "Game/Util/PlayerUtil.hpp" -#include "Game/Util/SoundUtil.hpp" -#include "Game/Util/StarPointerUtil.hpp" -#include "JSystem/JGeometry/TMatrix.hpp" -#include "revolution/mtx.h" -#include -#include -#include - -// all the return on void functions are used to exit the function, I have not found a way to do it otherwise. namespace NrvStinkBugSmall { NEW_NERVE(StinkBugSmallNrvWait, StinkBugSmall, Wait); @@ -284,59 +257,64 @@ void StinkBugSmall::initAfterPlacement() { } void StinkBugSmall::control() { - TVec3f v10(0.0f, 0.0f, 0.0f); - if (MR::isInDeath(this, v10)) { + if (MR::isInDeath(this, TVec3f(0.0f, 0.0f, 0.0f))) { kill(); + return; + } + if (tryDPDSwoon() || tryForceFall()) { + return; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) { + return; + } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) || !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance)) { + MR::offBind(this); + return; + } + MR::onBind(this); + if (MR::isBindedGround(this)) { + TVec3f v9; + MR::getGroundNormal(this); + v9.negate(); + v9.z = -v9.y; + mGravity.set(v9); } else { - if (!tryDPDSwoon() && !tryForceFall() && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance)) { - MR::onBind(this); - if (MR::isBindedGround(this)) { - TVec3f v9 = *MR::getGroundNormal(this); - v9 = -v9; - mGravity.set(v9); - } else { - mGravity.set(mGravity); - } - f32 v6 = mGravity.dot(mVelocity); - JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, -v6); - JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, 2.0f); - } else { - MR::offBind(this); - } + mGravity.set(mGravity); } + JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, -mGravity.dot(mVelocity)); + JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, 2.0f); + return; } void StinkBugSmall::calcAndSetBaseMtx() { TPos3f v9; MR::calcMtxFromGravityAndZAxis(&v9, this, mGravity, _8C); MtxPtr v2 = getBaseMtx(); - MR::blendMtx(v2, v9, 0.30000001f, v9); + MR::blendMtx(v2, v9, 0.3f, v9); MR::setBaseTRMtx(this, v9); TVec3f scale; - JMathInlineVEC::PSVECMultiply(scale, mScaleController->_C, &scale); + JMathInlineVEC::PSVECMultiply(scale, mScaleController->_C, scale); MR::setBaseScale(this, scale); } void StinkBugSmall::attackSensor(HitSensor* pSender, HitSensor* pReceiver) { - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { - if (_C4 && getSensor("body")) { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { + return; + } + if (_C4 && getSensor("body")) { + return; + } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance) && isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && + MR::isSensorPlayer(pSender) && MR::isSensorEnemyAttack(pReceiver)) { + if (MR::isPlayerDamaging()) { + MR::sendMsgPush(pReceiver, pSender); return; } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance) && isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && - MR::isSensorPlayer(pSender) && MR::isSensorEnemyAttack(pReceiver)) { - if (MR::isPlayerDamaging()) { - MR::sendMsgPush(pReceiver, pSender); - return; - } - if (isHitHorn(pSender, pReceiver, mScale.x * 20.0f)) { - if (MR::sendMsgEnemyAttackStrong(pReceiver, pSender)) { - MR::emitEffectHitBetweenSensors(this, pSender, pReceiver, 0.0f, nullptr); - if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance)) { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance); - } - } + if (isHitHorn(pSender, pReceiver, mScale.x * 20.0f) && MR::sendMsgEnemyAttackStrong(pReceiver, pSender)) { + MR::emitEffectHitBetweenSensors(this, pSender, pReceiver, 0.0f, nullptr); + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance)) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance); } } } From 82685160cd2715d54a26c7ec55ebe1a1abac37e7 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Thu, 16 Apr 2026 23:06:17 +0100 Subject: [PATCH 16/21] StinkBugSmall 94% --- src/Game/Enemy/StinkBugSmall.cpp | 68 ++++++++++++++++++-------------- 1 file changed, 39 insertions(+), 29 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index c4a0668e2..dfaed5ab7 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -66,13 +66,13 @@ void StinkBugSmall::init(const JMapInfoIter& rIter) { } void StinkBugSmall::exeWait() { - if (MR::isFirstStep(this) && mScale.x != 0.0f) { + if (MR::isFirstStep(this) && _B0 == 0.0f) { MR::tryStartBck(this, "Search", nullptr); } fixInitPos(); if (isPlayerInTerritory(400.0f, 600.0f, 200.0f, 200.0f)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSign::sInstance); - } else if (mScale.x != 0.0f) { + } else if (_B0 != 0.0f) { if (MR::isGreaterStep(this, 1)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSearch::sInstance); } @@ -108,7 +108,7 @@ void StinkBugSmall::exeDash() { MR::validateHitSensors(this); } MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_DASH", -1, -1, -1); - if (MR::isNear(this, mPosition, mScale.y)) { + if (MR::isNear(this, _98, mRadius)) { if (!MR::isBindedWall(this)) { return; } @@ -135,12 +135,12 @@ void StinkBugSmall::exeBack() { MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_BACK", -1, -1, -1); if (MR::isNear(this, _98, 10.0f)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvWait::sInstance); - } else { - TVec3f tvf = _98 - mPosition; - MR::normalize(&tvf); - MR::turnVecToPlane(&tvf, tvf, mGravity); - mVelocity.scale(5.0f, tvf); + return; } + TVec3f tvf(_98 - mPosition); + MR::normalize(&tvf); + MR::turnVecToPlane(&tvf, tvf, mGravity); + mVelocity.scale(5.0f, tvf); } void StinkBugSmall::exeHipDropDown() { @@ -196,13 +196,14 @@ void StinkBugSmall::exePanic() { MR::startLevelSound(this, "SE_EV_LV_STINKBUG_S_PANIC", -1, -1, 15); MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_PANIC", -1, -1, -1); mVelocity.zero(); - if (MR::isOnPlayer(getSensor("body"))) { - if (MR::isStep(this, 90)) { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance); - } - } else { + if (!MR::isOnPlayer(getSensor("body"))) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvRecover::sInstance); + return; } + if (!MR::isStep(this, 90)) { + return; + } + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance); } void StinkBugSmall::exeRecover() { mVelocity.zero(); @@ -261,19 +262,20 @@ void StinkBugSmall::control() { kill(); return; } - if (tryDPDSwoon() || tryForceFall()) { + mScaleController->updateNerve(); + if (tryDPDSwoon() || !tryForceFall()) { return; } if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvForceFall::sInstance)) { return; } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) || !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance)) { + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) || isNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance)) { MR::offBind(this); return; } + TVec3f v9; MR::onBind(this); if (MR::isBindedGround(this)) { - TVec3f v9; MR::getGroundNormal(this); v9.negate(); v9.z = -v9.y; @@ -283,7 +285,6 @@ void StinkBugSmall::control() { } JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, -mGravity.dot(mVelocity)); JMAVECScaleAdd(&mGravity, &mVelocity, &mVelocity, 2.0f); - return; } void StinkBugSmall::calcAndSetBaseMtx() { @@ -302,10 +303,11 @@ void StinkBugSmall::attackSensor(HitSensor* pSender, HitSensor* pReceiver) { if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance)) { return; } - if (_C4 && getSensor("body")) { + if (_C4 && !getSensor("body")) { + MR::sendMsgPush(pReceiver, pSender); return; } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance) && isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvAttack::sInstance) && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && MR::isSensorPlayer(pSender) && MR::isSensorEnemyAttack(pReceiver)) { if (MR::isPlayerDamaging()) { MR::sendMsgPush(pReceiver, pSender); @@ -327,23 +329,31 @@ bool StinkBugSmall::receiveMsgPlayerAttack(u32 msg, HitSensor* pSender, HitSenso if (getSensor("body")) { return false; } - if (MR::isMsgInvincibleAttack(msg) || MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { + if (MR::isMsgInvincibleAttack(msg)) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); return true; } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance) && !MR::isMsgLockOnStarPieceShoot(msg)) { - if (MR::isMsgStarPieceReflect(msg) && getSensor("body")) { - if (StinkBugSmall::isNrvEnableStarPieceAttack()) { - setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); - return true; - } - } - if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && - MR::isMsgPlayerSpinAttack(msg) && getSensor("body")) { + if (MR::isMsgPlayerHipDropFloor(msg) || MR::isMsgPlayerHipDrop(msg)) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvHipDropDown::sInstance); + return true; + } + if (isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDPDSwoon::sInstance)) { + return false; + } + if (MR::isMsgLockOnStarPieceShoot(msg)) { + return true; + } + if (MR::isMsgStarPieceReflect(msg) && !getSensor("body")) { + if (isNrvEnableStarPieceAttack()) { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); return true; } } + if (!isNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance) && !isNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance) && + MR::isMsgPlayerSpinAttack(msg) && !getSensor("body")) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvSpinReaction::sInstance); + return true; + } return false; } From 60982900508176d58ac9fbefe7b8af488cde3562 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Fri, 17 Apr 2026 01:51:46 +0100 Subject: [PATCH 17/21] Update StinkBugSmall.hpp --- include/Game/Enemy/StinkBugSmall.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/include/Game/Enemy/StinkBugSmall.hpp b/include/Game/Enemy/StinkBugSmall.hpp index 4b68558b4..9d99b6f66 100644 --- a/include/Game/Enemy/StinkBugSmall.hpp +++ b/include/Game/Enemy/StinkBugSmall.hpp @@ -29,6 +29,7 @@ class StinkBugSmall : public StinkBugBase { void exePanic(); void exeRecover(); void exeDPDSwoon(); + void endDPDSwoon(); void exeForceFall(); void exeShake(); void exeDashSignEnd(); From 00f15c5e4590dc66b46458109d9b5a6776e9e8c1 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Fri, 17 Apr 2026 01:52:17 +0100 Subject: [PATCH 18/21] StinkBugSmall 97% --- src/Game/Enemy/StinkBugSmall.cpp | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/src/Game/Enemy/StinkBugSmall.cpp b/src/Game/Enemy/StinkBugSmall.cpp index dfaed5ab7..4cb332f0f 100644 --- a/src/Game/Enemy/StinkBugSmall.cpp +++ b/src/Game/Enemy/StinkBugSmall.cpp @@ -15,7 +15,7 @@ namespace NrvStinkBugSmall { NEW_NERVE(StinkBugSmallNrvShake, StinkBugSmall, Shake); NEW_NERVE(StinkBugSmallNrvPanic, StinkBugSmall, Panic); NEW_NERVE(StinkBugSmallNrvRecover, StinkBugSmall, Recover); - NEW_NERVE(StinkBugSmallNrvDPDSwoon, StinkBugSmall, DPDSwoon); + NEW_NERVE_ONEND(StinkBugSmallNrvDPDSwoon, StinkBugSmall, DPDSwoon, DPDSwoon); NEW_NERVE(StinkBugSmallNrvForceFall, StinkBugSmall, ForceFall); } // namespace NrvStinkBugSmall @@ -102,6 +102,11 @@ void StinkBugSmall::exeDashSign() { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDashSignEnd::sInstance); } } +void StinkBugSmall::exeDashSignEnd() { + if (MR::isStep(this, 10)) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvDash::sInstance); + } +} void StinkBugSmall::exeDash() { if (MR::isFirstStep(this)) { MR::startBck(this, "Rush", nullptr); @@ -188,6 +193,11 @@ void StinkBugSmall::exeShakeStart() { setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShake::sInstance); } } +void StinkBugSmall::exeShake() { + if (MR::isBckStopped(this)) { + setNerve(&NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); + } +} void StinkBugSmall::exePanic() { if (MR::isFirstStep(this)) { MR::startBck(this, "Loss", nullptr); @@ -205,6 +215,7 @@ void StinkBugSmall::exePanic() { } setNerve(&NrvStinkBugSmall::StinkBugSmallNrvShakeStart::sInstance); } + void StinkBugSmall::exeRecover() { mVelocity.zero(); MR::startLevelSound(this, "SE_EM_LV_STINKBUG_S_PANID", -1, -1, -1); @@ -221,6 +232,9 @@ void StinkBugSmall::exeDPDSwoon() { } MR::updateActorStateAndNextNerve(this, mBindStarPointer, &NrvStinkBugSmall::StinkBugSmallNrvBack::sInstance); } +void StinkBugSmall::endDPDSwoon() { + mBindStarPointer->kill(); +} void StinkBugSmall::exeForceFall() { if (MR::isFirstStep(this)) { mVelocity.zero(); @@ -294,7 +308,7 @@ void StinkBugSmall::calcAndSetBaseMtx() { MR::blendMtx(v2, v9, 0.3f, v9); MR::setBaseTRMtx(this, v9); TVec3f scale; - JMathInlineVEC::PSVECMultiply(scale, mScaleController->_C, scale); + JMathInlineVEC::PSVECMultiply(mScaleController->_C, mScale, scale); MR::setBaseScale(this, scale); } From 9d0d42d432588f90d5c0d938c5fef0e1cba84eb1 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Tue, 21 Apr 2026 17:41:27 +0100 Subject: [PATCH 19/21] Create BegomanSpringHead.cpp --- src/Game/Enemy/BegomanSpringHead.cpp | 105 +++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 src/Game/Enemy/BegomanSpringHead.cpp diff --git a/src/Game/Enemy/BegomanSpringHead.cpp b/src/Game/Enemy/BegomanSpringHead.cpp new file mode 100644 index 000000000..67002e626 --- /dev/null +++ b/src/Game/Enemy/BegomanSpringHead.cpp @@ -0,0 +1,105 @@ +#include "Game/Enemy/BegomanSpringHead.hpp" + +namespace NrvBegomanSpringHead { + NEW_NERVE(HostTypeNrvWait, BegomanSpringHead, Wait); + NEW_NERVE(HostTypeNrvHopStart, BegomanSpringHead, HopStart); + NEW_NERVE(HostTypeNrvHopWait, BegomanSpringHead, HopWait); + NEW_NERVE(HostTypeNrvHopEnd, BegomanSpringHead, HopEnd); + NEW_NERVE(HostTypeNrvHopJump, BegomanSpringHead, HopJump); +} // namespace NrvBegomanSpringHead + +void BegomanHead::calcAndSetBaseMtx() { + PartsModel::calcAndSetBaseMtx(); + TVec3f v7; + JMathInlineVEC::PSVECMultiply(_9C, mScale, v7); + MR::setBaseScale(this, v7); +} + +BegomanSpringHead::BegomanSpringHead(LiveActor* pActor, MtxPtr pMtx) + : BegomanHead(pActor, "バネ頭", "BegomanSpringHead", pMtx, 10, false), _9C(nullptr) { +} + +BegomanHead::~BegomanHead() { +} + +void BegomanSpringHead::init(const JMapInfoIter& rIter) { + initNerve(&NrvBegomanSpringHead::HostTypeNrvWait::sInstance); + MR::initLightCtrl(this); + initHitSensor(1); + MR::addHitSensorAtJoint(this, "head", "SpringJoint5", 71, 8, 100.0f, TVec3f(0.0f, 100.0f, 0.0f)); + PartsModel::init(rIter); +} + +bool BegomanSpringHead::isSpringHop() { + return LiveActor::isNerve(&NrvBegomanSpringHead::HostTypeNrvWait::sInstance) == 0; +} + +void BegomanSpringHead::getHopEndBckFrameMax() { + MR::getBckFrameMax(this, "HopEnd"); +} + +void BegomanSpringHead::tryHopStart() { + if (!isNerve(&NrvBegomanSpringHead::HostTypeNrvHopStart::sInstance)) { + setNerve(&NrvBegomanSpringHead::HostTypeNrvHopStart::sInstance); + } +} + +void BegomanSpringHead::tryHopEnd() { + if (isNerve(&NrvBegomanSpringHead::HostTypeNrvHopEnd::sInstance) || isNerve(&NrvBegomanSpringHead::HostTypeNrvWait::sInstance)) { + return; + } + setNerve(&NrvBegomanSpringHead::HostTypeNrvHopEnd::sInstance); +} + +void BegomanSpringHead::tryHopJump() { + if (!isNerve(&NrvBegomanSpringHead::HostTypeNrvHopJump::sInstance)) { + setNerve(&NrvBegomanSpringHead::HostTypeNrvHopJump::sInstance); + } +} + +void BegomanSpringHead::forceWaitImmediately() { + MR::startBck(this, "Wait", nullptr); + MR::startBrk(this, "Green"); + setNerve(&NrvBegomanSpringHead::HostTypeNrvWait::sInstance); +} + +void BegomanSpringHead::exeWait() { + if (MR::isFirstStep(this)) { + MR::startBck(this, "Wait", nullptr); + MR::startBrk(this, "Green"); + } +} + +void BegomanSpringHead::exeHopStart() { + if (MR::isFirstStep(this)) { + MR::startBck(this, "HopStart", nullptr); + MR::startBrk(this, "OnAndOff"); + MR::setNerveAtBckStopped(this, &NrvBegomanSpringHead::HostTypeNrvHopWait::sInstance); + } +} + +void BegomanSpringHead::exeHopWait() { + if (MR::isFirstStep(this)) { + MR::startBck(this, "HopWait", nullptr); + MR::startBrk(this, "OnAndOff"); + } +} + +void BegomanSpringHead::exeHopEnd() { + if (MR::isFirstStep(this)) { + MR::startSound(this, "SE_EM_BEGOMAN_CLOSE_SPRING", -1, -1); + } + MR::startBckAtFirstStep(this, "HopEnd"); + MR::setNerveAtBckStopped(this, &NrvBegomanSpringHead::HostTypeNrvWait::sInstance); +} + +void BegomanSpringHead::exeHopJump() { + if (MR::isFirstStep(this)) { + MR::startBck(this, "HopJump", nullptr); + MR::startBrk(this, "OnAndOff"); + } + MR::setNerveAtBckStopped(this, &NrvBegomanSpringHead::HostTypeNrvHopWait::sInstance); +} + +BegomanSpringHead::~BegomanSpringHead() { +} From 3568c2646d17fc643f5a46873e2bfb7a58882834 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Tue, 21 Apr 2026 17:42:20 +0100 Subject: [PATCH 20/21] Create BegomanSpringHead.hpp --- include/Game/Enemy/BegomanSpringHead.hpp | 35 ++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 include/Game/Enemy/BegomanSpringHead.hpp diff --git a/include/Game/Enemy/BegomanSpringHead.hpp b/include/Game/Enemy/BegomanSpringHead.hpp new file mode 100644 index 000000000..7418b3237 --- /dev/null +++ b/include/Game/Enemy/BegomanSpringHead.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include "Game/LiveActor/PartsModel.hpp" + +class BegomanHead : public PartsModel { +public: + BegomanHead(LiveActor*, const char*, const char*, MtxPtr, int, bool); + virtual ~BegomanHead(); + virtual void calcAndSetBaseMtx(); + +private: + TVec3f* _9C; +}; + +class BegomanSpringHead : public BegomanHead { +public: + BegomanSpringHead(LiveActor*, MtxPtr); + virtual ~BegomanSpringHead(); + virtual void init(const JMapInfoIter&); + + bool isSpringHop(); + void getHopEndBckFrameMax(); + void tryHopStart(); + void tryHopEnd(); + void tryHopJump(); + void forceWaitImmediately(); + void exeWait(); + void exeHopStart(); + void exeHopWait(); + void exeHopEnd(); + void exeHopJump(); + +private: + TVec3f* _9C; +}; From db8d08946656ac71038e1f5b4cd2da60f8f8ba45 Mon Sep 17 00:00:00 2001 From: BlocksumoGuys <148206420+BlocksumoGuys@users.noreply.github.com> Date: Wed, 22 Apr 2026 09:06:20 +0100 Subject: [PATCH 21/21] Added requested changes --- src/Game/Enemy/BegomanSpringHead.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Game/Enemy/BegomanSpringHead.cpp b/src/Game/Enemy/BegomanSpringHead.cpp index 67002e626..f0f74611c 100644 --- a/src/Game/Enemy/BegomanSpringHead.cpp +++ b/src/Game/Enemy/BegomanSpringHead.cpp @@ -26,12 +26,12 @@ void BegomanSpringHead::init(const JMapInfoIter& rIter) { initNerve(&NrvBegomanSpringHead::HostTypeNrvWait::sInstance); MR::initLightCtrl(this); initHitSensor(1); - MR::addHitSensorAtJoint(this, "head", "SpringJoint5", 71, 8, 100.0f, TVec3f(0.0f, 100.0f, 0.0f)); + MR::addHitSensorAtJoint(this, "head", "SpringJoint5", ATYPE_MAP_OBJ_SIMPLE, 8, 100.0f, TVec3f(0.0f, 100.0f, 0.0f)); PartsModel::init(rIter); } bool BegomanSpringHead::isSpringHop() { - return LiveActor::isNerve(&NrvBegomanSpringHead::HostTypeNrvWait::sInstance) == 0; + return !LiveActor::isNerve(&NrvBegomanSpringHead::HostTypeNrvWait::sInstance); } void BegomanSpringHead::getHopEndBckFrameMax() {