mirror of
https://github.com/encounter/Petari.git
synced 2026-03-30 11:34:15 -07:00
shibbo
544 lines
15 KiB
C++
544 lines
15 KiB
C++
#include "Game/Enemy/PackunPetit.hpp"
|
|
#include "Game/LiveActor/ModelObj.hpp"
|
|
#include <JSystem/JMath/JMath.hpp>
|
|
|
|
PackunPetit::PackunPetit(const char *pName) : LiveActor(pName) {
|
|
mScaleController = nullptr;
|
|
mStarPointerState = nullptr;
|
|
_94.x = 0.0f;
|
|
_94.y = 0.0f;
|
|
_94.z = 1.0f;
|
|
mBlownModel = nullptr;
|
|
mDontTurn = false;
|
|
}
|
|
|
|
void PackunPetit::init(const JMapInfoIter &rIter) {
|
|
MR::initDefaultPos(this, rIter);
|
|
initModelManagerWithAnm("PackunPetit", nullptr, false);
|
|
MR::connectToSceneEnemy(this);
|
|
initHitSensor(3);
|
|
MR::addHitSensorAtJointMapObj(this, "body", "Head", 8, 90.0f, TVec3f(50.0f, 0.0f, 0.0f));
|
|
MR::addHitSensorAtJointEnemyAttack(this, "attack", "Head", 8, 50.0f, TVec3f(50.0f, 0.0f, 0.0f));
|
|
MR::addHitSensorMapObj(this, "stalk", 8, 100.0f, TVec3f(0.0f, 0.0f, 0.0f));
|
|
initEffectKeeper(2, nullptr, false);
|
|
MR::addEffectHitNormal(this, nullptr);
|
|
initSound(4, false);
|
|
MR::initLightCtrl(this);
|
|
MR::initShadowFromCSV(this, "Shadow");
|
|
MR::calcGravity(this);
|
|
MR::useStageSwitchWriteDead(this, rIter);
|
|
MR::declareCoin(this, 1);
|
|
MR::declareStarPiece(this, 6);
|
|
TVec3f offs;
|
|
offs.x = 0.0f;
|
|
offs.y = 0.0f;
|
|
offs.z = 0.0f;
|
|
MR::initStarPointerTargetAtJoint(this, "Head", 100.0f, offs);
|
|
mScaleController = new AnimScaleController(nullptr);
|
|
mStarPointerState = new WalkerStateBindStarPointer(this, mScaleController);
|
|
MR::getJMapInfoArg0NoInit(rIter, &mDontTurn);
|
|
MR::calcFrontVec(&_94, this);
|
|
initBlowModel();
|
|
initNerve(&NrvPackunPetit::PackunPetitNrvWait::sInstance);
|
|
makeActorAppeared();
|
|
}
|
|
|
|
void PackunPetit::initAfterPlacement() {
|
|
MR::initEffectAfterPlacement(this);
|
|
}
|
|
|
|
void PackunPetit::exeNonActive() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::invalidateHitSensors(this);
|
|
MR::offCalcAnim(this);
|
|
MR::offCalcShadow(this, "JawA");
|
|
}
|
|
|
|
if (MR::isNearPlayerAnyTime(this, 5000.0f)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvWait::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeWait() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBckWithInterpole(this, "Wait", 60);
|
|
}
|
|
|
|
if (MR::isNearPlayer(this, 1700.0f)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvFind::sInstance);
|
|
}
|
|
else {
|
|
tryNonActive();
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeFind() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBck(this, "Suspect", nullptr);
|
|
}
|
|
|
|
if (MR::isBckStopped(this)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvThreat::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeThreat() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBck(this, "Threat", nullptr);
|
|
}
|
|
|
|
MR::startLevelSound(this, "SE_EM_LV_PACKUNPETIT_THREAT", -1, -1, -1);
|
|
if (!mDontTurn) {
|
|
if (tryTurn()) {
|
|
return;
|
|
}
|
|
|
|
TVec3f* pos = MR::getPlayerPos();
|
|
MR::turnDirectionToTargetUseGroundNormalDegree(this, &_94, *pos, 2.0f);
|
|
}
|
|
|
|
if (MR::isGreaterStep(this, 50) && MR::isNearPlayer(this, 1100.0f) && (MR::isFaceToPlayerHorizontalDegree(this, _94, 10.0f) || mDontTurn)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvAttackStart::sInstance);
|
|
}
|
|
else if (!MR::isNearPlayer(this, 2000.0f)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvWait::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeTurn() {
|
|
if (MR::isFirstStep(this)) {
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvLeftTurn::sInstance)) {
|
|
MR::startBck(this, "TurnLeft", nullptr);
|
|
}
|
|
else {
|
|
MR::startBck(this, "TurnRight", nullptr);
|
|
}
|
|
}
|
|
|
|
f32 step = getNerveStep();
|
|
step = (10.0f - step);
|
|
if (step < 2.0f) {
|
|
step = 2.0f;
|
|
}
|
|
TVec3f* pos = MR::getPlayerPos();
|
|
MR::turnDirectionToTargetUseGroundNormalDegree(this, &_94, *pos, step);
|
|
if (MR::isBckStopped(this)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvThreat::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeAttackStart() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBck(this, "Attack", nullptr);
|
|
}
|
|
|
|
if (MR::isStep(this, 70)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvAttack::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeHitWaitForAttack() {
|
|
if (MR::isFirstStep(this) && !MR::isBckPlaying(this, "Attack")) {
|
|
MR::startBck(this, "Impact", nullptr);
|
|
}
|
|
|
|
if (MR::isBckStopped(this)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvHit::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeHit() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBck(this, "Hit", nullptr);
|
|
}
|
|
|
|
if (MR::isBckStopped(this) && !tryTurn()) {
|
|
selectNrvWait();
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeTrampleDown() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBck(this, "Press", nullptr);
|
|
MR::startSound(this, "SE_EM_STOMPED_S", -1, -1);
|
|
MR::invalidateHitSensors(this);
|
|
}
|
|
|
|
if (MR::isBckStopped(this)) {
|
|
kill();
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exePunchDown() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::invalidateHitSensor(this, "body");
|
|
MR::invalidateHitSensor(this, "attack");
|
|
mBlownModel->makeActorAppeared();
|
|
MR::copyJointPos(this, "Head", &mBlownModel->mPosition);
|
|
MR::startBck(mBlownModel, "BlowHead", nullptr);
|
|
MR::startBck(this, "Blow", nullptr);
|
|
MR::startBlowHitSound(this);
|
|
}
|
|
|
|
JMAVECScaleAdd(mGravity.toCVec(), mBlownModel->mVelocity.toCVec(), mBlownModel->mVelocity.toVec(), 2.5f);
|
|
|
|
if (!MR::isHiddenModel(mBlownModel) && (MR::isStep(this, 20) || MR::checkStikeBallToMap(mBlownModel->mPosition, 50.0f))) {
|
|
MR::emitEffect(mBlownModel, "Death");
|
|
MR::appearStarPiece(this, mBlownModel->mPosition, 3, 10.0f, 40.0f, false);
|
|
MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1);
|
|
MR::hideModel(mBlownModel);
|
|
}
|
|
|
|
if (MR::isStep(this, 30)) {
|
|
kill();
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeSwoonStart() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBck(this, "SwoonStart", nullptr);
|
|
}
|
|
|
|
if (MR::isBckStopped(this)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvSwoon::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::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, 250)) {
|
|
selectNrvWait();
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeSwoonToThreat() {
|
|
if (MR::isFirstStep(this)) {
|
|
MR::startBck(this, "SwoonToThreat", nullptr);
|
|
}
|
|
|
|
if (MR::isBckStopped(this)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvThreat::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeSwoonOnEnd() {
|
|
mStarPointerState->kill();
|
|
}
|
|
|
|
void PackunPetit::exeDPDSwoon() {
|
|
if (MR::updateActorState(this, mStarPointerState)) {
|
|
selectNrvWait();
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeAttackBack() {
|
|
if (MR::isBckStopped(this)) {
|
|
if (!tryTurn()) {
|
|
selectNrvWait();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeAttack() {
|
|
if (MR::isStep(this, 0xC)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvAttackBack::sInstance);
|
|
}
|
|
}
|
|
|
|
void PackunPetit::exeNonActiveOnEnd() {
|
|
MR::validateHitSensors(this);
|
|
MR::onCalcAnim(this);
|
|
MR::onCalcShadow(this, "JawA");
|
|
}
|
|
|
|
void PackunPetit::kill() {
|
|
if (!MR::isDead(mBlownModel)) {
|
|
if (!MR::isHiddenModel(mBlownModel)) {
|
|
MR::emitEffect(mBlownModel, "Death");
|
|
MR::appearStarPiece(this, mBlownModel->mPosition, 3, 10.0f, 40.0f, false);
|
|
MR::startSound(mBlownModel, "SE_OJ_STAR_PIECE_BURST", -1, -1);
|
|
}
|
|
|
|
mBlownModel->kill();
|
|
}
|
|
else {
|
|
if (!MR::isValidSwitchDead(this)) {
|
|
MR::appearCoinPop(this, mPosition, 1);
|
|
}
|
|
}
|
|
|
|
if (MR::isValidSwitchDead(this)) {
|
|
MR::onSwitchDead(this);
|
|
}
|
|
|
|
MR::emitEffect(this, "Death");
|
|
MR::startSound(this, "SE_EM_EXPLODE_S", -1, -1);
|
|
LiveActor::kill();
|
|
}
|
|
|
|
void PackunPetit::calcAndSetBaseMtx() {
|
|
TVec3f up;
|
|
MR::calcUpVec(&up, this);
|
|
TPos3f mtxUp;
|
|
mtxUp.identity();
|
|
MR::makeMtxUpFrontPos(&mtxUp, up, _94, mPosition);
|
|
TVec3f mult;
|
|
mult.multPS(mScale, mScaleController->_C);
|
|
MR::setBaseScale(this, mult);
|
|
}
|
|
|
|
void PackunPetit::control() {
|
|
mScaleController->update();
|
|
tryDPDSwoon();
|
|
}
|
|
|
|
/*
|
|
void PackunPetit::attackSensor(HitSensor *a2, HitSensor *a3) {
|
|
if (MR::isSensorPlayer(a3)) {
|
|
bool isTrampleOrPunch = false;
|
|
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvTrampleDown::sInstance) || isNerve(&NrvPackunPetit::PackunPetitNrvPunchDown::sInstance)) {
|
|
isTrampleOrPunch = true;
|
|
}
|
|
|
|
|
|
}
|
|
}*/
|
|
|
|
bool PackunPetit::receiveMsgPlayerAttack(u32 msg, HitSensor *a2, HitSensor *a3) {
|
|
bool isTrampleOrPunch = false;
|
|
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvTrampleDown::sInstance) || isNerve(&NrvPackunPetit::PackunPetitNrvPunchDown::sInstance)) {
|
|
isTrampleOrPunch = true;
|
|
}
|
|
|
|
if (isTrampleOrPunch) {
|
|
return false;
|
|
}
|
|
|
|
if (MR::isMsgLockOnStarPieceShoot(msg)) {
|
|
return true;
|
|
}
|
|
|
|
if (MR::isMsgStarPieceAttack(msg)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvSwoonStart::sInstance);
|
|
return true;
|
|
}
|
|
else {
|
|
bool isWaitOrHit = false;
|
|
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvHitWaitForAttack::sInstance) || isNerve(&NrvPackunPetit::PackunPetitNrvHit::sInstance)) {
|
|
isWaitOrHit = true;
|
|
}
|
|
|
|
if (isWaitOrHit) {
|
|
return false;
|
|
}
|
|
else if (MR::isMsgInvincibleAttack(msg) || MR::isMsgFireBallAttack(msg)) {
|
|
punchDown(a2, a3);
|
|
return true;
|
|
}
|
|
else if (isNerve(&NrvPackunPetit::PackunPetitNrvAttack::sInstance)) {
|
|
return false;
|
|
}
|
|
else if (MR::isMsgPlayerTrample(msg)) {
|
|
MR::tryRumbleDefaultHit(this, 0);
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvTrampleDown::sInstance);
|
|
return true;
|
|
}
|
|
else if (MR::isMsgPlayerHipDrop(msg)) {
|
|
MR::tryRumbleDefaultHit(this, 0);
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvTrampleDown::sInstance);
|
|
return true;
|
|
}
|
|
else if (MR::isMsgPlayerHitAll(msg)) {
|
|
MR::stopSceneForDefaultHit(5);
|
|
punchDown(a2, a3);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool PackunPetit::receiveMsgEnemyAttack(u32 msg, HitSensor *a2, HitSensor *a3) {
|
|
bool isTrampleOrPunch = false;
|
|
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvTrampleDown::sInstance) || isNerve(&NrvPackunPetit::PackunPetitNrvPunchDown::sInstance)) {
|
|
isTrampleOrPunch = true;
|
|
}
|
|
|
|
if (isTrampleOrPunch) {
|
|
return false;
|
|
}
|
|
|
|
if (MR::isMsgToEnemyAttackBlow(msg)) {
|
|
punchDown(a2, a3);
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvPunchDown::sInstance);
|
|
return true;
|
|
}
|
|
else if (MR::isMsgToEnemyAttackTrample(msg)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvTrampleDown::sInstance);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool PackunPetit::receiveOtherMsg(u32 msg, HitSensor *a2, HitSensor *a3) {
|
|
bool isSwoon = false;
|
|
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvSwoonStart::sInstance) || isNerve(&NrvPackunPetit::PackunPetitNrvSwoonStart::sInstance)) {
|
|
isSwoon = true;
|
|
}
|
|
|
|
if (!isSwoon) {
|
|
return false;
|
|
}
|
|
|
|
if (!MR::isSensorPlayer(a2)) {
|
|
return false;
|
|
}
|
|
|
|
if (MR::isMsgPlayerKick(msg)) {
|
|
MR::stopSceneForDefaultHit(5);
|
|
punchDown(a2, a3);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void PackunPetit::initBlowModel() {
|
|
mBlownModel = MR::createModelObjMapObjStrongLight("吹っ飛びモデル", "PackunPetitHead", nullptr);
|
|
mBlownModel->initWithoutIter();
|
|
MR::initShadowVolumeSphere(mBlownModel, 70.0f);
|
|
MR::invalidateClipping(mBlownModel);
|
|
MR::initLightCtrl(mBlownModel);
|
|
mBlownModel->makeActorDead();
|
|
}
|
|
|
|
void PackunPetit::punchDown(HitSensor *a1, HitSensor *a2) {
|
|
TVec3f v6;
|
|
v6.subtract(a2->mPosition, a1->mPosition);
|
|
TVec3f* grav = &mGravity;
|
|
f32 dot = grav->dot(v6);
|
|
JMAVECScaleAdd(grav->toCVec(), v6.toCVec(), v6.toVec(), -dot);
|
|
MR::normalize(&v6);
|
|
|
|
TVec3f v5;
|
|
v5.scale(20.0f, v6);
|
|
JMAVECScaleAdd(mGravity.toCVec(), v5.toCVec(), v5.toVec(), -40.0f);
|
|
mBlownModel->mVelocity.setInline(v5);
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvPunchDown::sInstance);
|
|
}
|
|
|
|
void PackunPetit::selectNrvWait() {
|
|
if (!MR::isNearPlayer(this, 1700.0f)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvWait::sInstance);
|
|
}
|
|
else {
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvSwoon::sInstance)) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvSwoonToThreat::sInstance);
|
|
}
|
|
else {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvThreat::sInstance);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool PackunPetit::tryNonActive() {
|
|
if (MR::isNearPlayerAnyTime(this, 5000.0f)) {
|
|
return false;
|
|
}
|
|
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvNonActive::sInstance);
|
|
return true;
|
|
}
|
|
|
|
bool PackunPetit::tryTurn() {
|
|
if (mDontTurn) {
|
|
return false;
|
|
}
|
|
|
|
if (MR::isFaceToPlayerHorizontalDegree(this, _94, 90.0f)) {
|
|
return false;
|
|
}
|
|
|
|
TVec3f* pos = MR::getPlayerPos();
|
|
TVec3f playerDist;
|
|
playerDist.subtract(*pos, mPosition);
|
|
TVec3f sideVec;
|
|
MR::calcSideVec(&sideVec, this);
|
|
|
|
if (playerDist.dot(sideVec) > 0.0f) {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvLeftTurn::sInstance);
|
|
}
|
|
else {
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvRightTurn::sInstance);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PackunPetit::tryDPDSwoon() {
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvDPDSwoon::sInstance)) {
|
|
return false;
|
|
}
|
|
|
|
bool isSwoon = false;
|
|
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvSwoonStart::sInstance) || isNerve(&NrvPackunPetit::PackunPetitNrvSwoon::sInstance)) {
|
|
isSwoon = true;
|
|
}
|
|
|
|
if (isSwoon) {
|
|
return false;
|
|
}
|
|
|
|
bool isTrampleOrPunch = false;
|
|
|
|
if (isNerve(&NrvPackunPetit::PackunPetitNrvTrampleDown::sInstance) || isNerve(&NrvPackunPetit::PackunPetitNrvPunchDown::sInstance)) {
|
|
isTrampleOrPunch = true;
|
|
}
|
|
|
|
if (isTrampleOrPunch) {
|
|
return false;
|
|
}
|
|
|
|
if (!mStarPointerState->tryStartPointBind()) {
|
|
return false;
|
|
}
|
|
|
|
setNerve(&NrvPackunPetit::PackunPetitNrvDPDSwoon::sInstance);
|
|
return true;
|
|
}
|
|
|
|
PackunPetit::~PackunPetit() {
|
|
|
|
}
|
|
|
|
namespace NrvPackunPetit {
|
|
INIT_NERVE(PackunPetitNrvNonActive);
|
|
INIT_NERVE(PackunPetitNrvWait);
|
|
INIT_NERVE(PackunPetitNrvFind);
|
|
INIT_NERVE(PackunPetitNrvThreat);
|
|
INIT_NERVE(PackunPetitNrvLeftTurn);
|
|
INIT_NERVE(PackunPetitNrvRightTurn);
|
|
INIT_NERVE(PackunPetitNrvAttackStart);
|
|
INIT_NERVE(PackunPetitNrvAttack);
|
|
INIT_NERVE(PackunPetitNrvAttackBack);
|
|
INIT_NERVE(PackunPetitNrvHitWaitForAttack);
|
|
INIT_NERVE(PackunPetitNrvHit);
|
|
INIT_NERVE(PackunPetitNrvTrampleDown);
|
|
INIT_NERVE(PackunPetitNrvPunchDown);
|
|
INIT_NERVE(PackunPetitNrvSwoonStart);
|
|
INIT_NERVE(PackunPetitNrvSwoon);
|
|
INIT_NERVE(PackunPetitNrvSwoonToThreat);
|
|
INIT_NERVE(PackunPetitNrvDPDSwoon);
|
|
}; |