Petari/source/Game/Enemy/Poihana.cpp

#include "Game/Enemy/Poihana.hpp"
#include "Game/Util.hpp"
#include "JSystem/JMath/JMath.hpp"

namespace {
	const Vec sNormalBinderPos = { 0.0f, 130.0f, 120.0f };
	const Vec sTrampleBinderPos = { 0.0f, 150.0f, 0.0f };
};

Poihana::Poihana(const char *pName) : LiveActor(pName) {
	mAnimScaleCtrl = nullptr;
	mBindStarPointer = nullptr;
	mCamInfo = nullptr;
	mBindedActor = nullptr;
	mLaunchIntensity = 0.0f;
	mRespawnPos.setInline(0.0f);
	_AC = 0.0f;
	_B0 = 0.0f;
	mHomePos.setInline(0.0f);
	_C0 = 1.0f;
	mBoundTimer = -1;
	mBehavior = POIHANA_BEHAVIOR_NORMAL;
	mCanDrown = false;
	mWaterColumn = nullptr;
	mIsActive = false;
	_E5 = 0;
}

/*void Poihana::init(const JMapInfoIter &rIter) {
	MR::initDefaultPos(this, rIter);
	MR::initActorCamera(this, rIter, &mCamInfo);
	initModelManagerWithAnm("Poihana", nullptr, false);

	MR::connectToSceneEnemy(this);

	// Initialize sensors
	initHitSensor(2);
	MR::addHitSensorPriorBinder(this, "binder", 8, 125.0f, sNormalBinderPos);
	MR::addHitSensorAtJoint(this, "body", "Body", 30, 8, 70.0f, TVec3f(0.0f, 0.0f, 0.0f));

	// Initialize binder
	bool useSmallBinder = false;
	MR::getJMapInfoArg7NoInit(rIter, &useSmallBinder);

	if (useSmallBinder) {
		initBinder(100.0f, 100.0f, 0);
	}
	else {
		initBinder(150.0f, 150.0f, 0);
	}

	mIsActive = true;
	MR::setGroupClipping(this, rIter, 0x20);
	initEffectKeeper(1, nullptr, false);
	initSound(4, false);

	// Initialize 2P behavior
	MR::initStarPointerTarget(this, 150.0f, TVec3f(0.0f, 100.0f, 0.0f));
	mAnimScaleCtrl = new AnimScaleController(nullptr);
	mBindStarPointer = new WalkerStateBindStarPointer(this, mAnimScaleCtrl);

	MR::initShadowVolumeSphere(this, 80.0f);
	MR::addToAttributeGroupSearchTurtle(this);

	mRespawnPos.set(mPosition);
	mHomePos.set(mRespawnPos);

	// Calculate launch intensity, thanks to Shibbo for helping me on that one
	s32 launchIntensity = 1000;
	MR::getJMapInfoArg0NoInit(rIter, &launchIntensity);
	float launchIntensityF = 2.0f * launchIntensity;

	if (launchIntensityF > 0) {
		f32 factor;
		f32 reciprocal = __frsqrte(launchIntensityF);
		factor = reciprocal * launchIntensityF;
		launchIntensityF = -(factor * reciprocal - 3.0f) * factor * 0.5f;
	}

	mLaunchIntensity = -launchIntensityF;

	// Setup color
	//s32 color = 0;
	//MR::getJMapInfoArg2NoInit(rIter, &color);
	//MR::startBtpAndSetFrameAndStop(this, "ColorChange", color);

	// Setup behaviors
	//MR::getJMapInfoArg1NoInit(rIter, &mActiveRange);
	MR::getJMapInfoArg3NoInit(rIter, &mBehavior);
	MR::getJMapInfoArg4NoInit(rIter, &mCanDrown);

	if (mCanDrown) {
		mWaterColumn = MR::createModelObjMapObj("エフェクト水柱", "WaterColumn", (MtxPtr)getBaseMtx());
		mWaterColumn->mScale.setAll(2.0f);
	}

	MR::tryCreateMirrorActor(this, nullptr);
	//MR::useStageSwitchAwake(this, rIter);

	if (mBehavior == POIHANA_BEHAVIOR_SLEEP) {
		initNerve(&NrvPoihana::PoihanaNrvSleep::sInstance);
	}
	else {
		initNerve(&NrvPoihana::PoihanaNrvWait::sInstance);
	}

	makeActorAppeared();
}*/

