Kukku TU (#379)

* fix: finding solutions for unused func in wanwan

* some stuff done

* formatting

* improvements

* improvements

* some stuff done

* formatting

* rebase and fix name

* naming

* im dumb

* some stuff done

* formatting

* rebase and fix name

* improvements

* improvements

* remove stupid comment

* MarRefGenEnemy

* reviews addressed + symbol order

* format

* remove dtors

include/Enemy/Kukku.hpp

@@ -0,0 +1,143 @@
+#ifndef ENEMY_KUKKU_HPP
+#define ENEMY_KUKKU_HPP
+
+#include <Enemy/SmallEnemy.hpp>
+#include <Strategic/Spine.hpp>
+#include <MarioUtil/MathUtil.hpp>
+#include <M3DUtil/MActor.hpp>
+#include <MoveBG/MapObjManager.hpp>
+
+class TKukkuBall;
+
+// Unused 0x3B0
+class TKukkuParams : public TSmallEnemyParams {
+public:
+	TKukkuParams(const char*);
+
+	/* 0x2D4 */ TParamRT<f32> mMarchSpeed;
+	/* 0x2E8 */ TParamRT<f32> mTurnSpeed;
+	/* 0x2FC */ TParamRT<f32> mWaterPowerY;
+	/* 0x310 */ TParamRT<f32> mShootSpeed;
+	/* 0x324 */ TParamRT<s32> mShootInterval;
+	/* 0x338 */ TParamRT<f32> mSearchRange;
+	/* 0x34C */ TParamRT<s32> mHabatakiTimer;
+	/* 0x360 */ TParamRT<f32> mAirFric;
+	/* 0x374 */ TParamRT<f32> mUpperVelocityY;
+	/* 0x388 */ TParamRT<f32> mDropSpeed;
+	/* 0x39C */ TParamRT<f32> mDropAngleX;
+};
+
+class TEnemyCoinUnit {
+	TEnemyCoinUnit(int);
+	void init();
+	TMapObjBase* getUnusedItem();
+};
+
+class TKukku : public TSmallEnemy {
+public:
+	TKukku(const char* name = "クック");
+	virtual void bind();
+	virtual void perform(u32 cue, JDrama::TGraphics* graphics);
+	virtual BOOL receiveMessage(THitActor* sender, u32 message);
+	virtual void reset();
+	virtual void control();
+	virtual void init(TLiveManager*);
+	virtual const char** getBasNameTable() const;
+
+	void setAfterDeadEffect();
+	void setDeadAnm();
+	void dropCoins();
+	void updateRotation();
+	void calcRootMatrix();
+	JGeometry::TVec3<f32> calcMomentum(f32 deltaTime);
+	void behaveToWater(THitActor* sender);
+
+	// Unused
+	TKukkuBall* getUnusedBall();
+	f32 getWaterPowerY() const;
+	f32 getWaterDamageRate() const;
+	void changeBck(const char*);
+	BOOL isFindOutMario() const;
+	BOOL isDying() const;
+	BOOL isRecoveringGraph() const;
+	BOOL isFalling() const;
+	void shotBall();
+	void decideFlyingAnm();
+	BOOL doHabataki();
+	void doRecoverToCurPathNode();
+	void doFlyToCurPathNode();
+	void behaveHitTrample();
+	void updateEffect();
+	void initParticle();
+	void initCollision();
+	void initBalls();
+
+	// fabricated
+	s32 getUnk1A4() const { return unk1A4; }
+	s32 getUnk1AC() const { return unk1AC; }
+
+	// fabricated
+	const TKukkuParams* getKukkuParams() const
+	{
+		return (const TKukkuParams*)getSaveParam();
+	}
+
+	// fabricated
+	JGeometry::TVec3<f32> polarXZ(f32 theta, f32 radius)
+	{
+		f32 c = radius * MsCos(theta);
+		f32 s = radius * MsSin(theta);
+		return JGeometry::TVec3<f32>(s, 0.0f, c);
+	}
+
+public:
+	/* 0x194 */ TKukkuBall* mBalls[3];
+	/* 0x1A0 */ TMapObjBase* mMapObj;
+	/* 0x1A4 */ u32 unk1A4;
+	/* 0x1A8 */ u32 unk1A8;
+	/* 0x1AC */ s32 unk1AC;
+	/* 0x1B0 */ s32 unk1B0;
+};
+
+class TKukkuManager : public TSmallEnemyManager {
+public:
+	TKukkuManager(const char* name = "クックマネージャー");
+	virtual void load(JSUMemoryInputStream&);
+	virtual TSpineEnemy* createEnemyInstance();
+	virtual void createModelData();
+	void initJParticle();
+
+	// Unused
+	void initCoins();
+};
+
+// class Thitactor adds all the bloat libraries horrible
+class TKukkuBall : public THitActor {
+public:
+	TKukkuBall(MActor* actor);
+	virtual void init();
+	virtual void perform(u32 cue, JDrama::TGraphics* graphics);
+
+	// UNUSED
+	BOOL isDead() const;
+	void kill();
+	void startToMove(const JGeometry::TVec3<f32>& start,
+	                 const JGeometry::TVec3<f32>& end);
+	void checkHitActors();
+	void bind();
+	void moveObject();
+
+public:
+	/* 0x68 */ MActor* actor;
+	/* 0x6C */ s32 unk6C;
+	/* 0x70 */ JGeometry::TVec3<f32> mVelocity;
+	/* 0x7C */ u32 unk7C;
+};
+
+DECLARE_NERVE(TNerveKukkuRecoverGraph, TLiveActor);
+DECLARE_NERVE(TNerveKukkuPostFall, TLiveActor);
+DECLARE_NERVE(TNerveKukkuFall, TLiveActor);
+DECLARE_NERVE(TNerveKukkuGraphWander, TLiveActor);
+DECLARE_NERVE(TNerveKukkuHit, TLiveActor);
+
+#endif

include/Strategic/ActorTypes.hpp

@@ -314,7 +314,7 @@ enum TActorType {
 	ACTOR_TYPE_ROCKET               = HIT_CATEGORY_ENEMY | 0x2B,
 	ACTOR_TYPE_KUMOKUN              = HIT_CATEGORY_ENEMY | 0x2C,
 	ACTOR_TYPE_AMENBO               = HIT_CATEGORY_ENEMY | 0x2D,
-	ACTOR_TYPE_ENEMY_UNK2E          = HIT_CATEGORY_ENEMY | 0x2E,
+	ACTOR_TYPE_KUKKU_BALL           = HIT_CATEGORY_ENEMY | 0x2E,
 	ACTOR_TYPE_ENEMY_UNK2F          = HIT_CATEGORY_ENEMY | 0x2F,
 	ACTOR_TYPE_BUTTERFLY            = HIT_CATEGORY_ENEMY | 0x30,
 	ACTOR_TYPE_ENEMY_UNK31          = HIT_CATEGORY_ENEMY | 0x31,

include/System/Particles.hpp

@@ -371,6 +371,8 @@ enum E_SMS_EFFECT_LOOP_NORMAL /* 1 */ {
 	KAZEKUN_JPA_MS_KAZE_WIND              = 0x189,
 	KAZEKUN_JPA_MS_KAZE_BLUR              = 0x18A,
 	PARTICLE_MS_YNB_ONPU                  = 0x18B,
+	COOC_JPA_MS_ASE                       = 0x18C,
+	COOC_JPA_MS_HANE                      = 0x18D,
 	AMENBO_JPA_MS_AME_HAMON               = 0x18E,
 	FIREWANWAN_JPA_MS_CAN_HITYUGE         = 0x18F,
 	WIRETRAP_JPA_NS_WRT_BIRI_A            = 0x190,

src/Enemy/Kukku.cpp

@@ -1 +1,626 @@
+#include <Enemy/Kukku.hpp>
+#include <Strategic/ObjModel.hpp>
+#include <Map/PollutionManager.hpp>
+#include <System/EmitterViewObj.hpp>
+#include <Player/MarioAccess.hpp>
+#include <Map/MapData.hpp>
+#include <Strategic/LiveActor.hpp>
+#include <Animal/AnimalBase.hpp>
+#include <Strategic/Strategy.hpp>
+#include <MarioUtil/TexUtil.hpp>
+#include <JSystem/JDrama/JDRNameRefGen.hpp>
+#include <System/Particles.hpp>
+#include <MoveBG/Item.hpp>
+#include <MoveBG/ItemManager.hpp>
+#include <Map/Map.hpp>
+#include <Enemy/Graph.hpp>
+#include <MSound/MSound.hpp>
+#include <macros.h>
 
+// to match __sinit__
+#include <MSound/MSSetSound.hpp>
+#include <MSound/MSoundBGM.hpp>
+
+static const char* tori_bastable[] = {
+	"/scene/tori/bas/tori_back.bas",
+	"/scene/tori/bas/tori_down.bas",
+	nullptr,
+	"/scene/tori/bas/tori_fall_end.bas",
+	"/scene/tori/bas/tori_hit.bas",
+	"/scene/tori/bas/tori_wait.bas",
+};
+
+static const int cDropCoinNumTable[] = { 3, 3, 1, 2 };
+
+TKukkuBall::TKukkuBall(MActor* actor)
+    : THitActor("クック玉")
+    , actor(actor)
+    , unk6C(1)
+    , unk7C(0)
+{
+}
+
+void TKukkuBall::init()
+{
+	initHitActor(ACTOR_TYPE_KUKKU_BALL, 1, HIT_CATEGORY_PLAYER, 30.0f, 30.0f,
+	             0.0f, 0.0f);
+	onHitFilter(HIT_FILTER_NO_COLLISION);
+	onHitFilter(HIT_FILTER_NO_DAMAGE);
+	TIdxGroupObj* group
+	    = static_cast<TIdxGroupObj*>(JDrama::TNameRefGen::search("敵グループ"));
+
+	group->getChildren().push_back(this);
+	const ResTIMG* res = static_cast<const ResTIMG*>(
+	    JKRFileLoader::getGlbResource("/scene/map/pollution/H_ma_rak.bti"));
+
+	if (res)
+		SMS_ChangeTextureAll(actor->getModel()->getModelData(), "K_name_dummy",
+		                     *res);
+}
+
+void TKukkuBall::perform(u32 cue, JDrama::TGraphics* graphics)
+{
+
+	if (checkHitFilter(HIT_FILTER_NO_DAMAGE))
+		return;
+
+	if (cue & CUE_CALC_ANIM) {
+		TPosition3f mtx;
+		mtx.identity33();
+		mtx.setTrans(mPosition);
+		J3DModel* model = actor->getModel();
+		model->setBaseScale(mScaling);
+		actor->getModel()->setBaseTRMtx(mtx);
+		actor->getModel()->calc();
+	}
+
+	if (cue & CUE_MOVE) {
+		checkHitActors();
+		bind();
+	}
+
+	if (!checkHitFilter(HIT_FILTER_NO_DAMAGE))
+		actor->perform(cue, graphics);
+}
+
+void TKukkuBall::moveObject() { }
+
+void TKukkuBall::bind()
+{
+	mVelocity.y -= 0.9f;
+	mVelocity.scale(0.94f);
+
+	JGeometry::TVec3<f32> next = mPosition;
+	next += mVelocity;
+
+	const TBGCheckData* ground;
+	f32 groundHeight
+	    = gpMap->checkGround(next.x, next.y + mAttackHeight, next.z, &ground);
+	groundHeight += 1.0f;
+	if (next.y <= 0.05f + groundHeight)
+		kill();
+
+	gpMap->isTouchedOneWallAndMoveXZ(&next.x, next.y + mAttackHeight, &next.z,
+	                                 mAttackRadius);
+	mPosition = next;
+}
+
+void TKukkuBall::checkHitActors()
+{
+	THitActor** end = mCollisions + mColCount;
+	for (THitActor** it = mCollisions; it != end; ++it) {
+		switch ((*it)->getActorType()) {
+		case ACTOR_TYPE_MARIO:
+			SMS_SendMessageToMario(this, HIT_MESSAGE_ATTACK);
+			kill();
+			break;
+		}
+	}
+}
+
+void TKukkuBall::startToMove(const JGeometry::TVec3<f32>& pos,
+                             const JGeometry::TVec3<f32>& vel)
+{
+	offHitFilter(HIT_FILTER_NO_COLLISION);
+	unk6C &= ~1;
+	mPosition = pos;
+	mVelocity = vel;
+}
+
+void TKukkuBall::kill()
+{
+	onHitFilter(HIT_FILTER_NO_COLLISION);
+	unk6C |= 0x1;
+	gpPollution->pollute(mPosition.x, mPosition.y, mPosition.z, 500.0f);
+}
+
+BOOL TKukkuBall::isDead() const
+{
+	if (checkHitFilter(HIT_FILTER_NO_DAMAGE) && unk7C == 0)
+		return true;
+	return false;
+}
+
+TEnemyCoinUnit::TEnemyCoinUnit(int) { }
+
+void TEnemyCoinUnit::init() { }
+
+TMapObjBase* TEnemyCoinUnit::getUnusedItem() { return nullptr; }
+
+TKukku::TKukku(const char* name)
+    : TSmallEnemy(name)
+    , mMapObj(nullptr)
+{
+}
+
+void TKukku::init(TLiveManager* manager)
+{
+	mManager = manager;
+	mManager->manageActor(this);
+	mMActorKeeper = new TMActorKeeper(mManager, 0x18);
+	mMActor       = mMActorKeeper->createMActor("tori.bmd", 0);
+
+	mSpine->initWith(&TNerveKukkuGraphWander::theNerve());
+
+	mMapObj = TMapObjBaseManager::newAndRegisterObj("mushroom1upR");
+	initBalls();
+	initCollision();
+	initAnmSound();
+	initParticle();
+	unk1A8 = getModel()->getModelData()->unkB0->getIndex("center");
+	reset();
+}
+
+void TKukku::initBalls()
+{
+	TKukkuBall** end = mBalls + ARRAY_COUNT(mBalls);
+	for (TKukkuBall** it = mBalls; it != end; ++it) {
+		*it = new TKukkuBall(mMActorKeeper->createMActor("torifun.bmd", 3));
+		(*it)->init();
+	}
+}
+
+void TKukku::initCollision()
+{
+	initHitActor(ACTOR_TYPE_KUKKU_BALL, 1, HIT_CATEGORY_PLAYER, 30.0f, 30.0f,
+	             100.0f, 100.0f);
+	offHitFilter(HIT_FILTER_NO_COLLISION);
+}
+
+void TKukku::initParticle()
+{
+	SMS_LoadParticle("/scene/tori/jpa/ms_cooc_ase.jpa", COOC_JPA_MS_ASE);
+	SMS_LoadParticle("/scene/tori/jpa/ms_cooc_hane.jpa", COOC_JPA_MS_HANE);
+}
+
+void TKukku::reset()
+{
+	unk1A4   = 0;
+	unk1AC   = 0;
+	mGravity = 0.0f;
+	unk1B0   = 0;
+	onLiveFlag(LIVE_FLAG_AIRBORNE);
+	mScaledBodyRadius = 75.0f;
+}
+
+BOOL TKukku::receiveMessage(THitActor* sender, u32 message)
+{
+	if (checkLiveFlag(LIVE_FLAG_DEAD)) {
+		return false;
+	}
+
+	switch (message) {
+	case HIT_MESSAGE_TRAMPLE:
+	case HIT_MESSAGE_HIP_DROP: {
+		mSpine->reset();
+		mSpine->setNext(&TNerveSmallEnemyDie::theNerve());
+		return true;
+	}
+
+	default:
+		return TSmallEnemy::receiveMessage(sender, message);
+	}
+}
+
+void TKukku::control()
+{
+	if (getUnk1A4() > 0)
+		unk1A4 -= 1;
+
+	TLiveActor::control();
+}
+
+void TKukku::calcRootMatrix()
+{
+	if (isDying()) {
+		JGeometry::TVec3<f32> normal;
+		if (mGroundPlane) {
+			normal.set(getGroundPlane()->getNormal());
+			normal.normalize();
+		} else {
+			normal.set(0.0f, 1.0f, 0.0f);
+		}
+
+		JGeometry::TQuat4<f32> yaw;
+		yaw.setEulerY(mRotation.y * 0.017453294f);
+		JGeometry::TVec3<f32> up(0.0f, 1.0f, 0.0f);
+		JGeometry::TQuat4<f32> tilt;
+		tilt.setRotate(up, normal, 1.0f);
+		tilt.mul(tilt, yaw);
+
+		TPosition3f mtx;
+		mtx.setQT(tilt, mPosition);
+		PSMTXCopy(mtx, getModel()->getBaseTRMtx());
+		getModel()->setBaseScale(mScaling);
+	} else {
+		TSpineEnemy::calcRootMatrix();
+	}
+
+	if (isFalling()) {
+		gpMarioParticleManager->emitAndBindToMtxPtr(
+		    COOC_JPA_MS_HANE, getModel()->getAnmMtx(unk1A8), 1, this);
+	}
+
+	if (getMActor()->checkCurAnm("tori_back", 0)) {
+		gpMarioParticleManager->emitAndBindToMtxPtr(
+		    COOC_JPA_MS_ASE, getModel()->getAnmMtx(unk1A8), 1, this);
+	}
+}
+
+void TKukku::bind() { TLiveActor::bind(); }
+
+void TKukku::perform(u32 cue, JDrama::TGraphics* graphics)
+{
+	TSmallEnemy::perform(cue, graphics);
+
+	for (TKukkuBall** it = mBalls; it != mBalls + ARRAY_COUNT(mBalls); it++)
+		(*it)->perform(cue, graphics);
+}
+
+void TKukku::updateEffect() { }
+
+void TKukku::behaveToWater(THitActor* sender)
+{
+	if (!isFalling() && isRecoveringGraph()) {
+		mSpine->reset();
+		mSpine->setNext(&TNerveKukkuFall::theNerve());
+	}
+}
+
+void TKukku::behaveHitTrample() { }
+
+void TKukku::doFlyToCurPathNode() { }
+
+void TKukku::updateRotation()
+{
+	JGeometry::TVec3<f32> toTarget = mCurrentTarget.getPoint();
+	toTarget.sub(mPosition);
+
+	f32 dist = toTarget.length();
+
+	if (dist < 100.0f) {
+		f32 marchSpeed = getKukkuParams()->mMarchSpeed.get();
+		f32 turnSpeed  = getKukkuParams()->mTurnSpeed.get();
+
+		if (dist <= 2.0f * calcMinimumTurnRadius(marchSpeed, turnSpeed)) {
+			turnSpeed = calcTurnSpeedToReach(marchSpeed, 0.5f * dist);
+		}
+
+		TAnimalBase::getRotationFlyToDir(&mRotation, toTarget, marchSpeed,
+		                                 turnSpeed);
+
+		mRotation.x *= isFalling() ? 0.0f : 1.0f;
+		mRotation.z *= isFalling() ? 0.0f : 1.0f;
+	}
+}
+
+JGeometry::TVec3<f32> TKukku::calcMomentum(f32 deltaTime)
+{
+	JGeometry::TQuat4<f32> quat = SMS_Eular2Quat(mRotation);
+	JGeometry::TVec3<f32> momentum(0.0f, 0.0f, deltaTime);
+
+	quat.rotate(momentum);
+	return momentum;
+}
+
+void TKukku::doRecoverToCurPathNode()
+{
+	updateRotation();
+	mPositionDelta = calcMomentum(getKukkuParams()->mDropAngleX.get());
+}
+
+BOOL TKukku::doHabataki()
+{
+	JGeometry::TVec3<f32> velocity = mVelocity;
+	velocity.scale(getKukkuParams()->mAirFric.get());
+	velocity.y += getKukkuParams()->mUpperVelocityY.get();
+	bool stopped = false;
+	if (-0.1f < velocity.y) {
+		stopped    = true;
+		velocity.y = 0.0f;
+	}
+	mVelocity = velocity;
+	return stopped;
+}
+
+void TKukku::decideFlyingAnm()
+{
+	if (getMActor()->checkCurAnm("tori_back", 0))
+		changeBck("tori_back");
+	else
+		changeBck("tori_wait");
+}
+
+void TKukku::shotBall()
+{
+	TKukkuBall* ball = getUnusedBall();
+	if (ball) {
+		JGeometry::TVec3<f32> velocity(0.0f, 1.0f, 0.0f);
+		velocity.setLength(getKukkuParams()->mShootSpeed.get());
+		getModel()->getModelData()->getJointName()->getIndex("null_osen");
+		ball->startToMove(mPosition, velocity);
+		unk1AC = getKukkuParams()->mShootInterval.get();
+		SMSGetMSound()->startSoundActor(MSD_SE_EN_TORI_SHIT, &mPosition, 0,
+		                                nullptr, 0, 4);
+	}
+}
+
+void TKukku::dropCoins()
+{
+	if (unk1B0 <= 10) {
+		if (unk1B0 == 10 && mMapObj) {
+			unk1B0++;
+			mMapObj->appear();
+			mMapObj->JSGSetTranslation(mPosition);
+			mMapObj->setVelocityAndFlag10(0.0f, 0.0f, 0.0f);
+		} else {
+			int index = 4.0f * MsRandF();
+			if (index < 1)
+				index = 1;
+			else if (index > 3)
+				index = 3;
+			int num = cDropCoinNumTable[index];
+
+			JGeometry::TQuat4<f32> step;
+			step.setEulerY((M_PI * 2) / num);
+			JGeometry::TQuat4<f32> tilt;
+			tilt.setEulerX(M_PI * getKukkuParams()->mDropAngleX.get());
+
+			JGeometry::TVec3<f32> velocity
+			    = polarXZ(mRotation.y, getKukkuParams()->mDropSpeed.get());
+			tilt.rotate(velocity);
+			step.rotate(velocity);
+
+			for (int i = 0; i < num; i++) {
+				TMapObjBase* coin
+				    = gpItemManager->makeObjAppear(ACTOR_TYPE_COIN);
+				if (!coin)
+					break;
+				coin->appear();
+				coin->JSGSetTranslation(mPosition);
+				coin->setVelocityAndFlag10(velocity.x, velocity.y, velocity.z);
+				if (++unk1B0 == 10)
+					break;
+				step.rotate(velocity);
+			}
+		}
+	}
+}
+
+BOOL TKukku::isFalling() const
+{
+	const TNerveBase<TLiveActor>* nerve = mSpine->getLatestNerve();
+	return nerve == &TNerveKukkuFall::theNerve()
+	       || nerve == &TNerveKukkuPostFall::theNerve();
+}
+
+BOOL TKukku::isRecoveringGraph() const
+{
+	return mSpine->getLatestNerve() == &TNerveKukkuRecoverGraph::theNerve();
+}
+
+BOOL TKukku::isDying() const
+{
+	return mSpine->getLatestNerve() == &TNerveSmallEnemyDie::theNerve();
+}
+
+BOOL TKukku::isFindOutMario() const
+{
+	JGeometry::TVec3<f32> toMario = *gpMarioPos;
+	toMario -= mPosition;
+	toMario.y = 0.0f;
+	f32 range = getKukkuParams()->mSearchRange.get();
+	return toMario.squared() < range * range;
+}
+
+void TKukku::changeBck(const char* name)
+{
+	getMActor()->setBck(name);
+	setCurAnmSound();
+}
+
+void TKukku::setDeadAnm() { changeBck("tori_dead"); }
+
+void TKukku::setAfterDeadEffect()
+{
+	TSmallEnemy::setAfterDeadEffect();
+	TSmallEnemyManager* manager = (TSmallEnemyManager*)getManager();
+	gpPollution->stamp(manager->getUnk58(), mPosition.x, mPosition.y,
+	                   mPosition.z, 1000.0f);
+}
+
+f32 TKukku::getWaterDamageRate() const { return 1.0f; }
+
+f32 TKukku::getWaterPowerY() const
+{
+	return getKukkuParams()->mWaterPowerY.get();
+}
+
+TKukkuBall* TKukku::getUnusedBall()
+{
+	for (TKukkuBall** it = mBalls; it != mBalls + ARRAY_COUNT(mBalls); ++it)
+		if ((*it)->isDead())
+			return *it;
+	return nullptr;
+}
+
+TKukkuParams::TKukkuParams(const char* path)
+    : TSmallEnemyParams(path)
+    , PARAM_INIT(mMarchSpeed, 3.0f)
+    , PARAM_INIT(mTurnSpeed, 0.2f)
+    , PARAM_INIT(mWaterPowerY, 12.0f)
+    , PARAM_INIT(mShootSpeed, 1.0f)
+    , PARAM_INIT(mShootInterval, 60)
+    , PARAM_INIT(mSearchRange, 800.0f)
+    , PARAM_INIT(mHabatakiTimer, 45)
+    , PARAM_INIT(mAirFric, 0.97f)
+    , PARAM_INIT(mUpperVelocityY, 0.0f)
+    , PARAM_INIT(mDropSpeed, 5.0f)
+    , PARAM_INIT(mDropAngleX, -0.25f)
+{
+	TParams::load(mPrmPath);
+}
+
+TKukkuManager::TKukkuManager(const char* name)
+    : TSmallEnemyManager(name)
+{
+}
+
+void TKukkuManager::load(JSUMemoryInputStream& stream)
+{
+	TKukkuParams* params = new TKukkuParams("/enemy/kukku.prm");
+	unk38                = params;
+	params->mSLAttackRadius.set(30);
+	params->mSLAttackHeight.set(30);
+	params->mSLDamageRadius.set(100);
+	params->mSLDamageHeight.set(100);
+	params->mSLBodyRadius.set(5.0f);
+
+	TSmallEnemyManager::load(stream);
+}
+
+void TKukkuManager::initCoins() { }
+
+void TKukkuManager::createModelData()
+{
+	static const TModelDataLoadEntry entry[] = {
+		"tori.bmd",
+		0,
+		0,
+	};
+
+	createModelDataArray(entry);
+}
+
+const char** TKukku::getBasNameTable() const { return tori_bastable; }
+
+DEFINE_NERVE(TNerveKukkuGraphWander, TLiveActor)
+{
+	TKukku* kukku = static_cast<TKukku*>(spine->getBody());
+
+	if (spine->getTime() == 0) {
+		JGeometry::TVec3<f32> zero(0.0f, 0.0f, 0.0f);
+		kukku->mVelocity        = zero;
+		kukku->unk124->mPrevIdx = -1;
+		kukku->goToShortestNextGraphNode();
+		kukku->decideFlyingAnm();
+	}
+
+	if (kukku->isReachedToGoal()) {
+		kukku->goToRandomNextGraphNode();
+		if (!kukku->getMActor()->checkCurAnm("tori_wait", 0)) {
+			kukku->changeBck("tori_wait");
+		}
+	}
+
+	if (kukku->isFindOutMario()) {
+		if (kukku->getUnk1AC() >= 0)
+			kukku->unk1AC--;
+		else
+			kukku->shotBall();
+	}
+
+	kukku->doRecoverToCurPathNode();
+	return false;
+}
+
+DEFINE_NERVE(TNerveKukkuHit, TLiveActor)
+{
+	TKukku* kukku = (TKukku*)spine->getBody();
+	if (spine->getTime() == 0) {
+		kukku->changeBck("tori_hit");
+	}
+
+	if (kukku->checkCurAnmEnd(0)) {
+		spine->pushAfterCurrent(&TNerveKukkuGraphWander::theNerve());
+		return true;
+	}
+	return false;
+}
+
+DEFINE_NERVE(TNerveKukkuFall, TLiveActor)
+{
+	TKukku* kukku = static_cast<TKukku*>(spine->getBody());
+
+	if (spine->getTime() == 0) {
+		kukku->changeBck("tori_back");
+		J3DFrameCtrl* ctrl = kukku->getMActor()->getFrameCtrl(ANM_TYPE_BCK);
+		ctrl->setRate(2.0f * SMSGetAnmFrameRate());
+		kukku->mVelocity
+		    = JGeometry::TVec3<f32>(0.0f, -kukku->getWaterPowerY(), 0.0f);
+		kukku->dropCoins();
+	}
+
+	if (!kukku->isAirborne()) {
+		SMS_EasyEmitParticle(PARTICLE_MS_POPO_BOMB_A, &kukku->mPosition,
+		                     nullptr, JGeometry::TVec3<f32>(1.0f, 1.0f, 1.0f));
+		SMS_EasyEmitParticle(PARTICLE_MS_POPO_BOMB_B, &kukku->mPosition,
+		                     nullptr, JGeometry::TVec3<f32>(1.0f, 1.0f, 1.0f));
+		spine->pushAfterCurrent(&TNerveSmallEnemyDie::theNerve());
+		return true;
+	}
+
+	if (kukku->doHabataki()) {
+		spine->pushAfterCurrent(&TNerveKukkuRecoverGraph::theNerve());
+		return true;
+	}
+	return false;
+}
+
+DEFINE_NERVE(TNerveKukkuPostFall, TLiveActor)
+{
+	TKukku* kukku = static_cast<TKukku*>(spine->getBody());
+
+	if (spine->getTime() == 0) {
+		kukku->changeBck("tori_back");
+		kukku->mVelocity = JGeometry::TVec3<f32>(0.0f, 0.0f, 0.0f);
+	}
+
+	if (!kukku->checkCurAnmEnd(0)
+	    || kukku->getKukkuParams()->mHabatakiTimer.get() >= spine->getTime()) {
+		return false;
+	}
+
+	spine->pushAfterCurrent(&TNerveKukkuGraphWander::theNerve());
+	return true;
+}
+
+DEFINE_NERVE(TNerveKukkuRecoverGraph, TLiveActor)
+{
+	TKukku* kukku = static_cast<TKukku*>(spine->getBody());
+
+	if (spine->getTime() == 0) {
+		kukku->changeBck("tori_back");
+		kukku->mVelocity = JGeometry::TVec3<f32>(0.0f, 0.0f, 0.0f);
+	}
+
+	if (kukku->getKukkuParams()->mHabatakiTimer.get() < spine->getTime()) {
+		spine->pushAfterCurrent(&TNerveKukkuGraphWander::theNerve());
+		return true;
+	}
+
+	kukku->doRecoverToCurPathNode(); // calcMomentum here gets out-of-line...
+	                                 // double layer?
+
+	return false;
+}

src/Player/MarioCheckCol.cpp

@@ -324,7 +324,7 @@ void TMario::checkCollision()
 		case ACTOR_TYPE_ENEMY_UNK1F:
 		case ACTOR_TYPE_EFFECT_OBJ:
 		case ACTOR_TYPE_HAUNT_LEG:
-		case ACTOR_TYPE_ENEMY_UNK2E:
+		case ACTOR_TYPE_KUKKU_BALL:
 		case ACTOR_TYPE_ENEMY_UNK31:
 		case ACTOR_TYPE_DORO_HANE_KURI:
 		case ACTOR_TYPE_CASINORULET:

src/Player/MarioReceiveMsg.cpp

@@ -488,7 +488,7 @@ BOOL TMario::receiveMessage(THitActor* sender, u32 message)
 		case ACTOR_TYPE_YUMBO:
 		case ACTOR_TYPE_KUMOKUN:
 		case ACTOR_TYPE_AMENBO:
-		case ACTOR_TYPE_ENEMY_UNK2E:
+		case ACTOR_TYPE_KUKKU_BALL:
 		case ACTOR_TYPE_ENEMY_UNK2F:
 		case ACTOR_TYPE_DEBU_TELESA:
 		case ACTOR_TYPE_ENEMY_DAMAGE_OBJ:

src/System/MarNameRefGen_Enemy.cpp

@@ -21,6 +21,7 @@
 #include <Enemy/FireWanwan.hpp>
 #include <Enemy/Beam.hpp>
 #include <Enemy/Amenbo.hpp>
+#include <Enemy/Kukku.hpp>
 #include <Enemy/Kumokun.hpp>
 #include <Enemy/EggGen.hpp>
 #include <Enemy/Igaiga.hpp>
@@ -442,13 +443,11 @@ JDrama::TNameRef* TMarNameRefGen::getNameRef_Enemy(const char* name) const
 		return gpBeamManager;
 	}
 
-	// TODO:
-	// if ( strcmp( name, "KukkuManager" ) == 0 )
-	//     return new TKukkuManager;
+	if (strcmp(name, "KukkuManager") == 0)
+		return new TKukkuManager;
 
-	// TODO:
-	// if ( strcmp( name, "Kukku" ) == 0 )
-	//     return new TKukku;
+	if (strcmp(name, "Kukku") == 0)
+		return new TKukku;
 
 	if (strcmp(name, "KumokunManager") == 0)
 		return new TKumokunManager;