Npc: Implement BigBirdStateFlyAway and SmallBirdStateFlyAway (#621)

data/odyssey_functions.csv

@@ -22499,19 +22499,19 @@ Address,Quality,Size,Name
 0x000000710037b394,U,000064,_ZN27AmiiboNpcStateChangeCostume7controlEv
 0x000000710037b3d4,U,000120,_ZN27AmiiboNpcStateChangeCostume12receiveEventEPKN2al18EventFlowEventDataE
 0x000000710037b44c,U,000036,_ZN27AmiiboNpcStateChangeCostumeD0Ev
-0x000000710037b470,U,000080,_ZN19BigBirdStateFlyAwayC2EPN2al9LiveActorE
-0x000000710037b4c0,U,000096,_ZN19BigBirdStateFlyAway6appearEv
-0x000000710037b520,U,000088,_ZN19BigBirdStateFlyAway17exeGroundReactionEv
-0x000000710037b578,U,000096,_ZN19BigBirdStateFlyAway14exeFlyReactionEv
-0x000000710037b5d8,U,000264,_ZN19BigBirdStateFlyAway17exeFlyAwayPrepareEv
-0x000000710037b6e0,U,000248,_ZN19BigBirdStateFlyAway15exeFlyAwayStartEv
-0x000000710037b7d8,U,000252,_ZN19BigBirdStateFlyAway10exeFlyAwayEv
-0x000000710037b8d4,U,000036,_ZN19BigBirdStateFlyAwayD0Ev
-0x000000710037b8f8,U,000008,_ZNK12_GLOBAL__N_136BigBirdStateFlyAwayNrvFlyAwayPrepare7executeEPN2al11NerveKeeperE
-0x000000710037b900,U,000092,_ZNK12_GLOBAL__N_136BigBirdStateFlyAwayNrvGroundReaction7executeEPN2al11NerveKeeperE
-0x000000710037b95c,U,000100,_ZNK12_GLOBAL__N_133BigBirdStateFlyAwayNrvFlyReaction7executeEPN2al11NerveKeeperE
-0x000000710037b9c0,U,000008,_ZNK12_GLOBAL__N_134BigBirdStateFlyAwayNrvFlyAwayStart7executeEPN2al11NerveKeeperE
-0x000000710037b9c8,U,000008,_ZNK12_GLOBAL__N_129BigBirdStateFlyAwayNrvFlyAway7executeEPN2al11NerveKeeperE
+0x000000710037b470,O,000080,_ZN19BigBirdStateFlyAwayC2EPN2al9LiveActorE
+0x000000710037b4c0,O,000096,_ZN19BigBirdStateFlyAway6appearEv
+0x000000710037b520,O,000088,_ZN19BigBirdStateFlyAway17exeGroundReactionEv
+0x000000710037b578,O,000096,_ZN19BigBirdStateFlyAway14exeFlyReactionEv
+0x000000710037b5d8,O,000264,_ZN19BigBirdStateFlyAway17exeFlyAwayPrepareEv
+0x000000710037b6e0,O,000248,_ZN19BigBirdStateFlyAway15exeFlyAwayStartEv
+0x000000710037b7d8,O,000252,_ZN19BigBirdStateFlyAway10exeFlyAwayEv
+0x000000710037b8d4,O,000036,_ZN19BigBirdStateFlyAwayD0Ev
+0x000000710037b8f8,O,000008,_ZNK12_GLOBAL__N_136BigBirdStateFlyAwayNrvFlyAwayPrepare7executeEPN2al11NerveKeeperE
+0x000000710037b900,O,000092,_ZNK12_GLOBAL__N_136BigBirdStateFlyAwayNrvGroundReaction7executeEPN2al11NerveKeeperE
+0x000000710037b95c,O,000100,_ZNK12_GLOBAL__N_133BigBirdStateFlyAwayNrvFlyReaction7executeEPN2al11NerveKeeperE
+0x000000710037b9c0,O,000008,_ZNK12_GLOBAL__N_134BigBirdStateFlyAwayNrvFlyAwayStart7executeEPN2al11NerveKeeperE
+0x000000710037b9c8,O,000008,_ZNK12_GLOBAL__N_129BigBirdStateFlyAwayNrvFlyAway7executeEPN2al11NerveKeeperE
 0x000000710037b9d0,U,000084,_ZN16BigBirdStateWaitC2EPN2al9LiveActorE
 0x000000710037ba24,U,000092,_ZN16BigBirdStateWait6appearEv
 0x000000710037ba80,U,000212,_ZN16BigBirdStateWait11exeWaitLeftEv
@@ -22628,18 +22628,18 @@ Address,Quality,Size,Name
 0x0000007100380d5c,O,000032,_ZN4sead10StrTreeMapILi32ENS_7Vector3IfEEE4Node6erase_Ev
 0x0000007100380d7c,O,000004,_ZN4sead11TreeMapNodeINS_14SafeStringBaseIcEEED2Ev
 0x0000007100380d80,O,000512,_ZN4sead11TreeMapImplINS_14SafeStringBaseIcEEE6insertEPNS_11TreeMapNodeIS2_EES6_
-0x0000007100380f80,U,000060,_ZN20BirdStateFlyAwayBaseC1EPKcPN2al9LiveActorE
-0x0000007100380fbc,U,000092,_ZN20BirdStateFlyAwayBase19initByPlacementInfoERKN2al13ActorInitInfoE
-0x0000007100381018,U,000016,_ZN20BirdStateFlyAwayBase4killEv
-0x0000007100381028,U,000012,_ZN20BirdStateFlyAwayBase25startFlyAwayByHomeLandingEv
-0x0000007100381034,U,000012,_ZN20BirdStateFlyAwayBase23startFlyAwayByCapGroundEv
-0x0000007100381040,U,000012,_ZN20BirdStateFlyAwayBase22startFlyAwayByTouchAirEv
-0x000000710038104c,U,000012,_ZN20BirdStateFlyAwayBase19startFlyAwayByKoopaEv
-0x0000007100381058,U,000016,_ZNK20BirdStateFlyAwayBase22isFlyAwayByHomeLandingEv
-0x0000007100381068,U,000016,_ZNK20BirdStateFlyAwayBase20isFlyAwayByCapGroundEv
-0x0000007100381078,U,000016,_ZNK20BirdStateFlyAwayBase19isFlyAwayByTouchAirEv
-0x0000007100381088,U,000016,_ZNK20BirdStateFlyAwayBase16isFlyAwayByKoopaEv
-0x0000007100381098,U,000036,_ZN20BirdStateFlyAwayBaseD0Ev
+0x0000007100380f80,O,000060,_ZN20BirdStateFlyAwayBaseC1EPKcPN2al9LiveActorE
+0x0000007100380fbc,O,000092,_ZN20BirdStateFlyAwayBase19initByPlacementInfoERKN2al13ActorInitInfoE
+0x0000007100381018,O,000016,_ZN20BirdStateFlyAwayBase4killEv
+0x0000007100381028,O,000012,_ZN20BirdStateFlyAwayBase25startFlyAwayByHomeLandingEv
+0x0000007100381034,O,000012,_ZN20BirdStateFlyAwayBase23startFlyAwayByCapGroundEv
+0x0000007100381040,O,000012,_ZN20BirdStateFlyAwayBase22startFlyAwayByTouchAirEv
+0x000000710038104c,O,000012,_ZN20BirdStateFlyAwayBase19startFlyAwayByKoopaEv
+0x0000007100381058,O,000016,_ZNK20BirdStateFlyAwayBase22isFlyAwayByHomeLandingEv
+0x0000007100381068,O,000016,_ZNK20BirdStateFlyAwayBase20isFlyAwayByCapGroundEv
+0x0000007100381078,O,000016,_ZNK20BirdStateFlyAwayBase19isFlyAwayByTouchAirEv
+0x0000007100381088,O,000016,_ZNK20BirdStateFlyAwayBase16isFlyAwayByKoopaEv
+0x0000007100381098,O,000036,_ZN20BirdStateFlyAwayBaseD0Ev
 0x00000071003810bc,U,000188,_ZN10CapSlotNpcC2EPKcPK19IItemExistanceJudge
 0x0000007100381178,U,000164,_ZN10CapSlotNpcC1EPKcPK19IItemExistanceJudge
 0x000000710038121c,U,000324,_ZN10CapSlotNpc4initERKN2al13ActorInitInfoE
@@ -24580,16 +24580,16 @@ Address,Quality,Size,Name
 0x00000071003d0238,U,001428,_ZN16SkeletonDynamics15updateAutoJointEv
 0x00000071003d07cc,U,000304,_ZN16SkeletonDynamics10applyModelEv
 0x00000071003d08fc,U,000608,
-0x00000071003d0b5c,U,000112,_ZN21SmallBirdStateFlyAwayC1EPN2al9LiveActorE
-0x00000071003d0bcc,U,000192,_ZN21SmallBirdStateFlyAway6appearEv
-0x00000071003d0c8c,U,000080,_ZN21SmallBirdStateFlyAway19startFlyAwayByKoopaEv
-0x00000071003d0cdc,U,002016,_ZN21SmallBirdStateFlyAway10exeFlyAwayEv
-0x00000071003d14bc,U,000340,_ZN21SmallBirdStateFlyAway21exeFlyAwayHomeLandingEv
-0x00000071003d1610,U,000340,_ZN21SmallBirdStateFlyAway15exeFlyAwayKoopaEv
-0x00000071003d1764,U,000036,_ZN21SmallBirdStateFlyAwayD0Ev
-0x00000071003d1788,U,000008,_ZNK12_GLOBAL__N_131SmallBirdStateFlyAwayNrvFlyAway7executeEPN2al11NerveKeeperE
-0x00000071003d1790,U,000008,_ZNK12_GLOBAL__N_142SmallBirdStateFlyAwayNrvFlyAwayHomeLanding7executeEPN2al11NerveKeeperE
-0x00000071003d1798,U,000008,_ZNK12_GLOBAL__N_136SmallBirdStateFlyAwayNrvFlyAwayKoopa7executeEPN2al11NerveKeeperE
+0x00000071003d0b5c,O,000112,_ZN21SmallBirdStateFlyAwayC1EPN2al9LiveActorE
+0x00000071003d0bcc,O,000192,_ZN21SmallBirdStateFlyAway6appearEv
+0x00000071003d0c8c,O,000080,_ZN21SmallBirdStateFlyAway19startFlyAwayByKoopaEv
+0x00000071003d0cdc,m,002016,_ZN21SmallBirdStateFlyAway10exeFlyAwayEv
+0x00000071003d14bc,O,000340,_ZN21SmallBirdStateFlyAway21exeFlyAwayHomeLandingEv
+0x00000071003d1610,O,000340,_ZN21SmallBirdStateFlyAway15exeFlyAwayKoopaEv
+0x00000071003d1764,O,000036,_ZN21SmallBirdStateFlyAwayD0Ev
+0x00000071003d1788,O,000008,_ZNK12_GLOBAL__N_131SmallBirdStateFlyAwayNrvFlyAway7executeEPN2al11NerveKeeperE
+0x00000071003d1790,O,000008,_ZNK12_GLOBAL__N_142SmallBirdStateFlyAwayNrvFlyAwayHomeLanding7executeEPN2al11NerveKeeperE
+0x00000071003d1798,O,000008,_ZNK12_GLOBAL__N_136SmallBirdStateFlyAwayNrvFlyAwayKoopa7executeEPN2al11NerveKeeperE
 0x00000071003d17a0,U,000152,_ZN18SmallBirdStateWaitC2EPN2al9LiveActorERKNS0_13ActorInitInfoE
 0x00000071003d1838,U,000016,_ZN18SmallBirdStateWait6appearEv
 0x00000071003d1848,U,000112,_ZN18SmallBirdStateWait7exeWaitEv

src/Npc/BigBirdStateFlyAway.cpp

@@ -0,0 +1,84 @@
+#include "Npc/BigBirdStateFlyAway.h"
+
+#include "Library/LiveActor/ActorActionFunction.h"
+#include "Library/LiveActor/ActorMovementFunction.h"
+#include "Library/LiveActor/ActorPoseUtil.h"
+#include "Library/Nerve/NerveSetupUtil.h"
+#include "Library/Nerve/NerveUtil.h"
+
+#include "Util/NpcAnimUtil.h"
+
+namespace {
+NERVE_IMPL(BigBirdStateFlyAway, FlyAwayPrepare);
+NERVE_IMPL(BigBirdStateFlyAway, GroundReaction);
+NERVE_IMPL(BigBirdStateFlyAway, FlyReaction);
+NERVE_IMPL(BigBirdStateFlyAway, FlyAwayStart);
+NERVE_IMPL(BigBirdStateFlyAway, FlyAway);
+
+NERVES_MAKE_NOSTRUCT(BigBirdStateFlyAway, FlyAwayStart);
+NERVES_MAKE_NOSTRUCT(BigBirdStateFlyAway, FlyAway);
+NERVES_MAKE_STRUCT(BigBirdStateFlyAway, FlyAwayPrepare, GroundReaction, FlyReaction);
+}  // namespace
+
+BigBirdStateFlyAway::BigBirdStateFlyAway(al::LiveActor* actor)
+    : BirdStateFlyAwayBase("大鳥の飛び去り", actor) {
+    initNerve(&NrvBigBirdStateFlyAway.FlyAwayPrepare, 0);
+}
+
+void BigBirdStateFlyAway::appear() {
+    BirdStateFlyAwayBase::appear();
+    if (isFlyAwayByCapGround())
+        al::setNerve(this, &NrvBigBirdStateFlyAway.GroundReaction);
+    else if (isFlyAwayByTouchAir())
+        al::setNerve(this, &NrvBigBirdStateFlyAway.FlyReaction);
+    else
+        al::setNerve(this, &NrvBigBirdStateFlyAway.FlyAwayPrepare);
+}
+
+void BigBirdStateFlyAway::exeGroundReaction() {
+    if (al::isFirstStep(this))
+        al::startAction(mActor, "GroundReaction");
+    if (al::isActionEnd(mActor))
+        al::setNerve(this, &NrvBigBirdStateFlyAway.FlyAwayPrepare);
+}
+
+void BigBirdStateFlyAway::exeFlyReaction() {
+    if (al::isFirstStep(this)) {
+        al::startAction(mActor, "FlyReaction");
+        al::setVelocityZero(mActor);
+    }
+    if (al::isActionEnd(mActor))
+        al::setNerve(this, &NrvBigBirdStateFlyAway.FlyAwayPrepare);
+}
+
+void BigBirdStateFlyAway::exeFlyAwayPrepare() {
+    if (al::isFirstStep(this)) {
+        al::startAction(mActor, "FlyStart");
+        al::setVelocityY(mActor, 30);
+    }
+    al::addVelocity(mActor, al::getGravity(mActor) * 0.75f +
+                                al::getFront(mActor) * al::calcNerveValue(this, 10, 0.0f, 2.0f));
+    al::scaleVelocityHV(mActor, 0.97f, 0.9f);
+    al::setNerveAtGreaterEqualStep(this, &FlyAwayStart, 10);
+}
+
+void BigBirdStateFlyAway::exeFlyAwayStart() {
+    al::addVelocity(
+        mActor,
+        -al::getGravity(mActor) * 0.7f +
+            al::getFront(mActor) *
+                al::calcNerveValue(this, al::getActionFrameMax(mActor, "FlyStart"), 2.0f, 0.8f));
+    al::scaleVelocity(mActor, 0.97f);
+    if (al::isActionEnd(mActor))
+        al::setNerve(this, &FlyAway);
+}
+
+void BigBirdStateFlyAway::exeFlyAway() {
+    if (al::isFirstStep(this))
+        al::startAction(mActor, "Fly");
+    al::addVelocity(mActor, -al::getGravity(mActor) * 0.7f + al::getFront(mActor) * 0.8f);
+    al::scaleVelocity(mActor, 0.97f);
+    BirdFunction::tryUpdateFlyAwayDisappearDitherAlpha(mActor, this, 180, 240);
+    if (al::isGreaterEqualStep(this, 240))
+        kill();
+}

src/Npc/BigBirdStateFlyAway.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Npc/BirdStateFlyAwayBase.h"
+
+class BigBirdStateFlyAway : public BirdStateFlyAwayBase {
+public:
+    BigBirdStateFlyAway(al::LiveActor* actor);
+
+    void appear() override;
+
+    void exeGroundReaction();
+    void exeFlyReaction();
+    void exeFlyAwayPrepare();
+    void exeFlyAwayStart();
+    void exeFlyAway();
+};
+
+static_assert(sizeof(BigBirdStateFlyAway) == 0x38);

src/Npc/BirdStateFlyAwayBase.cpp

@@ -0,0 +1,50 @@
+#include "Npc/BirdStateFlyAwayBase.h"
+
+#include "Library/Placement/PlacementFunction.h"
+
+BirdStateFlyAwayBase::BirdStateFlyAwayBase(const char* name, al::LiveActor* actor)
+    : al::ActorStateBase(name, actor) {}
+
+void BirdStateFlyAwayBase::initByPlacementInfo(const al::ActorInitInfo& info) {
+    if (al::isExistLinkChild(info, "TargetPos", 0)) {
+        mHasTargetPos = true;
+        al::getChildTrans(&mTargetPos, info, "TargetPos");
+    }
+}
+
+void BirdStateFlyAwayBase::kill() {
+    al::NerveStateBase::kill();
+    mCause = FlyAwayCause::None;
+}
+
+void BirdStateFlyAwayBase::startFlyAwayByHomeLanding() {
+    mCause = FlyAwayCause::HomeLanding;
+}
+
+void BirdStateFlyAwayBase::startFlyAwayByCapGround() {
+    mCause = FlyAwayCause::CapGround;
+}
+
+void BirdStateFlyAwayBase::startFlyAwayByTouchAir() {
+    mCause = FlyAwayCause::TouchAir;
+}
+
+void BirdStateFlyAwayBase::startFlyAwayByKoopa() {
+    mCause = FlyAwayCause::Koopa;
+}
+
+bool BirdStateFlyAwayBase::isFlyAwayByHomeLanding() const {
+    return mCause == FlyAwayCause::HomeLanding;
+}
+
+bool BirdStateFlyAwayBase::isFlyAwayByCapGround() const {
+    return mCause == FlyAwayCause::CapGround;
+}
+
+bool BirdStateFlyAwayBase::isFlyAwayByTouchAir() const {
+    return mCause == FlyAwayCause::TouchAir;
+}
+
+bool BirdStateFlyAwayBase::isFlyAwayByKoopa() const {
+    return mCause == FlyAwayCause::Koopa;
+}

src/Npc/BirdStateFlyAwayBase.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <math/seadVector.h>
+
+#include "Library/Nerve/NerveStateBase.h"
+
+namespace al {
+struct ActorInitInfo;
+}
+
+class BirdStateFlyAwayBase : public al::ActorStateBase {
+public:
+    BirdStateFlyAwayBase(const char* name, al::LiveActor* actor);
+
+    virtual void initByPlacementInfo(const al::ActorInitInfo& info);
+    void kill() override;
+
+    void startFlyAwayByHomeLanding();
+    void startFlyAwayByCapGround();
+    void startFlyAwayByTouchAir();
+    virtual void startFlyAwayByKoopa();
+
+    bool isFlyAwayByHomeLanding() const;
+    bool isFlyAwayByCapGround() const;
+    bool isFlyAwayByTouchAir() const;
+    bool isFlyAwayByKoopa() const;
+
+protected:
+    bool mHasTargetPos = false;
+    sead::Vector3f mTargetPos = {0, 0, 0};
+
+private:
+    enum class FlyAwayCause { None, HomeLanding, CapGround, TouchAir, Koopa };
+
+    FlyAwayCause mCause = FlyAwayCause::None;
+};
+
+static_assert(sizeof(BirdStateFlyAwayBase) == 0x38);

src/Npc/SmallBirdStateFlyAway.cpp

@@ -0,0 +1,207 @@
+#include "Npc/SmallBirdStateFlyAway.h"
+
+#include "Library/Collision/CollisionPartsKeeperUtil.h"
+#include "Library/Collision/CollisionPartsTriangle.h"
+#include "Library/LiveActor/ActorActionFunction.h"
+#include "Library/LiveActor/ActorMovementFunction.h"
+#include "Library/LiveActor/ActorPoseUtil.h"
+#include "Library/LiveActor/LiveActor.h"
+#include "Library/Math/MathUtil.h"
+#include "Library/Nerve/NerveSetupUtil.h"
+#include "Library/Nerve/NerveUtil.h"
+
+#include "Util/NpcAnimUtil.h"
+#include "Util/SpecialBuildUtil.h"
+
+namespace {
+NERVE_IMPL(SmallBirdStateFlyAway, FlyAway);
+NERVE_IMPL(SmallBirdStateFlyAway, FlyAwayHomeLanding);
+NERVE_IMPL(SmallBirdStateFlyAway, FlyAwayKoopa);
+
+NERVES_MAKE_STRUCT(SmallBirdStateFlyAway, FlyAway, FlyAwayHomeLanding, FlyAwayKoopa);
+}  // namespace
+
+SmallBirdStateFlyAway::SmallBirdStateFlyAway(al::LiveActor* actor)
+    : BirdStateFlyAwayBase("小鳥の飛び去り", actor) {
+    initNerve(&NrvSmallBirdStateFlyAway.FlyAway, 0);
+}
+
+void SmallBirdStateFlyAway::appear() {
+    BirdStateFlyAwayBase::appear();
+    mDisappearStep = al::getRandom(10) * 5 + 240;
+    if (isFlyAwayByHomeLanding()) {
+        mAngle = al::getRandom(45.0f, 70.0f);
+        al::setNerve(this, &NrvSmallBirdStateFlyAway.FlyAwayHomeLanding);
+    } else if (isFlyAwayByKoopa()) {
+        mAngle = al::getRandom(45.0f, 70.0f);
+        al::setNerve(this, &NrvSmallBirdStateFlyAway.FlyAwayKoopa);
+    } else {
+        mTargetDir.set(al::getFront(mActor));
+        al::setNerve(this, &NrvSmallBirdStateFlyAway.FlyAway);
+    }
+}
+
+static void startActionAtRandomFrameIfNotPlaying(al::LiveActor* actor, const char* action_name) {
+    if (!al::isActionPlaying(actor, action_name))
+        al::startActionAtRandomFrame(actor, action_name);
+}
+
+void SmallBirdStateFlyAway::startFlyAwayByKoopa() {
+    BirdStateFlyAwayBase::startFlyAwayByKoopa();
+    startActionAtRandomFrameIfNotPlaying(mActor, "Fly");
+}
+
+// TODO: Probably within `sead`
+static void setLength(sead::Vector3f* vec, f32 length) {
+    f32 old_length = vec->length();
+    if (old_length > 0)
+        *vec *= length / old_length;
+}
+
+static void turnVecToVecDegree(sead::Vector3f* vec, const sead::Vector3f& other, f32 degree) {
+    al::turnVecToVecDegree(vec, *vec, other, degree);
+}
+
+static void turnVecToVecRate(sead::Vector3f* vec, const sead::Vector3f& other, f32 rate) {
+    al::turnVecToVecRate(vec, *vec, other, rate);
+}
+
+static bool tryFaceToHorizontalDirection(al::LiveActor* actor, const sead::Vector3f& dir) {
+    sead::Vector3f horizontal_dir = dir;
+    al::verticalizeVec(&horizontal_dir, al::getGravity(actor), horizontal_dir);
+    if (!al::tryNormalizeOrZero(&horizontal_dir))
+        return false;
+    al::faceToDirection(actor, horizontal_dir);
+    return true;
+}
+
+// NON_MATCHING: wrong offset in store, should probably be ignored by tools/check
+// (https://decomp.me/scratch/icRWQ)
+void SmallBirdStateFlyAway::exeFlyAway() {
+    if (al::isFirstStep(this)) {
+        static const f32 gHorizontalAccel = 2.0f;
+        static const f32 gE3MovieHorizontalAccel[] = {2.0f, 3.0f, 4.0f, 5.0f};
+        static const f32 gVerticalAccel[] = {0.7f, 0.65f, 0.6f, 0.55f};
+        static const f32 gE3MovieVerticalAccel[] = {3.0f, 3.5f, 4.0f, 4.5f, 5.0f, 5.5f};
+        static s32 gVerticalAccelIndex = 0;
+        static s32 gHorizontalAccelIndex = 0;
+        static s32 gCollisionCheckOffsetStep = 0;
+
+        mIsColliding = false;
+        startActionAtRandomFrameIfNotPlaying(mActor, "Fly");
+        if (rs::isModeE3MovieRom()) {
+            gVerticalAccelIndex = al::modi(gVerticalAccelIndex + 7, 6);
+            mVerticalAccel = gE3MovieVerticalAccel[gVerticalAccelIndex];
+            gHorizontalAccelIndex = al::modi(gHorizontalAccelIndex + 5, 4);
+            mHorizontalAccel = gE3MovieHorizontalAccel[gHorizontalAccelIndex];
+        } else {
+            gVerticalAccelIndex = al::modi(gVerticalAccelIndex + 5, 4);
+            mVerticalAccel = gVerticalAccel[gVerticalAccelIndex];
+            mHorizontalAccel = gHorizontalAccel;
+        }
+        mTargetAccelDir = {0, mVerticalAccel, mHorizontalAccel};
+        al::normalize(&mTargetAccelDir);
+        gCollisionCheckOffsetStep = al::modi(gCollisionCheckOffsetStep + 11, 10);
+        mCollisionCheckOffsetStep = gCollisionCheckOffsetStep;
+    }
+
+    if (mHasTargetPos) {
+        sead::Vector3f velocity = al::getVelocity(mActor);
+        al::parallelizeVec(&velocity, al::getFront(mActor), velocity);
+        *al::getVelocityPtr(mActor) -= velocity;
+
+        sead::Vector3f target_dir = mTargetPos - al::getTrans(mActor);
+        al::verticalizeVec(&target_dir, al::getGravity(mActor), target_dir);
+        if (!al::tryNormalizeOrZero(&target_dir))
+            target_dir.set(al::getFront(mActor));
+        al::turnVecToVecDegree(&target_dir, al::getFront(mActor), target_dir, 15);
+        turnVecToVecRate(&mTargetDir, target_dir, 0.2f);
+        al::normalize(&mTargetDir);
+        turnVecToVecRate(al::getFrontPtr(mActor), mTargetDir, 0.1f);
+        al::normalize(al::getFrontPtr(mActor));
+
+        *al::getVelocityPtr(mActor) += velocity.length() * al::getFront(mActor);
+    }
+
+    sead::Quatf quat = sead::Quatf::unit;
+    al::calcQuat(&quat, mActor);
+
+    sead::Vector3f accel = {0, mVerticalAccel, mHorizontalAccel};
+    f32 accel_mag = accel.length();
+
+    if (al::isFirstStep(this) || al::isIntervalStep(this, 10, mCollisionCheckOffsetStep)) {
+        sead::Vector3f rotated = accel;
+        rotated.rotate(quat);
+        sead::Vector3f vec = rotated;
+        f32 max_speed = al::calcSpeedMax(accel_mag, 0.97f);
+        setLength(&vec, max_speed * 60);
+        sead::Vector3f hit_pos = {0, 0, 0};
+        al::Triangle triangle;
+        mIsColliding = alCollisionUtil::getFirstPolyOnArrow(
+            mActor, &hit_pos, &triangle, al::getTrans(mActor), vec, nullptr, nullptr);
+        if (mIsColliding) {
+            f32 distance = (hit_pos - al::getTrans(mActor)).length();
+            if (distance < max_speed * 10 && !al::isFirstStep(this)) {
+                bool turn_successful = tryFaceToHorizontalDirection(mActor, triangle.getNormal(0));
+                if (!turn_successful)
+                    mHorizontalAccel = 0;
+            }
+        }
+    }
+
+    sead::Vector3f accel_dir = {0, mVerticalAccel, mHorizontalAccel};
+    al::normalize(&accel_dir);
+    if (mIsColliding) {
+        turnVecToVecDegree(&mTargetAccelDir, sead::Vector3f::ey, 2.5);
+        al::normalize(&mTargetAccelDir);
+    }
+    turnVecToVecRate(&accel_dir, mTargetAccelDir, 0.15f);
+    al::normalize(&accel_dir);
+
+    accel = accel_dir * accel_mag;
+    mVerticalAccel = accel.y;
+    mHorizontalAccel = accel.z;
+
+    f32 old_accel = al::calcNerveValue(this, 1, 31, 2.0f, 0.8f);
+    f32 new_accel = al::calcNerveValue(this, 30, 2.0f, 0.8f);
+    mHorizontalAccel *= al::normalize(new_accel, 0.0f, old_accel);
+
+    sead::Vector3f rotated = accel_dir;
+    rotated.rotate(quat);
+    al::setVelocity(mActor, rotated * al::calcSpeed(mActor));
+    al::addVelocity(mActor, -al::getGravity(mActor) * mVerticalAccel +
+                                al::getFront(mActor) * mHorizontalAccel);
+    al::scaleVelocity(mActor, 0.97f);
+    BirdFunction::tryUpdateFlyAwayDisappearDitherAlpha(mActor, this, mDisappearStep - 60,
+                                                       mDisappearStep);
+    if (al::isGreaterEqualStep(this, mDisappearStep))
+        kill();
+}
+
+void SmallBirdStateFlyAway::exeFlyAwayHomeLanding() {
+    if (al::isFirstStep(this))
+        startActionAtRandomFrameIfNotPlaying(mActor, "Fly");
+    al::addVelocity(mActor,
+                    (al::getFront(mActor) * sead::Mathf::sin(sead::Mathf::deg2rad(mAngle)) -
+                     al::getGravity(mActor) * sead::Mathf::cos(sead::Mathf::deg2rad(mAngle))) *
+                        al::calcNerveValue(this, 30, 1.75f, 0.75f));
+    al::scaleVelocity(mActor, 0.97f);
+    BirdFunction::tryUpdateFlyAwayDisappearDitherAlpha(mActor, this, mDisappearStep - 60,
+                                                       mDisappearStep);
+    if (al::isGreaterEqualStep(this, mDisappearStep))
+        kill();
+}
+
+void SmallBirdStateFlyAway::exeFlyAwayKoopa() {
+    if (al::isFirstStep(this))
+        startActionAtRandomFrameIfNotPlaying(mActor, "Fly");
+    al::addVelocity(mActor,
+                    (al::getFront(mActor) * sead::Mathf::sin(sead::Mathf::deg2rad(mAngle)) -
+                     al::getGravity(mActor) * sead::Mathf::cos(sead::Mathf::deg2rad(mAngle))) *
+                        al::calcNerveValue(this, 30, 5.5f, 4.0f));
+    al::scaleVelocity(mActor, 0.97f);
+    BirdFunction::tryUpdateFlyAwayDisappearDitherAlpha(mActor, this, mDisappearStep - 60,
+                                                       mDisappearStep);
+    if (al::isGreaterEqualStep(this, mDisappearStep))
+        kill();
+}

src/Npc/SmallBirdStateFlyAway.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Npc/BirdStateFlyAwayBase.h"
+
+class SmallBirdStateFlyAway : public BirdStateFlyAwayBase {
+public:
+    SmallBirdStateFlyAway(al::LiveActor* actor);
+
+    void appear() override;
+    void startFlyAwayByKoopa() override;
+
+    void exeFlyAway();
+    void exeFlyAwayHomeLanding();
+    void exeFlyAwayKoopa();
+
+private:
+    sead::Vector3f mTargetDir = {0, 0, 0};
+    f32 mHorizontalAccel = 0;
+    f32 mVerticalAccel = 0;
+    sead::Vector3f mTargetAccelDir = {0, 0, 0};
+    s32 mDisappearStep = 240;
+    s32 mCollisionCheckOffsetStep = 0;
+    bool mIsColliding = false;
+    f32 mAngle = 0;
+};
+
+static_assert(sizeof(SmallBirdStateFlyAway) == 0x68);

src/Util/NpcAnimUtil.h

@@ -5,18 +5,18 @@
 #include <math/seadVector.h>
 
 namespace al {
-struct ActorInitInfo;
-class LiveActor;
 class HitSensor;
-class SensorMsg;
+class IUseNerve;
+class LiveActor;
 class MtxConnector;
+class SensorMsg;
+struct ActorInitInfo;
 }  // namespace al
-
-class TalkNpcParam;
+class ActorStateReactionBase;
 class NpcJointLookAtController;
 class NpcStateReactionParam;
 class PlayerEyeSensorHitHolder;
-class ShellActorStateReaction;
+class TalkNpcParam;
 
 namespace rs {
 bool tryApplyNpcMaterialAnimPresetFromPlacementInfo(al::LiveActor*, const al::ActorInitInfo&,
@@ -56,7 +56,16 @@ void syncActionCityMayorFace(al::LiveActor*);
 void syncMtsAnimCityMayorFace(al::LiveActor*);
 bool isExistFaceAnim(al::LiveActor*, const char*);
 void animateCityMayorFace(al::LiveActor*, const char*, f32);
-ShellActorStateReaction* createNpcStateReaction(al::LiveActor*, const TalkNpcParam*,
-                                                const NpcStateReactionParam*);
+ActorStateReactionBase* createNpcStateReaction(al::LiveActor*, const TalkNpcParam*,
+                                               const NpcStateReactionParam*);
 bool isInvalidTrampleSensor(const al::HitSensor*, const TalkNpcParam*);
 }  // namespace rs
+
+namespace TalkNpcFunction {
+bool tryGetHackingEventHackType(s32*, const al::ActorInitInfo&);
+}
+
+namespace BirdFunction {
+void tryUpdateFlyAwayDisappearDitherAlpha(al::LiveActor* actor, const al::IUseNerve* user,
+                                          s32 start_step, s32 end_step);
+}