void Poihana::initAfterPlacement() {
	TVec3f gravityNegated;
	JGeometry::negateInternal((f32 *)&mGravity, (f32 *)&gravityNegated);
	TPos3f baseMtx;
	MR::makeMtxUpNoSupportPos(&baseMtx, gravityNegated, mPosition);
	MR::setBaseTRMtx(this, baseMtx);
	MR::calcFrontVec(&mFrontVec, this);
	MR::trySetMoveLimitCollision(this);
}

void Poihana::control() {
	if (!isNerve(&NrvPoihana::PoihanaNrvHide::sInstance)) {
		mAnimScaleCtrl->updateNerve();
		calcBound();
		controlVelocity();
		calcMyGravity();

		if (!tryDrown() && !tryDPDSwoon() && tryHipDropShock()) {
			return;
		}
	}
}

void Poihana::calcAndSetBaseMtx() {
	TPos3f baseMtx;
	MR::calcMtxFromGravityAndZAxis(&baseMtx, this, mGravity, mFrontVec);

	if (isNerveTypeWalkOrWait()) {
		MR::blendMtx((MtxPtr)getBaseMtx(), (MtxPtr)&baseMtx, 0.3f, (MtxPtr)&baseMtx);
	}

	MR::setBaseTRMtx(this, baseMtx);

	TVec3f newScale;
	newScale.multPS(mScale, mAnimScaleCtrl->_C);
	MR::setBaseScale(this, newScale);
}

// This inline function might be used elsewhere too? It seems unusual for it to be used once
inline void calcRepelVector(const TVec3f &agent, const TVec3f &object, TVec3f& dst) {
	JMAVECScaleAdd(agent.toCVec(), object.toCVec(), dst.toVec(), -agent.dot(object));
}

void Poihana::attackSensor(HitSensor *pSender, HitSensor *pReceiver) {
	bool ret = false;

	if (MR::isSensorPlayer(pReceiver) || MR::isSensorEnemy(pReceiver) ||
	    MR::isSensorMapObj(pReceiver)) {
		ret = true;
	}

	if (!ret) {
		return;
	}

	if (MR::isSensorEnemy(pSender)) {
		if (MR::isSensorPlayer(pReceiver)) {
			contactMario(pSender, pReceiver);
		}

		if (MR::sendMsgPush(pReceiver, pSender)) {
			if (MR::isSensorPlayer(pReceiver)) {
				ret = false;
				if (isNerve(&NrvPoihana::PoihanaNrvShock::sInstance) ||
				    isNerve(&NrvPoihana::PoihanaNrvSwoonLand::sInstance) ||
				    isNerve(&NrvPoihana::PoihanaNrvSwoon::sInstance) ||
				    isNerve(&NrvPoihana::PoihanaNrvRecover::sInstance)) {
					ret = true;
				}

				if (ret) {
					return;
				}
			}

			TVec3f pushVelocity(mPosition - pReceiver->mActor->mPosition);
			MR::normalizeOrZero(&pushVelocity);

			if (mVelocity.dot(pushVelocity) < 0.0f) {
				const TVec3f& velocity = mVelocity;
				calcRepelVector(pushVelocity, velocity, mVelocity);
			}
		}
	}
}

bool Poihana::receiveMsgPush(HitSensor *pSender, HitSensor *pReceiver) {
	if (MR::isSensorEnemy(pSender) || MR::isSensorMapObj(pSender)) {
		TVec3f pushOffset(mPosition - pSender->mActor->mPosition);
		MR::normalizeOrZero(&pushOffset);
		JMAVECScaleAdd(pushOffset.toCVec(), mVelocity.toCVec(), mVelocity.toVec(), 1.5f);

		return true;
	}

	return false;
}

bool Poihana::receiveMsgPlayerAttack(u32 msg, HitSensor *pSender, HitSensor *pReceiver) {
	if (MR::isMsgStarPieceAttack(msg)) {
		return true;
	}

	if (MR::isMsgPlayerTrample(msg) || MR::isMsgPlayerHipDrop(msg)) {
		bool flag = false;

		if (isNerve(&NrvPoihana::PoihanaNrvDrown::sInstance) ||
		    isNerve(&NrvPoihana::PoihanaNrvHide::sInstance) ||
		    isNerve(&NrvPoihana::PoihanaNrvAppear::sInstance) ||
		    isNerve(&NrvPoihana::PoihanaNrvShock::sInstance)) {
			flag = true;
		}

		if (flag) {
			goto here;
		}

		flag = false;
		if (isNerve(&NrvPoihana::PoihanaNrvSleepStart::sInstance) ||
		    isNerve(&NrvPoihana::PoihanaNrvSleep::sInstance) ||
		    isNerve(&NrvPoihana::PoihanaNrvGetUp::sInstance)) {
			flag = true;
		}

		if (flag) {
here:
			startBound();
			MR::startSound(this, "SE_EV_POIHANA_TRAMPLE", -1, -1);

			if (MR::isMsgPlayerHipDrop(msg)) {
				MR::sendMsgAwayJump(pSender, pReceiver);
			}

			return true;
		}

		MR::setSensorOffset(this, "binder", sTrampleBinderPos);
		MR::setSensorRadius(this, "binder", 125.0f);
		MR::validateHitSensor(this, "binder");
	}

	if (MR::isMsgPlayerHitAll(msg) && tryShock()) {
		MR::stopSceneForDefaultHit(3);
		return true;
	}

	return false;
}

