diff options
Diffstat (limited to 'src/REL/d/a/npc/d_a_npc_bee.cpp')
| -rw-r--r-- | src/REL/d/a/npc/d_a_npc_bee.cpp | 712 |
1 files changed, 712 insertions, 0 deletions
diff --git a/src/REL/d/a/npc/d_a_npc_bee.cpp b/src/REL/d/a/npc/d_a_npc_bee.cpp index 3b859974..ad571d57 100644 --- a/src/REL/d/a/npc/d_a_npc_bee.cpp +++ b/src/REL/d/a/npc/d_a_npc_bee.cpp @@ -1,3 +1,715 @@ #include "d/a/npc/d_a_npc_bee.h" +#include "c/c_lib.h" +#include "c/c_math.h" +#include "common.h" +#include "d/a/d_a_itembase.h" +#include "d/a/d_a_player.h" +#include "d/a/e/d_a_e_bc.h" +#include "d/a/npc/d_a_npc_honeycomb.h" +#include "d/a/npc/d_a_npc_insect_capture_game_kobun.h" +#include "d/a/obj/d_a_obj_base.h" +#include "d/a/obj/d_a_obj_spore.h" +#include "d/col/bg/d_bg_s.h" +#include "d/col/bg/d_bg_s_gnd_chk.h" +#include "d/col/bg/d_bg_s_lin_chk.h" +#include "d/col/c/c_cc_d.h" +#include "d/col/cc/d_cc_d.h" +#include "d/d_camera.h" +#include "d/d_player_act.h" +#include "d/d_rumble.h" +#include "d/d_sc_game.h" +#include "d/flag/sceneflag_manager.h" +#include "d/snd/d_snd_wzsound.h" +#include "f/f_base.h" +#include "f/f_manager.h" +#include "f/f_profile_name.h" +#include "m/m_angle.h" +#include "m/m_mtx.h" +#include "m/m_vec.h" +#include "nw4r/g3d/res/g3d_resfile.h" +#include "nw4r/g3d/res/g3d_resmat.h" +#include "nw4r/g3d/res/g3d_resmdl.h" +#include "nw4r/g3d/res/g3d_resshp.h" +#include "nw4r/math/math_arithmetic.h" +#include "nw4r/math/math_triangular.h" +#include "s/s_Math.h" +#include "toBeSorted/d_emitter.h" + +#include <cmath> + SPECIAL_ACTOR_PROFILE(NPC_BEE, dAcNpcBee_c, fProfile::NPC_BEE, 0x123, 0, 0); + +static dCcD_SrcSph beeColliderSrc = { + /* mObjInf */ {/* mObjAt */ {AT_TYPE_0x2000000, 0x20000F, {0, 0, 0}, 1, 0, 0, 0, 0, 0}, + /* mObjTg */ {AT_TYPE_BUGNET | AT_TYPE_BELLOWS | AT_TYPE_BOMB, 0x00004011, {0, 00, 0x40F}, 8, 0}, + /* mObjCo */ {0}}, + /* mSphInf */ + {15.0f} +}; + +bool dAcNpcBee_c::createHeap() { + mRes = nw4r::g3d::ResFile(getOarcResFile("Bee")); + static const char *sModelNames[4] = { + "fly_A", + "fly_B", + "walk_A", + "walk_B", + }; + mSwarmBeeCount = 20; + for (int i = 0; i < (int)ARRAY_LENGTH(sModelNames); i++) { + nw4r::g3d::ResMdl mdl = mRes.GetResMdl(sModelNames[i]); + TRY_CREATE(mBeeModels[i].create(mdl, mSwarmBeeCount, &mAllocator, true, nullptr)); + } + return SUCCEEDED; +} + +int dAcNpcBee_c::create() { + mSceneflag = getFromParams(0x10, 0xFF); + if (mSceneflag != 0xFF && SceneflagManager::sInstance && + SceneflagManager::sInstance->checkFlag(getRoomId(), mSceneflag)) { + return FAILED; + } + CREATE_ALLOCATOR(dAcNpcBee_c); + dAcNpcBeeSingleBee *bee = &mBees[0]; + for (int i = 0; i < mSwarmBeeCount; i++, bee++) { + bee->mIndex = i; + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_CRAWL; + bee->mPos = mPosition; + bee->mTimer = cM::rndF(65536); + mColliderList.addCc(bee->mCollider, beeColliderSrc); + bee->mCollider.mTg.OffSPrm(0x100); + bee->mCollider.mAt.OnSPrm(0x100); + // hide half of the bees until the hive breaks + if (i < mSwarmBeeCount / 2) { + bee->mHide = true; + } + } + setInteractionFlags(0x80); + mStts.SetRank(3); + mColliderList.SetStts(mStts); + mFrameCounter = cM::rndF(65536); + dAcObjBase_c *honeycomb = + dAcObjBase_c::create(fProfile::NPC_HONEYCOMB, -1, mParams, &mPosition, nullptr, nullptr, -1); + if (honeycomb == nullptr) { + return FAILED; + } else { + mHiveRef.link(static_cast<dAcNpcHc_c *>(honeycomb)); + mAttackRef.link(dAcPy_c::GetLinkM()); + } + return SUCCEEDED; +} + +int dAcNpcBee_c::doDelete() { + return SUCCEEDED; +} + +// non matching +void dAcNpcBee_c::actuallyUpdateSwarmBees() { + if (mHiveRef.isLinked()) { + setStartingPosition(mHiveRef.get()->field_0x928); + } + dAcPy_c *player = dAcPy_c::GetLinkM(); + if ((mFrameCounter & 0xF) == 0) { + mAttackRef.link(player); + bool noSporeFound = true; + fLiNdBa_c *current = dAcOSpore_c::getListHead(); + if (current != nullptr) { + for (; current != nullptr; current = current->getNext()) { + dAcOSpore_c *spore = static_cast<dAcOSpore_c *>(current->p_owner); + if (spore != nullptr && spore->isGlitteringSpore()) { + mVec3_c &sporePos = spore->mPosition; + if (spore->mPosition.squareDistanceToXZ(mAliveBeePos) < 1000000.f && + std::fabsf(spore->mPosition.y - mAliveBeePos.y) < 500.f) { + if (!dBgS_ObjLinChk::LineCross(&mAliveBeePos, &sporePos, this)) { + mAttackRef.link(spore); + noSporeFound = false; + mSporeActor = spore; + break; + } + } + } + } + } + if (noSporeFound) { + dAcEbc_c *boko = nullptr; + while ((boko = static_cast<dAcEbc_c *>(fManager_c::searchBaseByProfName(fProfile::E_BC, boko)))) { + if (boko->getField_0x130D()) { + continue; + } + f32 distToPlayer = mAliveBeePos.distance(dAcPy_c::GetLink()->mPositionCopy2); + f32 distToBoko = mAliveBeePos.distance(boko->mPositionCopy2); + if (distToBoko < distToPlayer) { + mAttackRef.link(boko); + break; + } + } + } + } + mAttackActor = mAttackRef.get(); + if (mAttackActor == nullptr) { + mAttackActor = player; + } + dAcNpcBeeSingleBee *bee = &mBees[0]; + u8 beesAlive = 0; + int beeModelIndex = 0; + static mVec3_c colliderDisabledPos(10000.f, -20000.f, 50000.f); + dCamera_c *camera = dScGame_c::getCamera(); + bool hideBee; + bool isFirst = true; + int flyingBeeCount = 0; + mAttackActorDistFromHome = mStartingPos.distance(mAttackActor->mPositionCopy2); + mPosition = mStartingPos; + for (u32 i = 0; (s32)i < mSwarmBeeCount; i++, bee++) { + hideBee = true; + mMtx_c mtx; + if (bee->mBeeState != dAcNpcBeeSingleBee::BEE_STATE_DEAD) { + beesAlive++; + bee->mOldPos = bee->mPos; + if (bee->mActionTimer) { + bee->mActionTimer--; + } + if (bee->mDisableAttackTimer) { + bee->mDisableAttackTimer--; + } + if (bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_CRAWL) { + handleBeeCrawlingOnHive(bee); + bee->mDisableAttackTimer = 5; + } else { + bee->mTimer++; + if (bee->mBeeState <= dAcNpcBeeSingleBee::BEE_STATE_FLY_UP) { + handleBeeFlyingStates(bee); + flyingBeeCount++; + if (isFirst) { + isFirst = false; + mPosition = bee->mPos; + } + } else if (bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_BLOWN_AWAY) { + handleBeeBlownAway(bee); + } else if (bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_RISE) { + handleBeeRising(bee); + } + } + mVec3_c localA4; + mVec3_c localB0; + if (!bee->mHide) { + localA4 = bee->mPos - camera->getPosition(); + // float constants should be in a different order + if (localA4.absXZ() < 3000.f) { + localA4.normalize(); + localB0 = camera->getTarget() - camera->getPosition(); + localB0.normalize(); + if (localB0.dot(localA4) > 0.5f) { + if (bee->mIsFlying) { + if (bee->mTimer & 1) { + beeModelIndex = 0; // MODEL_FLY_A + } else { + beeModelIndex = 1; // MODEL_FLY_B + } + } else { + beeModelIndex = (bee->mTimer >> 2 & 1) ? 2 /* MODEL_WALK_A */ : 3 /* MODEL_WALK_B */; + } + if (bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_CRAWL) { + mtx.transS(bee->mPos); + mtx.ZrotM(bee->mCrawlingRotation.x); + mtx.XrotM(bee->mCrawlingRotation.z); + mtx.YrotM(bee->mCrawlingRotation.y); + mtx.XrotM(0x8000); + } else { + mtx.transS(bee->mPos); + mtx.YrotM(bee->mModelRotation.y); + mtx.XrotM(bee->mModelRotation.x); + mtx.ZrotM(bee->mModelRotation.z); + } + hideBee = false; + } + } + } + mAliveBeePos = bee->mPos; + } + for (u8 j = 0; j < ARRAY_LENGTH(mBeeModels); j++) { + if (!hideBee && j == (u8)beeModelIndex) { + mBeeModels[j].setDrawDisabled(i, false); + mBeeModels[j].setTransform(i, mtx); + } else { + mBeeModels[j].setDrawDisabled(i, true); + } + } + if (!hideBee && bee->mDisableAttackTimer == 0) { + bee->mCollider.SetC(bee->mPos); + } else { + bee->mCollider.SetC(colliderDisabledPos); + } + } + if (flyingBeeCount != 0) { + holdSoundWithIntParam(SE_Bee_FLY_LV, flyingBeeCount); + } + mColliderList.registerColliders(); + if (!beesAlive) { + deleteRequest(); + } +} + +void dAcNpcBee_c::handleBeeCrawlingOnHive(dAcNpcBeeSingleBee *bee) { +#define CRAWLING_SUBSTATE_NONMOVING 0 +#define CRAWLING_SUBSTATE_MOVE 1 +#define CRAWLING_SUBSTATE_FLY 2 +#define CRAWLING_SUBSTATE_LAND 3 +#define CRAWLING_SUBSTATE_PRE_RISE 4 + f32 targetSpeed = 0.0f; + dAcNpcHc_c *hive = mHiveRef.get(); + if (hive == nullptr || hive->mHealth == 0) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_DEAD; + } else { + if (bee->mHide) { + if (hive->mHealth == 1) { + bee->mHide = false; + bee->field_0x024.x = cM::rndFX(300.f); + bee->field_0x024.z = cM::rndFX(300.f); + } else { + bee->mPos = mStartingPos; + return; + } + } + if (dAcPy_c::GetLink()->getRidingActorType() != daPlayerActBase_c::RIDING_LOFTWING && + (mAttackActor->getPosition().y - getPosition().y) < 0.f && bee->mSubState != CRAWLING_SUBSTATE_PRE_RISE) { + // using getSpeed inline breaks the match + f32 aggroDistance = mAttackActor->mSpeed * 20.f + 350.f; + if (hive->field_0x915 >= 5 || hive->mHealth == 1 || + (hive->field_0x916 == 0 && mAttackActorDistFromHome < aggroDistance)) { + bee->mSubState = CRAWLING_SUBSTATE_PRE_RISE; + bee->mActionTimer = cM::rndF(15.f); + } else if (bee->mSubState != CRAWLING_SUBSTATE_FLY && hive->field_0x915 != 0) { + bee->mActionTimer = cM::rndF(70.f) + 30.f; + bee->mSubState = CRAWLING_SUBSTATE_FLY; + } + } + bee->mIsFlying = false; + mVec3_c local_74; + local_74 = bee->mTargetPos - bee->field_0x024; + if (bee->mSubState == CRAWLING_SUBSTATE_NONMOVING) { + bee->mCrawlingSpeed = 0.f; + if (bee->mActionTimer == 0) { + if (cM::rnd() < 0.02f) { + bee->mActionTimer = cM::rndF(70.f) + 30.f; + bee->mSubState = CRAWLING_SUBSTATE_FLY; + } else { + bee->mActionTimer = cM::rndF(30.f) + 5.f; + bee->mTargetPos.x = cM::rndFX(300.f); + bee->mTargetPos.z = cM::rndFX(300.f); + bee->mSubState = CRAWLING_SUBSTATE_MOVE; + } + } + } else if (bee->mSubState == CRAWLING_SUBSTATE_MOVE) { + bee->mTimer++; + sLib::addCalcAngle(bee->mCrawlingRotation.y.ref(), local_74.atan2sX_Z(), 2, 0x400); + if (bee->mActionTimer == 0 || local_74.absXZ() < 10.f) { + bee->mSubState = CRAWLING_SUBSTATE_NONMOVING; + bee->mActionTimer = cM::rndF(15.f) + 2.f; + } + targetSpeed = 2.f; + } else if (bee->mSubState == CRAWLING_SUBSTATE_FLY) { + bee->mIsFlying = true; + sLib::addCalcScaledDiff(&bee->mCrawlingSpeed, 50.f, 0.1f, 5.f); + sLib::addCalcAngle(bee->mCrawlingRotation.y.ref(), local_74.atan2sX_Z(), 2, 0x800); + if ((bee->mActionTimer & 0x7) == 0) { + bee->mTargetPos.x = cM::rndFX(300.f); + bee->mTargetPos.z = cM::rndFX(300.f); + } + if (bee->mActionTimer == 0) { + bee->mSubState = CRAWLING_SUBSTATE_LAND; + } + targetSpeed = 5.f; + } else if (bee->mSubState == CRAWLING_SUBSTATE_LAND) { + bee->mIsFlying = true; + sLib::addCalcScaled(&bee->mCrawlingSpeed, 1.f, 5.f); + if (bee->mCrawlingSpeed <= 0.1f) { + bee->mSubState = CRAWLING_SUBSTATE_NONMOVING; + } + } else if (bee->mSubState == CRAWLING_SUBSTATE_PRE_RISE && bee->mActionTimer == 0) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_RISE; + bee->mSubState = 0; + } + sLib::addCalcScaledDiff(&bee->mSpeed, targetSpeed, 0.5f, 0.5f); + mMtx_c mtx; + mtx.YrotS(bee->mCrawlingRotation.y); + local_74.set(0.f, 0.f, bee->mSpeed); + mtx.multVec(local_74, bee->field_0x048); + bee->field_0x024 += bee->field_0x048; + s16 xRot = -bee->field_0x024.x * 32768.f / 200.f; + s16 zRot = bee->field_0x024.z * 32768.f / 200.f; + local_74.set(0.f, -68.f - bee->mCrawlingSpeed, 0.f); + mtx.scaleS(1.f, 1.15f, 1.f); + mtx.YrotM(hive->mRotation.y); + mtx.ZrotM(xRot); + mtx.XrotM(zRot); + mtx.multVec(local_74, bee->mPos); + bee->mPos += mStartingPos; + if (!bee->mIsFlying) { + sLib::addCalcAngle(bee->mCrawlingRotation.x.ref(), xRot, 2, 0x800); + sLib::addCalcAngle(bee->mCrawlingRotation.z.ref(), zRot, 2, 0x800); + } else { + bee->mTimer++; + sLib::addCalcAngle(bee->mCrawlingRotation.x.ref(), 0, 1, 0x1000); + sLib::addCalcAngle(bee->mCrawlingRotation.z.ref(), -0x8000, 1, 0x1000); + } + } +} + +// non matching +void dAcNpcBee_c::handleBeeFlyingStates(dAcNpcBeeSingleBee *bee) { + bee->mIsFlying = true; + dAcNpcHc_c *hive = mHiveRef.get(); + bee->mCollider.ClrAtSet(); + bool isFlyingAway = false; + bool isAttacking = false; + bool dodgedSword; + mMtx_c mtx; + mVec3_c offsetToTarget; + mVec3_c local_98; + if (bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_CHASE) { + if (bee->mAttackCooldownTimer != 0) { + bee->mAttackCooldownTimer--; + } + if (bee->mSwordDodgeTimer != 0) { + bee->mSwordDodgeTimer--; + bee->mPos += bee->mSwordDodgeOffset; + bee->mSwordDodgeOffset *= 0.8f; + } else { + if (mAttackActor == dAcPy_c::GetLink() && dAcPy_c::GetLink()->checkFlags0x354(4) && + bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_CHASE) { + dodgedSword = false; + local_98 = dAcPy_c::GetLink()->getPosition() - bee->mPos; + if (local_98.squareMagXZ() < 90000.f) { + if (dAcPy_c::GetLink()->getSpecificAttackDirection() == + (s16)daPlayerActBase_c::ATTACK_DIRECTION_LEFT || + dAcPy_c::GetLink()->getSpecificAttackDirection() == + (s16)daPlayerActBase_c::ATTACK_DIRECTION_RIGHT) { + local_98.y += 150.f; + if (std::fabsf(local_98.y) < 50.f) { + if (local_98.y < 0.f) { + bee->mSwordDodgeOffset.y = 10.f; + } else { + bee->mSwordDodgeOffset.y = -10.f; + } + bee->mSwordDodgeOffset.y *= (50.f - std::fabsf(local_98.y)) * (cM::rndF(0.02f) + 0.02f); + bee->mSwordDodgeOffset.x = cM::rndFX(5.f); + bee->mSwordDodgeOffset.z = cM::rndFX(5.f); + dodgedSword = true; + } + } else { + mtx.YrotS(-dAcPy_c::GetLink()->mRotation.y); + mtx.multVec(local_98, local_98); + f32 xAbs = std::fabsf(local_98.x); + if (xAbs < 130.f) { + if (local_98.x > 0.f) { + local_98.x = -15.f; + } else { + local_98.x = 15.f; + } + local_98.x *= (130.f - xAbs) * (cM::rndF(0.005f) + 0.005f); + local_98.y = cM::rndFX(7.f); + local_98.z = cM::rndFX(7.f); + mtx.YrotS(dAcPy_c::GetLink()->mRotation.y); + mtx.multVec(local_98, bee->mSwordDodgeOffset); + dodgedSword = true; + } + } + if (dodgedSword) { + bee->mActionTimer = bee->mSwordDodgeTimer = cM::rndF(5.f) + 10.f; + bee->mSpeed = 0.f; + } + } + } + } + offsetToTarget = mAttackActor->mPositionCopy2 - bee->mPos; + f32 distToTarget = offsetToTarget.squareMagXZ(); + // targeted actor is less than 300 units away and not moving + if (distToTarget < 90000.f && mAttackActor->getSpeed() < 10.f) { + if ((bee->mAttackCooldownTimer != 0 && bee->mSpeed > 10.f) || distToTarget < 400.f) { + bee->mActionTimer = 0; + } + if (bee->mActionTimer == 0) { + bee->mIsAttacking = false; + if (bee->mAttackCooldownTimer != 0 || cM::rnd() < 0.95f) { + // don't actually attack + bee->mSpeed = cM::rndF(5.f) + 5.f; + bee->mTargetPos.x = cM::rndFX(200.f); + bee->mTargetPos.y = cM::rndFX(50.f); + bee->mTargetPos.z = cM::rndF(50.f) + 100.f; + mtx.YrotS(mAttackActor->mRotation.y); + mtx.multVec(bee->mTargetPos, bee->mTargetPos); + bee->mActionTimer = cM::rndF(15.f) + 15.f; + } else { + // attack + bee->mSpeed = cM::rndF(5.f) + 17.f; + bee->mTargetPos.x = 0.f; + bee->mTargetPos.y = 0.f; + bee->mTargetPos.z = 0.f; + bee->mActionTimer = 20; + bee->mIsAttacking = true; + isAttacking = true; + } + } + } else { + bee->mIsAttacking = false; + if (bee->mActionTimer == 0) { + bee->mActionTimer = cM::rndF(15.f) + 15.f; + bee->mSpeed = cM::rndF(5.f) + 17.f + 2.f; + bee->mTargetPos.x = cM::rndFX(100.f); + bee->mTargetPos.y = cM::rndFX(50.f); + bee->mTargetPos.z = cM::rndFX(100.f); + } + bee->mAttackCooldownTimer = 80; + } + offsetToTarget += bee->mTargetPos; + f32 maxDist = 1000000.f; + if ((bee->mFlyingStatesTimer == 0 || distToTarget > maxDist) || + (mAttackActor == dAcPy_c::LINK && dAcPy_c::LINK->checkActionFlags(0x40000))) { + if (mSporeActor == mAttackActor || (hive != nullptr && mAttackActorDistFromHome < 300.f)) { + bee->mFlyingStatesTimer = cM::rndF(30.f) + 20.f; + } else { + if (hive != nullptr) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_FLY_TO_HIVE; + bee->mTargetPos = mStartingPos; + } else { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_FLY_UP; + mtx.YrotS(cM::rndF(65536.f)); + offsetToTarget.y = cM::rndF(2000.f) + 6000.f; + offsetToTarget.x = 0.f; + offsetToTarget.z = 8000.f; + mtx.multVec(offsetToTarget, local_98); + bee->mTargetPos = local_98 + mAttackActor->mPositionCopy2; + bee->mFlyingStatesTimer = cM::rndF(55.f) + 200.f; + } + bee->mSpeed = cM::rndF(5.f) + 17.f; + bee->mIsAttacking = false; + } + } + if (bee->mSpeed >= 10.f && mSporeActor != mAttackActor) { + bee->mCollider.OnAtSet(); + } + } else if ( + bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_FLY_TO_HIVE || + bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_FLY_UP + ) { + isFlyingAway = true; + offsetToTarget = bee->mTargetPos - bee->mPos; + f32 distToTarget; + f32 fVar17; + if (hive != nullptr) { + fVar17 = hive->mScale.x * 55.f; + } else { + fVar17 = 55.f; + } + distToTarget = offsetToTarget.mag(); + if (fVar17 < 55.f) { + fVar17 = 55.f; + } + if (distToTarget < fVar17) { + if (bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_FLY_TO_HIVE) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_CRAWL; + bee->mSpeed = 0.f; + } + } else { + if (distToTarget > 500.f) { + distToTarget = 500.f; + } + // seems fake, I suspect there is an inline that takes s16 + offsetToTarget.x += distToTarget * nw4r::math::SinIdx((s16)(bee->mTimer * 0x400)); + offsetToTarget.y += distToTarget * nw4r::math::CosIdx(bee->mTimer * 0x300) * 0.5f; + offsetToTarget.z += distToTarget * nw4r::math::CosIdx(bee->mTimer * 0x500); + } + if (bee->mBeeState == dAcNpcBeeSingleBee::BEE_STATE_FLY_UP && bee->mFlyingStatesTimer == 0) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_DEAD; + } + } + if (bee->mWallReflectTimer == 0) { + if (isAttacking) { + bee->mCrawlingRotation.y = offsetToTarget.atan2sX_Z(); + bee->mCrawlingRotation.x = offsetToTarget.atan2sXZ_Y(); + } else { + s32 fVar17 = nw4r::math::SinIdx(bee->mTimer * 3500) * 1500.f; + s32 fVar16 = nw4r::math::SinIdx(bee->mTimer * 3000) * 1500.f; + sLib::addCalcAngle(bee->mCrawlingRotation.y.ref(), fVar17 + cM::atan2s(offsetToTarget.x, offsetToTarget.z), 1, 0x1000); + sLib::addCalcAngle(bee->mCrawlingRotation.x.ref(), fVar16 - cM::atan2s(offsetToTarget.y, offsetToTarget.absXZ()), 1, 0x1000); + } + } + mtx.YrotS(bee->mCrawlingRotation.y); + mtx.XrotM(bee->mCrawlingRotation.x); + offsetToTarget.set(0.f, 0.f, bee->mSpeed); + mtx.multVec(offsetToTarget, bee->field_0x048); + bee->mPos += bee->field_0x048; + if (bee->mFlyingStatesTimer != 0) { + bee->mFlyingStatesTimer--; + } + if (isFlyingAway) { + sLib::addCalcAngle(bee->mModelRotation.y.ref(), bee->mCrawlingRotation.y, 2, 0x800); + sLib::addCalcAngle(bee->mModelRotation.x.ref(), bee->mCrawlingRotation.x, 2, 0x800); + } else { + local_98 = mAttackActor->mPositionCopy2 - bee->mPos; + s16 sVar15 = local_98.atan2sX_Z(); + sLib::addCalcAngle(bee->mModelRotation.y.ref(), sVar15, 2, 0x1000); + if (bee->mIsAttacking) { + sLib::addCalcAngle(bee->mModelRotation.x.ref(), -0x4000, 2, 0x1000); + } else { + sLib::addCalcAngle(bee->mModelRotation.x.ref(), 0, 2, 0x1000); + } + } + if (bee->mWallReflectTimer == 0) { + // if wall hit + // potential @bug, doesn't catch when both wall and floor are hit + if (beeCheckWallFloorCollision(bee) == 2) { + bee->mWallReflectTimer = cM::rndF(5.f) + 10.f; + bee->mCrawlingRotation.y += ((s16)cM::rndFX(8000.f)) + 0x8000; + } + } else { + bee->mWallReflectTimer--; + } + if ((bee->mTimer & 0xF) == 0 && cM::rnd() < 0.5f) { + bee->mCrawlingRotation.z = cM::rndFX(5000.f); + } + sLib::addCalcAngle(bee->mModelRotation.z.ref(), bee->mCrawlingRotation.z, 2, 0x200); +} + +void dAcNpcBee_c::handleBeeRising(dAcNpcBeeSingleBee *bee) { + bee->mIsFlying = true; + switch (bee->mSubState) { + case 0: { + bee->mTargetPos = mStartingPos + (bee->mPos - mStartingPos) * (cM::rndF(0.5f) + 1.5f); + bee->mActionTimer = 20; + bee->mSubState = 1; + // fallthrough + } + case 1: { + cLib::addCalcPos2(&bee->mPos, bee->mTargetPos, 0.2f, 15.0f); + sLib::addCalcAngle( + bee->mCrawlingRotation.y.ref(), cLib::targetAngleY(bee->mPos, mAttackActor->mPositionCopy2), 2, 0x800 + ); + sLib::addCalcAngle(bee->mCrawlingRotation.x.ref(), 0, 2, 0x800); + sLib::addCalcAngle(bee->mCrawlingRotation.z.ref(), 0, 2, 0x800); + if (bee->mActionTimer == 0) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_CHASE; + bee->mSubState = 0; + bee->mFlyingStatesTimer = cM::rndF(155.f) + 300.f; + } + } + } +} + +void dAcNpcBee_c::handleBeeBlownAway(dAcNpcBeeSingleBee *bee) { + bee->mPos += bee->field_0x048; + bee->mPos.x += nw4r::math::SinIdx(bee->mTimer * 0x900) * 10.f; + bee->mPos.y += nw4r::math::SinIdx(bee->mTimer * 0xa00) * 10.f; + bee->mPos.z += nw4r::math::SinIdx(bee->mTimer * 0xb00) * 10.f; + if (bee->mIndex & 1) { + bee->mModelRotation.y += 0xD00; + } else { + bee->mModelRotation.y -= 0xD00; + } + bee->mModelRotation.x += 0xA00; + if (bee->mActionTimer == 0) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_CHASE; + bee->mSubState = 0; + bee->mFlyingStatesTimer = cM::rndF(155.f) + 300.f; + } + beeCheckWallFloorCollision(bee); +} + +int dAcNpcBee_c::actorExecute() { + mFrameCounter++; + updateSwarmBeeColliders(); + actuallyUpdateSwarmBees(); + if (mRumbleTimer) { + mRumbleTimer--; + if (mRumbleTimer == 7) { + dRumble_c::start(dRumble_c::sRumblePreset1, 1); + } else if (mRumbleTimer == 5) { + dRumble_c::stop(-1); + } + } + return SUCCEEDED; +} + +u32 dAcNpcBee_c::updateSwarmBeeColliders() { + mMtx_c mtx; + mtx.YrotS(dAcPy_c::LINK->mRotation.y); + dAcNpcBeeSingleBee *bee = &mBees[0]; + for (int i = 0; i < mSwarmBeeCount; i++, bee++) { + if (bee->mBeeState != dAcNpcBeeSingleBee::BEE_STATE_DEAD) { + if (bee->mCollider.ChkTgHit()) { + if (bee->mCollider.ChkTgAtHitType(AT_TYPE_BUGNET)) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_DEAD; + dAcPy_c::LINK->bugNetCollectTreasure(ITEM_DEKU_HORNET); + dAcNpcIcgKobun_c *npc = + static_cast<dAcNpcIcgKobun_c *>(fManager_c::searchBaseByProfName(fProfile::NPC_ICGK)); + if (npc != nullptr) { + npc->fn_66_30C0(ITEM_DEKU_HORNET); + } + } else if (bee->mCollider.ChkTgAtHitType(AT_TYPE_BOMB)) { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_DEAD; + dJEffManager_c::spawnEffect( + PARTICLE_RESOURCE_ID_MAPPING_394_, bee->mPos, nullptr, nullptr, nullptr, nullptr, 0, 0 + ); + } else { + bee->mBeeState = dAcNpcBeeSingleBee::BEE_STATE_BLOWN_AWAY; + bee->field_0x048 = bee->mCollider.GetTgAtHitDir(); + bee->field_0x048.normalize(); + if (bee->mCollider.ChkTgAtHitType(AT_TYPE_BELLOWS)) { + bee->field_0x048 *= cM::rndF(5.f) + 15.f; + bee->mActionTimer = cM::rndF(5.f) + 15.f; + mRumbleTimer |= 8; + } else { + // can this even be reached? all possible AT types should be handled + bee->field_0x048 *= cM::rndF(5.f) + 25.f; + bee->field_0x048.y = cM::rndF(5.f) + 15.f; + mVec3_c local_b8(cM::rndFX(20.f), 0.f, 0.f); + mtx.multVec(local_b8, local_b8); + bee->field_0x048 += local_b8; + bee->mActionTimer = cM::rndF(50.f) + 200.f; + } + } + } + } + } + return 1; +} + +int dAcNpcBee_c::draw() { + dShpProc1_c *model = &mBeeModels[0]; + for (int i = 0; i < 4; i++, model++) { + model->entry(); + } + return 1; +} + +/** + * Returns bits when a collision is detected, 2 is wall, 1 is floor + */ +s32 dAcNpcBee_c::beeCheckWallFloorCollision(dAcNpcBeeSingleBee *bee) { + dBgS_ObjGndChk gndChk; + dBgS_ObjLinChk linChk; + mVec3_c local_148; + mVec3_c scaled; + u32 ret = 0; + local_148 = bee->mPos - bee->mOldPos; + local_148.y = 0.f; + local_148.normalize(); + scaled = local_148 * 50.f; + local_148 = bee->mPos + scaled; + linChk.Set(&bee->mPos, &local_148, nullptr); + if (dBgS::GetInstance()->LineCross(&linChk)) { + ret = 2; + bee->mPos.x = linChk.GetLinEnd().x - scaled.x; + bee->mPos.z = linChk.GetLinEnd().z - scaled.z; + } + local_148 = bee->mPos; + local_148.y += 100.f; + gndChk.SetPos(&local_148); + if (bee->mPos.y <= dBgS::GetInstance()->GroundCross(&gndChk) + 15.f) { + // imagine using temp variables... + bee->mPos.y = dBgS::GetInstance()->GroundCross(&gndChk) + 15.f; + ret |= 1; + } + return ret; +} |