bool Poihana::receiveMsgEnemyAttack(u32 msg, HitSensor *pSender, HitSensor *pReceiver) {
	if (MR::isMsgExplosionAttack(msg) && tryShock()) {
		return true;
	}

	return false;
}

/*bool Poihana::receiveOtherMsg(u32 msg, HitSensor *pSender, HitSensor *pReceiver) {
	if (MR::isMsgAutoRushBegin(msg) && MR::isSensorPlayer(pSender)) {
		if (isNerve(&NrvPoihana::PoihanaNrvShootUpCharge::sInstance)) {
			return false;
		}
		else if (MR::isOnGroundPlayer()) {
			if (isNerve(&NrvPoihana::PoihanaNrvShootUp::sInstance)) {
				if (getNerveStep() < 30) {
					if (!tryToStartBind(pSender)) {
						return false;
					}
				}
			}
			else if (isNerve(&NrvPoihana::PoihanaNrvShootUpCharge::sInstance) ||
			         !MR::isNear(pSender, pReceiver, 100.0f)) {
				return false;
			}
			else {
				setNerve(&NrvPoihana::PoihanaNrvShootUpCharge::sInstance);
			}
		}
		else if (tryToStartBind(pSender)) {
			setNerve(&NrvPoihana::PoihanaNrvShootUp::sInstance);
			return true;
		}
	}
	else if (MR::isMsgUpdateBaseMtx(msg) && mBindedActor) {
		updateBindActorMtx();
		return true;
	}

	return false;
}*/

void Poihana::exeNonActive() {
	if (MR::isFirstStep(this)) {
		mVelocity.zero();
		MR::offBind(this);
		MR::offCalcShadow(this, nullptr);
		MR::offCalcAnim(this);

		mIsActive = false;

		MR::invalidateHitSensors(this);
	}

	if (MR::isNearPlayerAnyTime(this, 3500.0f)) {
		if (mBehavior == POIHANA_BEHAVIOR_SLEEP) {
			setNerve(&NrvPoihana::PoihanaNrvSleep::sInstance);
		}
		else {
			setNerve(&NrvPoihana::PoihanaNrvWait::sInstance);
		}
	}
}

void Poihana::endNonActive() {
	MR::onBind(this);
	MR::onCalcShadow(this, nullptr);
	MR::onCalcAnim(this);

	mIsActive = true;

	MR::setSensorOffset(this, "binder", sNormalBinderPos);
	MR::setSensorRadius(this, "binder", 125.0f);
	MR::validateHitSensor(this, "binder");
	MR::validateHitSensors(this);
}

void Poihana::exeWait() {
	if (MR::isFirstStep(this)) {
		MR::startBckNoInterpole(this, "Wait");
		MR::setSensorOffset(this, "binder", sNormalBinderPos);
		MR::setSensorRadius(this, "binder", 125.0f);
		MR::validateHitSensor(this, "binder");
	}

	if (MR::isNearPlayer(this, 800.0f)) {
		setNerve(&NrvPoihana::PoihanaNrvSearch::sInstance);
	}
	else if (MR::isGreaterStep(this, 180)) {
		setNerve(&NrvPoihana::PoihanaNrvWalkAround::sInstance);
	}
	else {
		tryNonActive();
	}
}

void Poihana::exeWalkAround() {
	if (MR::isFirstStep(this)) {
		if (!MR::isBckPlaying(this, "Walk")) {
			MR::startBck(this, "Walk", nullptr);
		}

		mRandDir = MR::getRandom((s32)-2, (s32)2);
	}

	MR::rotateVecDegree(&mFrontVec, mGravity, mRandDir);
	JMAVECScaleAdd(mFrontVec.toCVec(), mVelocity.toCVec(), mVelocity.toVec(), 0.5f);

	if (isNeedForBackHome()) {
		setNerve(&NrvPoihana::PoihanaNrvGoBack::sInstance);
	}

	else if (MR::isNearPlayer(this, 800.0f)) {
		setNerve(&NrvPoihana::PoihanaNrvSearch::sInstance);
	}

	else if (MR::isGreaterStep(this, 120)) {
		if (mBehavior == POIHANA_BEHAVIOR_SLEEP) {
			setNerve(&NrvPoihana::PoihanaNrvSleepStart::sInstance);
		}
		else {
			setNerve(&NrvPoihana::PoihanaNrvWait::sInstance);
		}
	}
}

void Poihana::exeSleepStart() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "SleepStart", nullptr);
		MR::startSound(this, "SE_EV_POIHANA_SLEEP_START", -1, -1);
		MR::invalidateHitSensor(this, "binder");
	}

	if (MR::isBckStopped(this)) {
		setNerve(&NrvPoihana::PoihanaNrvSleep::sInstance);
	}
}

void Poihana::exeSleep() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "Sleep", nullptr);
		MR::invalidateHitSensor(this, "binder");
	}

	if (isNeedForGetUp()) {
		setNerve(&NrvPoihana::PoihanaNrvGetUp::sInstance);
	}
	else {
		tryNonActive();
	}
}

void Poihana::exeGetUp() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "GetUp", nullptr);
		MR::startSound(this, "SE_EV_POIHANA_WAKEUP", -1, -1);
		MR::startSound(this, "SE_EM_POIHANA_WAKEUP", -1, -1);
	}

	if (MR::isBckStopped(this)) {
		MR::setSensorOffset(this, "binder", sNormalBinderPos);
		MR::setSensorRadius(this, "binder", 125.0f);
		MR::validateHitSensor(this, "binder");
		setNerve(&NrvPoihana::PoihanaNrvWait::sInstance);
	}
}

void Poihana::exeSearch() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "Search", nullptr);
		MR::startSound(this, "SE_EV_POIHANA_FIND", -1, -1);
	}

	MR::turnDirectionToTargetUseGroundNormalDegree(this, &mFrontVec, *MR::getPlayerPos(), 4.0f);

	if (MR::isBckStopped(this)) {
		setNerve(&NrvPoihana::PoihanaNrvChasePlayer::sInstance);
	}
}

void Poihana::exeChasePlayer() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "Run", nullptr);
		MR::setSensorOffset(this, "binder", sNormalBinderPos);
		MR::setSensorRadius(this, "binder", 125.0f);
		MR::validateHitSensor(this, "binder");
	}

	MR::turnDirectionToTargetUseGroundNormalDegree(this, &mFrontVec, *MR::getPlayerPos(), 4.0f);
	JMAVECScaleAdd(mFrontVec.toCVec(), mVelocity.toCVec(), mVelocity.toVec(), 0.5f);

	if (isNeedForBackHome()) {
		setNerve(&NrvPoihana::PoihanaNrvGoBack::sInstance);
	}
}

void Poihana::exeShootUpCharge() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "ThrowStart", nullptr);
	}

	TVec3f& gravity = mGravity;
	f32 dot = gravity.dot(mVelocity);
	mVelocity.scale(dot, gravity);

	if (MR::isBckStopped(this)) {
		setNerve(&NrvPoihana::PoihanaNrvShootUp::sInstance);
	}
}

/*void Poihana::exeShootUp() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "Throw", nullptr);
		MR::startSound(this, "SE_EV_POIHANA_SHOOT_UP", -1, -1);
		MR::startActorCameraNoTarget(this, mCamInfo, -1);
	}

	f32 dot = mGravity.dot(mVelocity);
	mVelocity.scale(dot, mGravity);

	if (MR::isStep(this, 2)) {
		endBind();
		MR::invalidateHitSensor(this, "binder");
	}

	if (MR::isStep(this, 30)) {
		MR::setSensorOffset(this, "binder", sNormalBinderPos);
		MR::setSensorRadius(this, "binder", 125.0f);
		MR::validateHitSensor(this, "binder");
	}

	if (MR::isBckStopped(this)) {
		if (mBehavior == POIHANA_BEHAVIOR_NEW_HOME) {
			mHomePos.set(mPosition);
			setNerve(&NrvPoihana::PoihanaNrvWalkAround::sInstance);
		}
		else {
			setNerve(&NrvPoihana::PoihanaNrvGoBack::sInstance);
		}
	}
}*/

void Poihana::endShootUp() {
	endBind();

	MR::setSensorOffset(this, "binder", sNormalBinderPos);
	MR::setSensorRadius(this, "binder", 125.0f);
	MR::validateHitSensor(this, "binder");

	MR::endActorCamera(this, mCamInfo, true, -1);
}

void Poihana::exeGoBack() {
	if (MR::isFirstStep(this) && !MR::isBckPlaying(this, "Walk")) {
		MR::startBck(this, "Walk", nullptr);
	}

	MR::turnDirectionToTargetUseGroundNormalDegree(this, &mFrontVec, mHomePos, 2.0f);
	JMAVECScaleAdd(mFrontVec.toCVec(), mVelocity.toCVec(), mVelocity.toVec(), 0.5f);

	if (MR::isNearPlayer(this, 800.0f) && MR::isGreaterStep(this, 120)) {
		setNerve(&NrvPoihana::PoihanaNrvSearch::sInstance);
	}
	else if (MR::isNear(this, mHomePos, 100.0f)) {
		setNerve(&NrvPoihana::PoihanaNrvWait::sInstance);
	}
}

void Poihana::exeShock() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "PunchDamage", nullptr);
		MR::startBlowHitSound(this);
		MR::invalidateHitSensor(this, "binder");
	}

	if (MR::isOnGround(this) && MR::isGreaterStep(this, 12)) {
		setNerve(&NrvPoihana::PoihanaNrvSwoon::sInstance);
	}
}

void Poihana::exeSwoonLand() {
	if (MR::isFirstStep(this)) {
		MR::startBckNoInterpole(this, "SwoonLand");
		MR::startSound(this, "SE_EV_POIHANA_SWOON", -1, -1);
	}

	if (MR::isBckStopped(this)) {
		setNerve(&NrvPoihana::PoihanaNrvSwoon::sInstance);
	}
}

void Poihana::exeSwoon() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "Swoon", nullptr);
	}

	MR::startLevelSound(this, "SE_EM_LV_SWOON_S", -1, -1, -1);

	if (MR::isStep(this, 110)) {
		setNerve(&NrvPoihana::PoihanaNrvRecover::sInstance);
	}
}

void Poihana::exeRecover() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "Recover", nullptr);
		MR::startSound(this, "SE_EM_POIHANA_RECOVER", -1, -1);
		MR::startSound(this, "SE_EV_POIHANA_RECOVER", -1, -1);
		mScale.setInline(1.0f);
	}

	if (MR::isBckStopped(this)) {
		MR::setSensorOffset(this, "binder", sNormalBinderPos);
		MR::setSensorRadius(this, "binder", 125.0f);
		MR::validateHitSensor(this, "binder");
		setNerve(&NrvPoihana::PoihanaNrvWait::sInstance);
	}
}

// Needs to be reviewed
void Poihana::exeShake() {
	f32 _f31 = 0.2f - 0.01f * getNerveStep();
	f32 scale = MR::sinDegree(getNerveStep() * 0.01745329251f) * _f31 + 36.0f;
	mScale.setInline(scale);

	if (MR::isStep(this, 20)) {
		mScale.setInline(1.0f);
		setNerve(&NrvPoihana::PoihanaNrvSearch::sInstance);
	}
}

void Poihana::exeDrown() {
	if (MR::isFirstStep(this)) {
		MR::startBck(this, "Drown", nullptr);
		MR::invalidateClipping(this);
		MR::invalidateHitSensors(this);
		MR::startSound(this, "SE_EM_FALL_INTO_WATER_S", -1, -1);

		mWaterColumn->appear();
		MR::tryStartAllAnim(mWaterColumn, "Splash");
	}

	if (MR::isBckStopped(this)) {
		setNerve(&NrvPoihana::PoihanaNrvHide::sInstance);
	}
}

void Poihana::exeHide() {
	if (MR::isFirstStep(this)) {
		MR::startSound(this, "SE_EM_EXPLODE_S_WATER", -1, -1);
		MR::emitEffect(this, "DeathWater");
		MR::hideModel(this);
	}

	if (MR::isStep(this, 150)) {
		setNerve(&NrvPoihana::PoihanaNrvAppear::sInstance);
	}
}

void Poihana::exeAppear() {
	if (MR::isFirstStep(this)) {
		MR::resetPosition(this, mRespawnPos);
		MR::emitEffect(this, "Appear");
	}

	if (MR::isLessStep(this, 60)) {
		MR::startLevelSound(this, "SE_EM_LV_POIHANA_REVIVE_EFFECT", -1, -1, -1);
	}

	if (MR::isStep(this, 60)) {
		MR::showModel(this);
		MR::startBck(this, "Appear", nullptr);
		MR::startSound(this, "SE_EM_POIHANA_REVIVE_APPEAR", -1, -1);
	}
	else if (MR::isBckStopped(this) && MR::isGreaterStep(this, 60)) {
		MR::validateClipping(this);
		MR::validateHitSensors(this);
		MR::setSensorOffset(this, "binder", sNormalBinderPos);
		MR::setSensorRadius(this, "binder", 125.0f);
		MR::validateHitSensor(this, "binder");
		setNerve(&NrvPoihana::PoihanaNrvWait::sInstance);
	}
}

void Poihana::exeDPDSwoon() {
	if (MR::isFirstStep(this)) {
		MR::invalidateHitSensor(this, "Binder");
	}

	MR::updateActorStateAndNextNerve(this, (ActorStateBaseInterface*)mBindStarPointer,
	                                 &NrvPoihana::PoihanaNrvWait::sInstance);
}

void Poihana::endDPDSwoon() {
	mBindStarPointer->kill();

	MR::setSensorOffset(this, "binder", sNormalBinderPos);
	MR::setSensorRadius(this, "binder", 125.0f);
	MR::validateHitSensor(this, "binder");
}

bool Poihana::tryToStartBind(HitSensor* pSender) {
	if (mBindedActor != nullptr) {
		return false;
	}

	LiveActor *bindedActor = pSender->mActor;
	if (MR::isInWater(bindedActor, TVec3f(0.0f, 0.0f, 0.0f))) {
		return false;
	}

	MR::tryRumblePadMiddle(this, 0);
	mBindedActor = pSender->mActor;
	MR::startBckPlayer("Rise", (const char *)nullptr);
	MR::invalidateClipping(this);
	return true;
}

void Poihana::updateBindActorMtx() {
	TPos3f binderMtx;
	MR::makeMtxTR(binderMtx.toMtxPtr(), mBindedActor);
	MR::setBaseTRMtx(mBindedActor, binderMtx);
}

void Poihana::endBind() {
	MR::validateClipping(this);

	if (MR::isPlayerInRush()) {
		TVec3f jumpVec;
		jumpVec.scale(-mLaunchIntensity, mGravity);
		MR::endBindAndPlayerJump(this, jumpVec, 0);
		MR::startSound(this, "SE_PM_HELI_JUMP", -1, -1);
	}

	mBindedActor = nullptr;
}

void Poihana::startBound() {
	mBoundTimer = 0;
	mScale.setInline(1.0f);
}

/*
* This function calculates Poihana's scale for 40 frames after being trampled. This is
* used to simulate the "vibrating" visual effect. This is not 1:1 the same as in SMG1,
* but it looks VERY similar and appears to be even more efficient compared to SMG1's
* unusually complicated calculations.
*/
/*void Poihana::calcBound() {
	if (mBoundTimer != -1) {
		f32 scale = 1.0f;

		if (mBoundTimer < 40) {
			scale = 0.05f * sin(0.393f * mBoundTimer) + 1.0f;
			mBoundTimer++;
		}
		else {
			mBoundTimer = -1;
		}

		mScale.setAll(scale);
	}
}*/

void Poihana::contactMario(HitSensor *pSender, HitSensor *pReceiver) {
	bool isShooting;

	if (!isNerveTypeWalkOrWait()) {
		isShooting = false;
		if (isNerve(&NrvPoihana::PoihanaNrvShootUpCharge::sInstance) ||
		    isNerve(&NrvPoihana::PoihanaNrvShootUp::sInstance)) {
			isShooting = true;
		}
	} else {
		goto doFlip;
	}

	if (isShooting) {
doFlip:
		if (!isBackAttack(pReceiver)) {
			return;
		}

		if (MR::sendMsgEnemyAttackFlipWeak(pReceiver, pSender)) {
			setNerve(&NrvPoihana::PoihanaNrvShake::sInstance);
		}
	} else if (isNerve(&NrvPoihana::PoihanaNrvSleep::sInstance)) {
			setNerve(&NrvPoihana::PoihanaNrvGetUp::sInstance);
	}
}

// Needs review
/*void Poihana::controlVelocity() {
	if (!mIsActive) {
		return;
	}

	// Calculate front vector
	TVec3f gravity;
	if (MR::isBindedGround(this)) {
		gravity.set(-*MR::getGroundNormal(this));
	}
	else {
		gravity.set(mGravity);
	}

	TVec3f frontVec(mFrontVec);
	MR::turnVecToPlane(&mFrontVec, frontVec, gravity);

	// Calculate velocity
	if (MR::isBindedGround(this)) {
		f32 dot = mFrontVec.dot(mVelocity) * -1.0f;

		TVec3f addVel;
		JMAVECScaleAdd(mFrontVec.toCVec(), mVelocity.toCVec(), addVel.toVec(), dot);
		addVel.scale(0.8f);

		mVelocity.scale(mFrontVec.dot(mVelocity), mFrontVec);
		mVelocity.add(addVel);

		if (mVelocity.dot(gravity) > 0.0f) {
			dot = gravity.dot(mVelocity) * -1.0f;
			JMAVECScaleAdd(gravity.toCVec(), mVelocity.toCVec(), mVelocity.toVec(), dot);
		}

		mVelocity.scale(0.95f);
	}

	JMAVECScaleAdd(gravity.toCVec(), mVelocity.toCVec(), mVelocity.toVec(), 2.0f);

	if (!isNerve(&NrvPoihana::PoihanaNrvShock::sInstance)) {
		f32 magVel = isNerve(&NrvPoihana::PoihanaNrvChasePlayer::sInstance) ? 10.0f : 5.0f;

		if (PSVECMag((Vec *)&mVelocity) > magVel) {
			f32 squared = mVelocity.squared();

			if (squared > 0.0000038146973f) {
				mVelocity.scale(JGeometry::TUtil<f32>::inv_sqrt(squared));
			}
		}

		if (MR::isNearZero(mVelocity, 0.001f)) {
			mVelocity.zero();
		}
	}
}*/

void Poihana::calcMyGravity() {
	if (!mIsActive) {
		return;
	}

	TVec3f upVec, gravityPos;
	MR::calcUpVec(&upVec, this);
	JMAVECScaleAdd(upVec.toCVec(), mPosition.toCVec(), gravityPos.toVec(), 20.0f);
	MR::calcGravity(this, gravityPos);
}

bool Poihana::tryNonActive() {
	if (!MR::isStageStateScenarioOpeningCamera()) {
		bool notNear = !MR::isNearPlayerAnyTime(this, 3500.0f);
		if (notNear && MR::isBindedGround(this)) {
			setNerve(&NrvPoihana::PoihanaNrvNonActive::sInstance);
			return true;
		}
	}

	return false;
}

bool Poihana::tryDrown() {
	if (!mCanDrown) {
		return false;
	}

	if (isNerve(&NrvPoihana::PoihanaNrvAppear::sInstance)) {
		return false;
	}

	if (isNerve(&NrvPoihana::PoihanaNrvDrown::sInstance)) {
		return false;
	}

	if (!MR::isInWater(this, TVec3f(0.0f, 0.0f, 0.0f))) {
		return false;
	}

	setNerve(&NrvPoihana::PoihanaNrvDrown::sInstance);
	return true;
}

bool Poihana::tryDPDSwoon() {
	if (!isNerveTypeWalkOrWait()) {
		return false;
	}

	if (!mBindStarPointer->tryStartPointBind()) {
		return false;
	}

	setNerve(&NrvPoihana::PoihanaNrvDPDSwoon::sInstance);
	return true;
}

bool Poihana::tryShock() {
	bool ret = false;

	if (isNerve(&NrvPoihana::PoihanaNrvDrown::sInstance) ||
	    isNerve(&NrvPoihana::PoihanaNrvHide::sInstance) ||
	    isNerve(&NrvPoihana::PoihanaNrvAppear::sInstance)) {
		ret = true;
	}

	if (ret) {
		return false;
	}

	if (isNerve(&NrvPoihana::PoihanaNrvShock::sInstance)) {
		return false;
	}

	if (isNerve(&NrvPoihana::PoihanaNrvSwoonLand::sInstance)) {
		return false;
	}

	mVelocity.scale(-30.0f, mGravity);
	setNerve(&NrvPoihana::PoihanaNrvShock::sInstance);
	return true;
}

bool Poihana::tryHipDropShock() {
	bool isNotNear = !MR::isNearPlayerAnyTime(this, 500.0f);

	if (isNotNear) {
		return false;
	}

	if (MR::isPlayerHipDropLand()) {
		return tryShock();
	}

	return false;
}

bool Poihana::isNerveTypeWalkOrWait() const {
	return (isNerve(&NrvPoihana::PoihanaNrvWait::sInstance) ||
	        isNerve(&NrvPoihana::PoihanaNrvSearch::sInstance) ||
	        isNerve(&NrvPoihana::PoihanaNrvWalkAround::sInstance) ||
	        isNerve(&NrvPoihana::PoihanaNrvChasePlayer::sInstance) ||
	        isNerve(&NrvPoihana::PoihanaNrvGoBack::sInstance));
}

bool Poihana::isNeedForBackHome() const {
	if (isNerve(&NrvPoihana::PoihanaNrvWalkAround::sInstance)) {
		return !MR::isNear(this, mHomePos, 350.0f);
	}

	if (!isNerve(&NrvPoihana::PoihanaNrvChasePlayer::sInstance)) {
		bool ret;
		if (mBehavior == POIHANA_BEHAVIOR_NEW_HOME) {
			ret = !MR::isNearPlayer(this, 1100.0f);
		} else {
			ret = false;
			if (!MR::isNear(this, mHomePos, 2000.0f) || !MR::isNearPlayer(this, 1110.0f)) {
				ret = true;
			}
		}

		return ret;
	}

	return false;
}

bool Poihana::isNeedForGetUp() const {
	bool ret = false;

	if (MR::isNearPlayer(this, 500.0f)) {
		bool flag = true;

		f32 mag = PSVECMag((Vec *)MR::getPlayerVelocity());

		if (!(mag >= 10.0f) && !MR::isPlayerSwingAction()) {
			flag = false;
		}

		if (flag) {
			ret = true;
		}
	}

	return ret;
}

bool Poihana::isBackAttack(HitSensor *pMySensor) const {
	TVec3f frontVec;
	MR::calcFrontVec(&frontVec, this);
	JGeometry::negateInternal((f32 *)&frontVec, (f32 *)&frontVec);

	TVec3f sensorRelative(pMySensor->mPosition - mPosition);
	return sensorRelative.dot(frontVec) > 0.0f;
}

namespace NrvPoihana {
	INIT_NERVE(PoihanaNrvNonActive);
	INIT_NERVE(PoihanaNrvWait);
	INIT_NERVE(PoihanaNrvWalkAround);
	INIT_NERVE(PoihanaNrvSleepStart);
	INIT_NERVE(PoihanaNrvSleep);
	INIT_NERVE(PoihanaNrvGetUp);
	INIT_NERVE(PoihanaNrvSearch);
	INIT_NERVE(PoihanaNrvChasePlayer);
	INIT_NERVE(PoihanaNrvShootUpCharge);
	INIT_NERVE(PoihanaNrvShootUp);
	INIT_NERVE(PoihanaNrvGoBack);
	INIT_NERVE(PoihanaNrvShock);
	INIT_NERVE(PoihanaNrvSwoon);
	INIT_NERVE(PoihanaNrvSwoonLand);
	INIT_NERVE(PoihanaNrvRecover);
	INIT_NERVE(PoihanaNrvShake);
	INIT_NERVE(PoihanaNrvDrown);
	INIT_NERVE(PoihanaNrvHide);
	INIT_NERVE(PoihanaNrvAppear);
	INIT_NERVE(PoihanaNrvDPDSwoon);

	void PoihanaNrvNonActive::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeNonActive();
	}

	void PoihanaNrvNonActive::executeOnEnd(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->endNonActive();
	}

	void PoihanaNrvWait::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeWait();
	}

	void PoihanaNrvWalkAround::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeWalkAround();
	}

	void PoihanaNrvSleepStart::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeSleepStart();
	}

	void PoihanaNrvSleep::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeSleep();
	}

	void PoihanaNrvGetUp::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeGetUp();
	}

	void PoihanaNrvSearch::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeSearch();
	}

	void PoihanaNrvChasePlayer::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeChasePlayer();
	}

	void PoihanaNrvShootUpCharge::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeShootUpCharge();
	}

	void PoihanaNrvShootUp::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeShootUp();
	}

	void PoihanaNrvShootUp::executeOnEnd(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->endShootUp();
	}

	void PoihanaNrvGoBack::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeGoBack();
	}

	void PoihanaNrvShock::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeShock();
	}

	void PoihanaNrvSwoon::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeSwoon();
	}

	void PoihanaNrvSwoonLand::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeSwoonLand();
	}

	void PoihanaNrvRecover::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeRecover();
	}

	void PoihanaNrvShake::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeShake();
	}

	void PoihanaNrvDrown::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeDrown();
	}

	void PoihanaNrvHide::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeHide();
	}

	void PoihanaNrvAppear::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeAppear();
	}

	void PoihanaNrvDPDSwoon::execute(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->exeDPDSwoon();
	}

	void PoihanaNrvDPDSwoon::executeOnEnd(Spine *pSpine) const {
		Poihana *pActor = (Poihana*)pSpine->mExecutor;
		pActor->endDPDSwoon();
	}
}