Generate AIs

src/Game/AI/AI/aiASWeaponRoot.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/AI/aiASWeaponRoot.h"
+
+namespace uking::ai {
+
+ASWeaponRoot::ASWeaponRoot(const InitArg& arg) : WeaponRootAI(arg) {}
+
+ASWeaponRoot::~ASWeaponRoot() = default;
+
+bool ASWeaponRoot::init_(sead::Heap* heap) {
+    return WeaponRootAI::init_(heap);
+}
+
+void ASWeaponRoot::enter_(ksys::act::ai::InlineParamPack* params) {
+    WeaponRootAI::enter_(params);
+}
+
+void ASWeaponRoot::leave_() {
+    WeaponRootAI::leave_();
+}
+
+void ASWeaponRoot::loadParams_() {
+    WeaponRootAI::loadParams_();
+    getStaticParam(&mEquiped_s, "Equiped");
+    getStaticParam(&mUnEquiped_s, "UnEquiped");
+    getStaticParam(&mThrown_s, "Thrown");
+    getStaticParam(&mStick_s, "Stick");
+    getStaticParam(&mCancelStick_s, "CancelStick");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiASWeaponRoot.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Game/AI/AI/aiWeaponRootAI.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class ASWeaponRoot : public WeaponRootAI {
+    SEAD_RTTI_OVERRIDE(ASWeaponRoot, WeaponRootAI)
+public:
+    explicit ASWeaponRoot(const InitArg& arg);
+    ~ASWeaponRoot() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0xe8
+    sead::SafeString mEquiped_s{};
+    // static_param at offset 0xf8
+    sead::SafeString mUnEquiped_s{};
+    // static_param at offset 0x108
+    sead::SafeString mThrown_s{};
+    // static_param at offset 0x118
+    sead::SafeString mStick_s{};
+    // static_param at offset 0x128
+    sead::SafeString mCancelStick_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiActorWaterDepthSelect.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/AI/aiActorWaterDepthSelect.h"
+
+namespace uking::ai {
+
+ActorWaterDepthSelect::ActorWaterDepthSelect(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+ActorWaterDepthSelect::~ActorWaterDepthSelect() = default;
+
+bool ActorWaterDepthSelect::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void ActorWaterDepthSelect::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void ActorWaterDepthSelect::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void ActorWaterDepthSelect::loadParams_() {
+    getStaticParam(&mDeepDepth_s, "DeepDepth");
+    getStaticParam(&mOnEnterOnly_s, "OnEnterOnly");
+    getStaticParam(&mForceDeepChange_s, "ForceDeepChange");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiActorWaterDepthSelect.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class ActorWaterDepthSelect : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(ActorWaterDepthSelect, ksys::act::ai::Ai)
+public:
+    explicit ActorWaterDepthSelect(const InitArg& arg);
+    ~ActorWaterDepthSelect() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mDeepDepth_s{};
+    // static_param at offset 0x40
+    const bool* mOnEnterOnly_s{};
+    // static_param at offset 0x48
+    const bool* mForceDeepChange_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddBasicLinkOn.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAddBasicLinkOn.h"
+
+namespace uking::ai {
+
+AddBasicLinkOn::AddBasicLinkOn(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AddBasicLinkOn::~AddBasicLinkOn() = default;
+
+bool AddBasicLinkOn::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AddBasicLinkOn::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AddBasicLinkOn::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AddBasicLinkOn::loadParams_() {
+    getStaticParam(&mOnlyOne_s, "OnlyOne");
+    getStaticParam(&mIsBroadCastOnlyOne_s, "IsBroadCastOnlyOne");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddBasicLinkOn.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddBasicLinkOn : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AddBasicLinkOn, ksys::act::ai::Ai)
+public:
+    explicit AddBasicLinkOn(const InitArg& arg);
+    ~AddBasicLinkOn() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const bool* mOnlyOne_s{};
+    // static_param at offset 0x40
+    const bool* mIsBroadCastOnlyOne_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddCarried.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/AI/aiAddCarried.h"
+
+namespace uking::ai {
+
+AddCarried::AddCarried(const InitArg& arg) : AddCarriedBase(arg) {}
+
+AddCarried::~AddCarried() = default;
+
+bool AddCarried::init_(sead::Heap* heap) {
+    return AddCarriedBase::init_(heap);
+}
+
+void AddCarried::enter_(ksys::act::ai::InlineParamPack* params) {
+    AddCarriedBase::enter_(params);
+}
+
+void AddCarried::leave_() {
+    AddCarriedBase::leave_();
+}
+
+void AddCarried::loadParams_() {
+    AddCarriedBase::loadParams_();
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddCarried.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Game/AI/AI/aiAddCarriedBase.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddCarried : public AddCarriedBase {
+    SEAD_RTTI_OVERRIDE(AddCarried, AddCarriedBase)
+public:
+    explicit AddCarried(const InitArg& arg);
+    ~AddCarried() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddCarriedBase.cpp

@@ -0,0 +1,28 @@
+#include "Game/AI/AI/aiAddCarriedBase.h"
+
+namespace uking::ai {
+
+AddCarriedBase::AddCarriedBase(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AddCarriedBase::~AddCarriedBase() = default;
+
+bool AddCarriedBase::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AddCarriedBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AddCarriedBase::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AddCarriedBase::loadParams_() {
+    getStaticParam(&mFailDistance_s, "FailDistance");
+    getStaticParam(&mIsRecoverCharCtrlAxis_s, "IsRecoverCharCtrlAxis");
+    getStaticParam(&mIsUseConstraint_s, "IsUseConstraint");
+    getStaticParam(&mHoldOnXLinkKey_s, "HoldOnXLinkKey");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddCarriedBase.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddCarriedBase : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AddCarriedBase, ksys::act::ai::Ai)
+public:
+    explicit AddCarriedBase(const InitArg& arg);
+    ~AddCarriedBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mFailDistance_s{};
+    // static_param at offset 0x40
+    const bool* mIsRecoverCharCtrlAxis_s{};
+    // static_param at offset 0x48
+    const bool* mIsUseConstraint_s{};
+    // static_param at offset 0x50
+    sead::SafeString mHoldOnXLinkKey_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddDemoCall.cpp

@@ -0,0 +1,28 @@
+#include "Game/AI/AI/aiAddDemoCall.h"
+
+namespace uking::ai {
+
+AddDemoCall::AddDemoCall(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AddDemoCall::~AddDemoCall() = default;
+
+bool AddDemoCall::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AddDemoCall::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AddDemoCall::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AddDemoCall::loadParams_() {
+    getStaticParam(&mOnlyOne_s, "OnlyOne");
+    getStaticParam(&mIsBroadCastOnlyOne_s, "IsBroadCastOnlyOne");
+    getStaticParam(&mEntryPoint_s, "EntryPoint");
+    getStaticParam(&mDemoName_s, "DemoName");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddDemoCall.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddDemoCall : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AddDemoCall, ksys::act::ai::Ai)
+public:
+    explicit AddDemoCall(const InitArg& arg);
+    ~AddDemoCall() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const bool* mOnlyOne_s{};
+    // static_param at offset 0x40
+    const bool* mIsBroadCastOnlyOne_s{};
+    // static_param at offset 0x48
+    sead::SafeString mEntryPoint_s{};
+    // static_param at offset 0x58
+    sead::SafeString mDemoName_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddNodeNodeCarried.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/AI/aiAddNodeNodeCarried.h"
+
+namespace uking::ai {
+
+AddNodeNodeCarried::AddNodeNodeCarried(const InitArg& arg) : AddCarriedBase(arg) {}
+
+AddNodeNodeCarried::~AddNodeNodeCarried() = default;
+
+bool AddNodeNodeCarried::init_(sead::Heap* heap) {
+    return AddCarriedBase::init_(heap);
+}
+
+void AddNodeNodeCarried::enter_(ksys::act::ai::InlineParamPack* params) {
+    AddCarriedBase::enter_(params);
+}
+
+void AddNodeNodeCarried::leave_() {
+    AddCarriedBase::leave_();
+}
+
+void AddNodeNodeCarried::loadParams_() {
+    AddCarriedBase::loadParams_();
+    getStaticParam(&mMyNode_s, "MyNode");
+    getStaticParam(&mNodeRotOffset_s, "NodeRotOffset");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddNodeNodeCarried.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Game/AI/AI/aiAddCarriedBase.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddNodeNodeCarried : public AddCarriedBase {
+    SEAD_RTTI_OVERRIDE(AddNodeNodeCarried, AddCarriedBase)
+public:
+    explicit AddNodeNodeCarried(const InitArg& arg);
+    ~AddNodeNodeCarried() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x138
+    sead::SafeString mMyNode_s{};
+    // static_param at offset 0x148
+    const sead::Vector3f* mNodeRotOffset_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddNoiseToTargetPos.cpp

@@ -0,0 +1,32 @@
+#include "Game/AI/AI/aiAddNoiseToTargetPos.h"
+
+namespace uking::ai {
+
+AddNoiseToTargetPos::AddNoiseToTargetPos(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AddNoiseToTargetPos::~AddNoiseToTargetPos() = default;
+
+bool AddNoiseToTargetPos::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AddNoiseToTargetPos::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AddNoiseToTargetPos::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AddNoiseToTargetPos::loadParams_() {
+    getStaticParam(&mRandYMin_s, "RandYMin");
+    getStaticParam(&mRandYMax_s, "RandYMax");
+    getStaticParam(&mRandLeftMax_s, "RandLeftMax");
+    getStaticParam(&mRandRightMax_s, "RandRightMax");
+    getStaticParam(&mRandDistMin_s, "RandDistMin");
+    getStaticParam(&mRandDistMax_s, "RandDistMax");
+    getStaticParam(&mIsUpdateEveryFrame_s, "IsUpdateEveryFrame");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddNoiseToTargetPos.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddNoiseToTargetPos : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AddNoiseToTargetPos, ksys::act::ai::Ai)
+public:
+    explicit AddNoiseToTargetPos(const InitArg& arg);
+    ~AddNoiseToTargetPos() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mRandYMin_s{};
+    // static_param at offset 0x40
+    const float* mRandYMax_s{};
+    // static_param at offset 0x48
+    const float* mRandLeftMax_s{};
+    // static_param at offset 0x50
+    const float* mRandRightMax_s{};
+    // static_param at offset 0x58
+    const float* mRandDistMin_s{};
+    // static_param at offset 0x60
+    const float* mRandDistMax_s{};
+    // static_param at offset 0x68
+    const bool* mIsUpdateEveryFrame_s{};
+    // dynamic_param at offset 0x70
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddPlayerLargeAttackJustGuard.cpp

@@ -0,0 +1,22 @@
+#include "Game/AI/AI/aiAddPlayerLargeAttackJustGuard.h"
+
+namespace uking::ai {
+
+AddPlayerLargeAttackJustGuard::AddPlayerLargeAttackJustGuard(const InitArg& arg)
+    : ksys::act::ai::Ai(arg) {}
+
+bool AddPlayerLargeAttackJustGuard::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AddPlayerLargeAttackJustGuard::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AddPlayerLargeAttackJustGuard::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AddPlayerLargeAttackJustGuard::loadParams_() {}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddPlayerLargeAttackJustGuard.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddPlayerLargeAttackJustGuard : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AddPlayerLargeAttackJustGuard, ksys::act::ai::Ai)
+public:
+    explicit AddPlayerLargeAttackJustGuard(const InitArg& arg);
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddSwarmMove.cpp

@@ -0,0 +1,31 @@
+#include "Game/AI/AI/aiAddSwarmMove.h"
+
+namespace uking::ai {
+
+AddSwarmMove::AddSwarmMove(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AddSwarmMove::~AddSwarmMove() = default;
+
+bool AddSwarmMove::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AddSwarmMove::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AddSwarmMove::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AddSwarmMove::loadParams_() {
+    getStaticParam(&mIgnoreSensorTime_s, "IgnoreSensorTime");
+    getStaticParam(&mSubSpeed_s, "SubSpeed");
+    getStaticParam(&mSubAccRateMin_s, "SubAccRateMin");
+    getStaticParam(&mSubAccRateMax_s, "SubAccRateMax");
+    getStaticParam(&mIsEndBySensor_s, "IsEndBySensor");
+    getStaticParam(&mAnimName_s, "AnimName");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddSwarmMove.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddSwarmMove : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AddSwarmMove, ksys::act::ai::Ai)
+public:
+    explicit AddSwarmMove(const InitArg& arg);
+    ~AddSwarmMove() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const int* mIgnoreSensorTime_s{};
+    // static_param at offset 0x40
+    const float* mSubSpeed_s{};
+    // static_param at offset 0x48
+    const float* mSubAccRateMin_s{};
+    // static_param at offset 0x50
+    const float* mSubAccRateMax_s{};
+    // static_param at offset 0x58
+    const bool* mIsEndBySensor_s{};
+    // static_param at offset 0x60
+    sead::SafeString mAnimName_s{};
+    // dynamic_param at offset 0x70
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddViewTargetPos.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/AI/aiAddViewTargetPos.h"
+
+namespace uking::ai {
+
+AddViewTargetPos::AddViewTargetPos(const InitArg& arg) : AddViewTargetPosBase(arg) {}
+
+AddViewTargetPos::~AddViewTargetPos() = default;
+
+bool AddViewTargetPos::init_(sead::Heap* heap) {
+    return AddViewTargetPosBase::init_(heap);
+}
+
+void AddViewTargetPos::enter_(ksys::act::ai::InlineParamPack* params) {
+    AddViewTargetPosBase::enter_(params);
+}
+
+void AddViewTargetPos::leave_() {
+    AddViewTargetPosBase::leave_();
+}
+
+void AddViewTargetPos::loadParams_() {
+    AddViewTargetPosBase::loadParams_();
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddViewTargetPos.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Game/AI/AI/aiAddViewTargetPosBase.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddViewTargetPos : public AddViewTargetPosBase {
+    SEAD_RTTI_OVERRIDE(AddViewTargetPos, AddViewTargetPosBase)
+public:
+    explicit AddViewTargetPos(const InitArg& arg);
+    ~AddViewTargetPos() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddViewTargetPosBase.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/AI/aiAddViewTargetPosBase.h"
+
+namespace uking::ai {
+
+AddViewTargetPosBase::AddViewTargetPosBase(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AddViewTargetPosBase::~AddViewTargetPosBase() = default;
+
+bool AddViewTargetPosBase::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AddViewTargetPosBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AddViewTargetPosBase::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AddViewTargetPosBase::loadParams_() {}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAddViewTargetPosBase.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AddViewTargetPosBase : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AddViewTargetPosBase, ksys::act::ai::Ai)
+public:
+    explicit AddViewTargetPosBase(const InitArg& arg);
+    ~AddViewTargetPosBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaBoardBurn.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAirOctaBoardBurn.h"
+
+namespace uking::ai {
+
+AirOctaBoardBurn::AirOctaBoardBurn(const InitArg& arg) : SeqTwoAction(arg) {}
+
+AirOctaBoardBurn::~AirOctaBoardBurn() = default;
+
+bool AirOctaBoardBurn::init_(sead::Heap* heap) {
+    return SeqTwoAction::init_(heap);
+}
+
+void AirOctaBoardBurn::enter_(ksys::act::ai::InlineParamPack* params) {
+    SeqTwoAction::enter_(params);
+}
+
+void AirOctaBoardBurn::leave_() {
+    SeqTwoAction::leave_();
+}
+
+void AirOctaBoardBurn::loadParams_() {
+    SeqTwoAction::loadParams_();
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaBoardBurn.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Game/AI/AI/aiSeqTwoAction.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AirOctaBoardBurn : public SeqTwoAction {
+    SEAD_RTTI_OVERRIDE(AirOctaBoardBurn, SeqTwoAction)
+public:
+    explicit AirOctaBoardBurn(const InitArg& arg);
+    ~AirOctaBoardBurn() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // aitree_variable at offset 0x50
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaBurnReaction.cpp

@@ -0,0 +1,29 @@
+#include "Game/AI/AI/aiAirOctaBurnReaction.h"
+
+namespace uking::ai {
+
+AirOctaBurnReaction::AirOctaBurnReaction(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AirOctaBurnReaction::~AirOctaBurnReaction() = default;
+
+bool AirOctaBurnReaction::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AirOctaBurnReaction::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AirOctaBurnReaction::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AirOctaBurnReaction::loadParams_() {
+    getStaticParam(&mDisconnectTime_s, "DisconnectTime");
+    getStaticParam(&mDisconnectRandTime_s, "DisconnectRandTime");
+    getStaticParam(&mSingleBurnTime_s, "SingleBurnTime");
+    getStaticParam(&mChangeRandTime_s, "ChangeRandTime");
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaBurnReaction.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AirOctaBurnReaction : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AirOctaBurnReaction, ksys::act::ai::Ai)
+public:
+    explicit AirOctaBurnReaction(const InitArg& arg);
+    ~AirOctaBurnReaction() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mDisconnectTime_s{};
+    // static_param at offset 0x40
+    const float* mDisconnectRandTime_s{};
+    // static_param at offset 0x48
+    const float* mSingleBurnTime_s{};
+    // static_param at offset 0x50
+    const float* mChangeRandTime_s{};
+    // aitree_variable at offset 0x58
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaFlyUp.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/AI/aiAirOctaFlyUp.h"
+
+namespace uking::ai {
+
+AirOctaFlyUp::AirOctaFlyUp(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AirOctaFlyUp::~AirOctaFlyUp() = default;
+
+bool AirOctaFlyUp::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AirOctaFlyUp::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AirOctaFlyUp::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AirOctaFlyUp::loadParams_() {
+    getStaticParam(&mFlyUpDuration_s, "FlyUpDuration");
+    getDynamicParam(&mTargetDistance_d, "TargetDistance");
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaFlyUp.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AirOctaFlyUp : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AirOctaFlyUp, ksys::act::ai::Ai)
+public:
+    explicit AirOctaFlyUp(const InitArg& arg);
+    ~AirOctaFlyUp() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mFlyUpDuration_s{};
+    // dynamic_param at offset 0x40
+    float* mTargetDistance_d{};
+    // aitree_variable at offset 0x48
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaReaction.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAirOctaReaction.h"
+
+namespace uking::ai {
+
+AirOctaReaction::AirOctaReaction(const InitArg& arg) : EnemyDefaultReaction(arg) {}
+
+AirOctaReaction::~AirOctaReaction() = default;
+
+bool AirOctaReaction::init_(sead::Heap* heap) {
+    return EnemyDefaultReaction::init_(heap);
+}
+
+void AirOctaReaction::enter_(ksys::act::ai::InlineParamPack* params) {
+    EnemyDefaultReaction::enter_(params);
+}
+
+void AirOctaReaction::leave_() {
+    EnemyDefaultReaction::leave_();
+}
+
+void AirOctaReaction::loadParams_() {
+    EnemyDefaultReaction::loadParams_();
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaReaction.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Game/AI/AI/aiEnemyDefaultReaction.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AirOctaReaction : public EnemyDefaultReaction {
+    SEAD_RTTI_OVERRIDE(AirOctaReaction, EnemyDefaultReaction)
+public:
+    explicit AirOctaReaction(const InitArg& arg);
+    ~AirOctaReaction() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // aitree_variable at offset 0x68
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaRoot.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/AI/aiAirOctaRoot.h"
+
+namespace uking::ai {
+
+AirOctaRoot::AirOctaRoot(const InitArg& arg) : Fork2AI(arg) {}
+
+AirOctaRoot::~AirOctaRoot() = default;
+
+bool AirOctaRoot::init_(sead::Heap* heap) {
+    return Fork2AI::init_(heap);
+}
+
+void AirOctaRoot::enter_(ksys::act::ai::InlineParamPack* params) {
+    Fork2AI::enter_(params);
+}
+
+void AirOctaRoot::leave_() {
+    Fork2AI::leave_();
+}
+
+void AirOctaRoot::loadParams_() {
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaRoot.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Game/AI/AI/aiFork2AI.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AirOctaRoot : public Fork2AI {
+    SEAD_RTTI_OVERRIDE(AirOctaRoot, Fork2AI)
+public:
+    explicit AirOctaRoot(const InitArg& arg);
+    ~AirOctaRoot() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // aitree_variable at offset 0x38
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaState.cpp

@@ -0,0 +1,29 @@
+#include "Game/AI/AI/aiAirOctaState.h"
+
+namespace uking::ai {
+
+AirOctaState::AirOctaState(const InitArg& arg) : EnemyRoot(arg) {}
+
+AirOctaState::~AirOctaState() = default;
+
+bool AirOctaState::init_(sead::Heap* heap) {
+    return EnemyRoot::init_(heap);
+}
+
+void AirOctaState::enter_(ksys::act::ai::InlineParamPack* params) {
+    EnemyRoot::enter_(params);
+}
+
+void AirOctaState::leave_() {
+    EnemyRoot::leave_();
+}
+
+void AirOctaState::loadParams_() {
+    EnemyRoot::loadParams_();
+    getStaticParam(&mRopeGravityFactor_s, "RopeGravityFactor");
+    getStaticParam(&mBalloonMassRatio_s, "BalloonMassRatio");
+    getStaticParam(&mWindForceScale_s, "WindForceScale");
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaState.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "Game/AI/AI/aiEnemyRoot.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AirOctaState : public EnemyRoot {
+    SEAD_RTTI_OVERRIDE(AirOctaState, EnemyRoot)
+public:
+    explicit AirOctaState(const InitArg& arg);
+    ~AirOctaState() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x1d8
+    const float* mRopeGravityFactor_s{};
+    // static_param at offset 0x1e0
+    const float* mBalloonMassRatio_s{};
+    // static_param at offset 0x1e8
+    const float* mWindForceScale_s{};
+    // aitree_variable at offset 0x1f0
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaWait.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAirOctaWait.h"
+
+namespace uking::ai {
+
+AirOctaWait::AirOctaWait(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AirOctaWait::~AirOctaWait() = default;
+
+bool AirOctaWait::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AirOctaWait::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AirOctaWait::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AirOctaWait::loadParams_() {
+    getDynamicParam(&mIsSameChange_d, "IsSameChange");
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAirOctaWait.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AirOctaWait : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AirOctaWait, ksys::act::ai::Ai)
+public:
+    explicit AirOctaWait(const InitArg& arg);
+    ~AirOctaWait() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // dynamic_param at offset 0x38
+    bool* mIsSameChange_d{};
+    // aitree_variable at offset 0x40
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAlertCreationNestOnTree.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAlertCreationNestOnTree.h"
+
+namespace uking::ai {
+
+AlertCreationNestOnTree::AlertCreationNestOnTree(const InitArg& arg) : CreationNestOnTree(arg) {}
+
+AlertCreationNestOnTree::~AlertCreationNestOnTree() = default;
+
+bool AlertCreationNestOnTree::init_(sead::Heap* heap) {
+    return CreationNestOnTree::init_(heap);
+}
+
+void AlertCreationNestOnTree::enter_(ksys::act::ai::InlineParamPack* params) {
+    CreationNestOnTree::enter_(params);
+}
+
+void AlertCreationNestOnTree::leave_() {
+    CreationNestOnTree::leave_();
+}
+
+void AlertCreationNestOnTree::loadParams_() {
+    CreationNestOnTree::loadParams_();
+    getStaticParam(&mCreateIntervalTime_s, "CreateIntervalTime");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAlertCreationNestOnTree.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Game/AI/AI/aiCreationNestOnTree.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AlertCreationNestOnTree : public CreationNestOnTree {
+    SEAD_RTTI_OVERRIDE(AlertCreationNestOnTree, CreationNestOnTree)
+public:
+    explicit AlertCreationNestOnTree(const InitArg& arg);
+    ~AlertCreationNestOnTree() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x1f8
+    const int* mCreateIntervalTime_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAmbushableWeaponShoot.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/AI/aiAmbushableWeaponShoot.h"
+
+namespace uking::ai {
+
+AmbushableWeaponShoot::AmbushableWeaponShoot(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AmbushableWeaponShoot::~AmbushableWeaponShoot() = default;
+
+bool AmbushableWeaponShoot::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AmbushableWeaponShoot::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AmbushableWeaponShoot::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AmbushableWeaponShoot::loadParams_() {
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAmbushableWeaponShoot.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AmbushableWeaponShoot : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AmbushableWeaponShoot, ksys::act::ai::Ai)
+public:
+    explicit AmbushableWeaponShoot(const InitArg& arg);
+    ~AmbushableWeaponShoot() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // dynamic_param at offset 0x38
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnchorRangeSelectTwoAction.cpp

@@ -0,0 +1,28 @@
+#include "Game/AI/AI/aiAnchorRangeSelectTwoAction.h"
+
+namespace uking::ai {
+
+AnchorRangeSelectTwoAction::AnchorRangeSelectTwoAction(const InitArg& arg)
+    : RangeSelectTwoAction(arg) {}
+
+AnchorRangeSelectTwoAction::~AnchorRangeSelectTwoAction() = default;
+
+bool AnchorRangeSelectTwoAction::init_(sead::Heap* heap) {
+    return RangeSelectTwoAction::init_(heap);
+}
+
+void AnchorRangeSelectTwoAction::enter_(ksys::act::ai::InlineParamPack* params) {
+    RangeSelectTwoAction::enter_(params);
+}
+
+void AnchorRangeSelectTwoAction::leave_() {
+    RangeSelectTwoAction::leave_();
+}
+
+void AnchorRangeSelectTwoAction::loadParams_() {
+    RangeSelectTwoAction::loadParams_();
+    getStaticParam(&mFarDist_s, "FarDist");
+    getStaticParam(&mAnchorName_s, "AnchorName");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnchorRangeSelectTwoAction.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Game/AI/AI/aiRangeSelectTwoAction.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnchorRangeSelectTwoAction : public RangeSelectTwoAction {
+    SEAD_RTTI_OVERRIDE(AnchorRangeSelectTwoAction, RangeSelectTwoAction)
+public:
+    explicit AnchorRangeSelectTwoAction(const InitArg& arg);
+    ~AnchorRangeSelectTwoAction() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x70
+    const float* mFarDist_s{};
+    // static_param at offset 0x78
+    sead::SafeString mAnchorName_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAncientNecklaceBall.cpp

@@ -0,0 +1,28 @@
+#include "Game/AI/AI/aiAncientNecklaceBall.h"
+
+namespace uking::ai {
+
+AncientNecklaceBall::AncientNecklaceBall(const InitArg& arg) : AncientNecklaceBallBase(arg) {}
+
+AncientNecklaceBall::~AncientNecklaceBall() = default;
+
+bool AncientNecklaceBall::init_(sead::Heap* heap) {
+    return AncientNecklaceBallBase::init_(heap);
+}
+
+void AncientNecklaceBall::enter_(ksys::act::ai::InlineParamPack* params) {
+    AncientNecklaceBallBase::enter_(params);
+}
+
+void AncientNecklaceBall::leave_() {
+    AncientNecklaceBallBase::leave_();
+}
+
+void AncientNecklaceBall::loadParams_() {
+    AncientNecklaceBallBase::loadParams_();
+    getStaticParam(&mLandNoiseLevel_s, "LandNoiseLevel");
+    getMapUnitParam(&mGrabNodeIndex_m, "GrabNodeIndex");
+    getMapUnitParam(&mGiantNecklaceActiveSaveFlag_m, "GiantNecklaceActiveSaveFlag");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAncientNecklaceBall.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Game/AI/AI/aiAncientNecklaceBallBase.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AncientNecklaceBall : public AncientNecklaceBallBase {
+    SEAD_RTTI_OVERRIDE(AncientNecklaceBall, AncientNecklaceBallBase)
+public:
+    explicit AncientNecklaceBall(const InitArg& arg);
+    ~AncientNecklaceBall() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x100
+    const float* mLandNoiseLevel_s{};
+    // map_unit_param at offset 0x108
+    const int* mGrabNodeIndex_m{};
+    // map_unit_param at offset 0x110
+    sead::SafeString mGiantNecklaceActiveSaveFlag_m{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAncientNecklaceBallBase.cpp

@@ -0,0 +1,28 @@
+#include "Game/AI/AI/aiAncientNecklaceBallBase.h"
+
+namespace uking::ai {
+
+AncientNecklaceBallBase::AncientNecklaceBallBase(const InitArg& arg) : SimpleLiftable(arg) {}
+
+AncientNecklaceBallBase::~AncientNecklaceBallBase() = default;
+
+bool AncientNecklaceBallBase::init_(sead::Heap* heap) {
+    return SimpleLiftable::init_(heap);
+}
+
+void AncientNecklaceBallBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    SimpleLiftable::enter_(params);
+}
+
+void AncientNecklaceBallBase::leave_() {
+    SimpleLiftable::leave_();
+}
+
+void AncientNecklaceBallBase::loadParams_() {
+    getStaticParam(&mIsIgnoreSameOnAS_s, "IsIgnoreSameOnAS");
+    getStaticParam(&mIsIgnoreSameOffAS_s, "IsIgnoreSameOffAS");
+    getStaticParam(&mOnAS_s, "OnAS");
+    getStaticParam(&mOffAS_s, "OffAS");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAncientNecklaceBallBase.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "Game/AI/AI/aiSimpleLiftable.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AncientNecklaceBallBase : public SimpleLiftable {
+    SEAD_RTTI_OVERRIDE(AncientNecklaceBallBase, SimpleLiftable)
+public:
+    explicit AncientNecklaceBallBase(const InitArg& arg);
+    ~AncientNecklaceBallBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0xc8
+    const bool* mIsIgnoreSameOnAS_s{};
+    // static_param at offset 0xd0
+    const bool* mIsIgnoreSameOffAS_s{};
+    // static_param at offset 0xd8
+    sead::SafeString mOnAS_s{};
+    // static_param at offset 0xe8
+    sead::SafeString mOffAS_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalAttackOtherTarget.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/AI/aiAnimalAttackOtherTarget.h"
+
+namespace uking::ai {
+
+AnimalAttackOtherTarget::AnimalAttackOtherTarget(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AnimalAttackOtherTarget::~AnimalAttackOtherTarget() = default;
+
+bool AnimalAttackOtherTarget::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalAttackOtherTarget::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalAttackOtherTarget::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalAttackOtherTarget::loadParams_() {}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalAttackOtherTarget.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalAttackOtherTarget : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalAttackOtherTarget, ksys::act::ai::Ai)
+public:
+    explicit AnimalAttackOtherTarget(const InitArg& arg);
+    ~AnimalAttackOtherTarget() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalBattleAggressive.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/AI/aiAnimalBattleAggressive.h"
+
+namespace uking::ai {
+
+AnimalBattleAggressive::AnimalBattleAggressive(const InitArg& arg) : EnemyBattle(arg) {}
+
+AnimalBattleAggressive::~AnimalBattleAggressive() = default;
+
+bool AnimalBattleAggressive::init_(sead::Heap* heap) {
+    return EnemyBattle::init_(heap);
+}
+
+void AnimalBattleAggressive::enter_(ksys::act::ai::InlineParamPack* params) {
+    EnemyBattle::enter_(params);
+}
+
+void AnimalBattleAggressive::leave_() {
+    EnemyBattle::leave_();
+}
+
+void AnimalBattleAggressive::loadParams_() {
+    EnemyBattle::loadParams_();
+    getStaticParam(&mForceAttackTimer_s, "ForceAttackTimer");
+    getStaticParam(&mCounterAttackTimer_s, "CounterAttackTimer");
+    getStaticParam(&mForceAttackRange_s, "ForceAttackRange");
+    getStaticParam(&mCounterAttackRange_s, "CounterAttackRange");
+    getAITreeVariable(&mAnimalEnableCounterFlag_a, "AnimalEnableCounterFlag");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalBattleAggressive.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Game/AI/AI/aiEnemyBattle.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalBattleAggressive : public EnemyBattle {
+    SEAD_RTTI_OVERRIDE(AnimalBattleAggressive, EnemyBattle)
+public:
+    explicit AnimalBattleAggressive(const InitArg& arg);
+    ~AnimalBattleAggressive() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x90
+    const int* mForceAttackTimer_s{};
+    // static_param at offset 0x98
+    const int* mCounterAttackTimer_s{};
+    // static_param at offset 0xa0
+    const float* mForceAttackRange_s{};
+    // static_param at offset 0xa8
+    const float* mCounterAttackRange_s{};
+    // aitree_variable at offset 0xb0
+    bool* mAnimalEnableCounterFlag_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalBattleMoveLeave.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAnimalBattleMoveLeave.h"
+
+namespace uking::ai {
+
+AnimalBattleMoveLeave::AnimalBattleMoveLeave(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AnimalBattleMoveLeave::~AnimalBattleMoveLeave() = default;
+
+bool AnimalBattleMoveLeave::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalBattleMoveLeave::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalBattleMoveLeave::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalBattleMoveLeave::loadParams_() {
+    getStaticParam(&mCheckForwardDist_s, "CheckForwardDist");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalBattleMoveLeave.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalBattleMoveLeave : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalBattleMoveLeave, ksys::act::ai::Ai)
+public:
+    explicit AnimalBattleMoveLeave(const InitArg& arg);
+    ~AnimalBattleMoveLeave() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mCheckForwardDist_s{};
+    // dynamic_param at offset 0x40
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalEscapeAI.cpp

@@ -0,0 +1,37 @@
+#include "Game/AI/AI/aiAnimalEscapeAI.h"
+
+namespace uking::ai {
+
+AnimalEscapeAI::AnimalEscapeAI(const InitArg& arg) : AnimalRoamBase(arg) {}
+
+AnimalEscapeAI::~AnimalEscapeAI() = default;
+
+bool AnimalEscapeAI::init_(sead::Heap* heap) {
+    return AnimalRoamBase::init_(heap);
+}
+
+void AnimalEscapeAI::enter_(ksys::act::ai::InlineParamPack* params) {
+    AnimalRoamBase::enter_(params);
+}
+
+void AnimalEscapeAI::leave_() {
+    AnimalRoamBase::leave_();
+}
+
+void AnimalEscapeAI::loadParams_() {
+    AnimalRoamBase::loadParams_();
+    getStaticParam(&mNumTimesAllowStuck_s, "NumTimesAllowStuck");
+    getStaticParam(&mContinueDistance_s, "ContinueDistance");
+    getStaticParam(&mShouldEscapeDistance_s, "ShouldEscapeDistance");
+    getStaticParam(&mShouldEscapeDistanceRand_s, "ShouldEscapeDistanceRand");
+    getStaticParam(&mPenaltyScale_s, "PenaltyScale");
+    getStaticParam(&mNavMeshRadiusScale_s, "NavMeshRadiusScale");
+    getStaticParam(&mFramesStuckOnTerrainAction_s, "FramesStuckOnTerrainAction");
+    getStaticParam(&mIsSendGoalPos_s, "IsSendGoalPos");
+    getStaticParam(&mIsUseBeforeAction_s, "IsUseBeforeAction");
+    getStaticParam(&mIsDynamicallyOffsetNavChar_s, "IsDynamicallyOffsetNavChar");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+    getAITreeVariable(&mIsUseTerritory_a, "IsUseTerritory");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalEscapeAI.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "Game/AI/AI/aiAnimalRoamBase.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalEscapeAI : public AnimalRoamBase {
+    SEAD_RTTI_OVERRIDE(AnimalEscapeAI, AnimalRoamBase)
+public:
+    explicit AnimalEscapeAI(const InitArg& arg);
+    ~AnimalEscapeAI() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0xa8
+    const int* mNumTimesAllowStuck_s{};
+    // static_param at offset 0xb0
+    const float* mContinueDistance_s{};
+    // static_param at offset 0xb8
+    const float* mShouldEscapeDistance_s{};
+    // static_param at offset 0xc0
+    const float* mShouldEscapeDistanceRand_s{};
+    // static_param at offset 0xc8
+    const float* mPenaltyScale_s{};
+    // static_param at offset 0xd0
+    const float* mNavMeshRadiusScale_s{};
+    // static_param at offset 0xd8
+    const float* mFramesStuckOnTerrainAction_s{};
+    // static_param at offset 0xe0
+    const bool* mIsSendGoalPos_s{};
+    // static_param at offset 0xe8
+    const bool* mIsUseBeforeAction_s{};
+    // static_param at offset 0xf0
+    const bool* mIsDynamicallyOffsetNavChar_s{};
+    // dynamic_param at offset 0xf8
+    sead::Vector3f* mTargetPos_d{};
+    // aitree_variable at offset 0x100
+    bool* mIsUseTerritory_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalEscapeAfterDamage.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/AI/aiAnimalEscapeAfterDamage.h"
+
+namespace uking::ai {
+
+AnimalEscapeAfterDamage::AnimalEscapeAfterDamage(const InitArg& arg) : AnimalEscapeAI(arg) {}
+
+AnimalEscapeAfterDamage::~AnimalEscapeAfterDamage() = default;
+
+bool AnimalEscapeAfterDamage::init_(sead::Heap* heap) {
+    return AnimalEscapeAI::init_(heap);
+}
+
+void AnimalEscapeAfterDamage::enter_(ksys::act::ai::InlineParamPack* params) {
+    AnimalEscapeAI::enter_(params);
+}
+
+void AnimalEscapeAfterDamage::leave_() {
+    AnimalEscapeAI::leave_();
+}
+
+void AnimalEscapeAfterDamage::loadParams_() {
+    AnimalEscapeAI::loadParams_();
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalEscapeAfterDamage.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Game/AI/AI/aiAnimalEscapeAI.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalEscapeAfterDamage : public AnimalEscapeAI {
+    SEAD_RTTI_OVERRIDE(AnimalEscapeAfterDamage, AnimalEscapeAI)
+public:
+    explicit AnimalEscapeAfterDamage(const InitArg& arg);
+    ~AnimalEscapeAfterDamage() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalFollowTarget.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAnimalFollowTarget.h"
+
+namespace uking::ai {
+
+AnimalFollowTarget::AnimalFollowTarget(const InitArg& arg) : HorseFollow(arg) {}
+
+AnimalFollowTarget::~AnimalFollowTarget() = default;
+
+bool AnimalFollowTarget::init_(sead::Heap* heap) {
+    return HorseFollow::init_(heap);
+}
+
+void AnimalFollowTarget::enter_(ksys::act::ai::InlineParamPack* params) {
+    HorseFollow::enter_(params);
+}
+
+void AnimalFollowTarget::leave_() {
+    HorseFollow::leave_();
+}
+
+void AnimalFollowTarget::loadParams_() {
+    HorseFollow::loadParams_();
+    getStaticParam(&mUseLocalOffsetType_s, "UseLocalOffsetType");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalFollowTarget.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Game/AI/AI/aiHorseFollow.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalFollowTarget : public HorseFollow {
+    SEAD_RTTI_OVERRIDE(AnimalFollowTarget, HorseFollow)
+public:
+    explicit AnimalFollowTarget(const InitArg& arg);
+    ~AnimalFollowTarget() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0xe0
+    const int* mUseLocalOffsetType_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalLineOfSightSelector.cpp

@@ -0,0 +1,29 @@
+#include "Game/AI/AI/aiAnimalLineOfSightSelector.h"
+
+namespace uking::ai {
+
+AnimalLineOfSightSelector::AnimalLineOfSightSelector(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AnimalLineOfSightSelector::~AnimalLineOfSightSelector() = default;
+
+bool AnimalLineOfSightSelector::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalLineOfSightSelector::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalLineOfSightSelector::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalLineOfSightSelector::loadParams_() {
+    getStaticParam(&mStartGear_s, "StartGear");
+    getStaticParam(&mMinGear_s, "MinGear");
+    getStaticParam(&mMaxGear_s, "MaxGear");
+    getStaticParam(&mGearUpRestrictionFrames_s, "GearUpRestrictionFrames");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalLineOfSightSelector.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalLineOfSightSelector : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalLineOfSightSelector, ksys::act::ai::Ai)
+public:
+    explicit AnimalLineOfSightSelector(const InitArg& arg);
+    ~AnimalLineOfSightSelector() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const int* mStartGear_s{};
+    // static_param at offset 0x40
+    const int* mMinGear_s{};
+    // static_param at offset 0x48
+    const int* mMaxGear_s{};
+    // static_param at offset 0x50
+    const float* mGearUpRestrictionFrames_s{};
+    // dynamic_param at offset 0x58
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalPreAttack.cpp

@@ -0,0 +1,28 @@
+#include "Game/AI/AI/aiAnimalPreAttack.h"
+
+namespace uking::ai {
+
+AnimalPreAttack::AnimalPreAttack(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AnimalPreAttack::~AnimalPreAttack() = default;
+
+bool AnimalPreAttack::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalPreAttack::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalPreAttack::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalPreAttack::loadParams_() {
+    getStaticParam(&mForceEndTime_s, "ForceEndTime");
+    getStaticParam(&mKeepDistCheckLength_s, "KeepDistCheckLength");
+    getStaticParam(&mBackCliffCheckLength_s, "BackCliffCheckLength");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalPreAttack.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalPreAttack : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalPreAttack, ksys::act::ai::Ai)
+public:
+    explicit AnimalPreAttack(const InitArg& arg);
+    ~AnimalPreAttack() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const int* mForceEndTime_s{};
+    // static_param at offset 0x40
+    const float* mKeepDistCheckLength_s{};
+    // static_param at offset 0x48
+    const float* mBackCliffCheckLength_s{};
+    // dynamic_param at offset 0x50
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRangeKeepMove.cpp

@@ -0,0 +1,31 @@
+#include "Game/AI/AI/aiAnimalRangeKeepMove.h"
+
+namespace uking::ai {
+
+AnimalRangeKeepMove::AnimalRangeKeepMove(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AnimalRangeKeepMove::~AnimalRangeKeepMove() = default;
+
+bool AnimalRangeKeepMove::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalRangeKeepMove::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalRangeKeepMove::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalRangeKeepMove::loadParams_() {
+    getStaticParam(&mBattleEndTimerMin_s, "BattleEndTimerMin");
+    getStaticParam(&mBattleEndTimerMax_s, "BattleEndTimerMax");
+    getStaticParam(&mCloseStartDist_s, "CloseStartDist");
+    getStaticParam(&mCloseEndDist_s, "CloseEndDist");
+    getStaticParam(&mLeaveStartDist_s, "LeaveStartDist");
+    getStaticParam(&mLeaveEndDist_s, "LeaveEndDist");
+    getStaticParam(&mBattleEndDist_s, "BattleEndDist");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRangeKeepMove.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalRangeKeepMove : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalRangeKeepMove, ksys::act::ai::Ai)
+public:
+    explicit AnimalRangeKeepMove(const InitArg& arg);
+    ~AnimalRangeKeepMove() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const int* mBattleEndTimerMin_s{};
+    // static_param at offset 0x40
+    const int* mBattleEndTimerMax_s{};
+    // static_param at offset 0x48
+    const float* mCloseStartDist_s{};
+    // static_param at offset 0x50
+    const float* mCloseEndDist_s{};
+    // static_param at offset 0x58
+    const float* mLeaveStartDist_s{};
+    // static_param at offset 0x60
+    const float* mLeaveEndDist_s{};
+    // static_param at offset 0x68
+    const float* mBattleEndDist_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRangeKeepMoveWithLOS.cpp

@@ -0,0 +1,33 @@
+#include "Game/AI/AI/aiAnimalRangeKeepMoveWithLOS.h"
+
+namespace uking::ai {
+
+AnimalRangeKeepMoveWithLOS::AnimalRangeKeepMoveWithLOS(const InitArg& arg)
+    : ksys::act::ai::Ai(arg) {}
+
+AnimalRangeKeepMoveWithLOS::~AnimalRangeKeepMoveWithLOS() = default;
+
+bool AnimalRangeKeepMoveWithLOS::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalRangeKeepMoveWithLOS::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalRangeKeepMoveWithLOS::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalRangeKeepMoveWithLOS::loadParams_() {
+    getStaticParam(&mFindPathBeginTimer_s, "FindPathBeginTimer");
+    getStaticParam(&mNoPathTimer_s, "NoPathTimer");
+    getStaticParam(&mCloseStartDist_s, "CloseStartDist");
+    getStaticParam(&mCloseEndDist_s, "CloseEndDist");
+    getStaticParam(&mLeaveStartDist_s, "LeaveStartDist");
+    getStaticParam(&mLeaveEndDist_s, "LeaveEndDist");
+    getStaticParam(&mBattleEndDist_s, "BattleEndDist");
+    getStaticParam(&mDistFailOnUnreachablePath_s, "DistFailOnUnreachablePath");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRangeKeepMoveWithLOS.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalRangeKeepMoveWithLOS : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalRangeKeepMoveWithLOS, ksys::act::ai::Ai)
+public:
+    explicit AnimalRangeKeepMoveWithLOS(const InitArg& arg);
+    ~AnimalRangeKeepMoveWithLOS() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const int* mFindPathBeginTimer_s{};
+    // static_param at offset 0x40
+    const int* mNoPathTimer_s{};
+    // static_param at offset 0x48
+    const float* mCloseStartDist_s{};
+    // static_param at offset 0x50
+    const float* mCloseEndDist_s{};
+    // static_param at offset 0x58
+    const float* mLeaveStartDist_s{};
+    // static_param at offset 0x60
+    const float* mLeaveEndDist_s{};
+    // static_param at offset 0x68
+    const float* mBattleEndDist_s{};
+    // static_param at offset 0x70
+    const float* mDistFailOnUnreachablePath_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRoam.cpp

@@ -0,0 +1,32 @@
+#include "Game/AI/AI/aiAnimalRoam.h"
+
+namespace uking::ai {
+
+AnimalRoam::AnimalRoam(const InitArg& arg) : AnimalRoamBase(arg) {}
+
+AnimalRoam::~AnimalRoam() = default;
+
+bool AnimalRoam::init_(sead::Heap* heap) {
+    return AnimalRoamBase::init_(heap);
+}
+
+void AnimalRoam::enter_(ksys::act::ai::InlineParamPack* params) {
+    AnimalRoamBase::enter_(params);
+}
+
+void AnimalRoam::leave_() {
+    AnimalRoamBase::leave_();
+}
+
+void AnimalRoam::loadParams_() {
+    AnimalRoamBase::loadParams_();
+    getStaticParam(&mFinishChangeCount_s, "FinishChangeCount");
+    getStaticParam(&mLimitRadius_s, "LimitRadius");
+    getStaticParam(&mChangeWaitRate_s, "ChangeWaitRate");
+    getStaticParam(&mFramesStuckOnTerrainAction_s, "FramesStuckOnTerrainAction");
+    getStaticParam(&mIsSendGoalPos_s, "IsSendGoalPos");
+    getStaticParam(&mCheckValidStartPos_s, "CheckValidStartPos");
+    getStaticParam(&mCheckLOS_s, "CheckLOS");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRoam.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "Game/AI/AI/aiAnimalRoamBase.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalRoam : public AnimalRoamBase {
+    SEAD_RTTI_OVERRIDE(AnimalRoam, AnimalRoamBase)
+public:
+    explicit AnimalRoam(const InitArg& arg);
+    ~AnimalRoam() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0xa8
+    const int* mFinishChangeCount_s{};
+    // static_param at offset 0xb0
+    const float* mLimitRadius_s{};
+    // static_param at offset 0xb8
+    const float* mChangeWaitRate_s{};
+    // static_param at offset 0xc0
+    const float* mFramesStuckOnTerrainAction_s{};
+    // static_param at offset 0xc8
+    const bool* mIsSendGoalPos_s{};
+    // static_param at offset 0xd0
+    const bool* mCheckValidStartPos_s{};
+    // static_param at offset 0xd8
+    const bool* mCheckLOS_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRoamBase.cpp

@@ -0,0 +1,37 @@
+#include "Game/AI/AI/aiAnimalRoamBase.h"
+
+namespace uking::ai {
+
+AnimalRoamBase::AnimalRoamBase(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AnimalRoamBase::~AnimalRoamBase() = default;
+
+bool AnimalRoamBase::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalRoamBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalRoamBase::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalRoamBase::loadParams_() {
+    getStaticParam(&mSearchNextPathRadius_s, "SearchNextPathRadius");
+    getStaticParam(&mRadiusLimit_s, "RadiusLimit");
+    getStaticParam(&mForwardDirDistCoefficient_s, "ForwardDirDistCoefficient");
+    getStaticParam(&mDirRandomMinRatio_s, "DirRandomMinRatio");
+    getStaticParam(&mDirRangeAngle_s, "DirRangeAngle");
+    getStaticParam(&mRejectDistRatio_s, "RejectDistRatio");
+    getStaticParam(&mContinueAddSearchAngle_s, "ContinueAddSearchAngle");
+    getStaticParam(&mContinueReduceDistRatio_s, "ContinueReduceDistRatio");
+    getStaticParam(&mContinueReduceRejectDistRatio_s, "ContinueReduceRejectDistRatio");
+    getMapUnitParam(&mTerritoryArea_m, "TerritoryArea");
+    getMapUnitParam(&mEnableNoEntryAreaCheck_m, "EnableNoEntryAreaCheck");
+    getAITreeVariable(&mFramesStuckOnTerrain_a, "FramesStuckOnTerrain");
+    getAITreeVariable(&mIsStuckOnTerrain_a, "IsStuckOnTerrain");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRoamBase.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalRoamBase : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalRoamBase, ksys::act::ai::Ai)
+public:
+    explicit AnimalRoamBase(const InitArg& arg);
+    ~AnimalRoamBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mSearchNextPathRadius_s{};
+    // static_param at offset 0x40
+    const float* mRadiusLimit_s{};
+    // static_param at offset 0x48
+    const float* mForwardDirDistCoefficient_s{};
+    // static_param at offset 0x50
+    const float* mDirRandomMinRatio_s{};
+    // static_param at offset 0x58
+    const float* mDirRangeAngle_s{};
+    // static_param at offset 0x60
+    const float* mRejectDistRatio_s{};
+    // static_param at offset 0x68
+    const float* mContinueAddSearchAngle_s{};
+    // static_param at offset 0x70
+    const float* mContinueReduceDistRatio_s{};
+    // static_param at offset 0x78
+    const float* mContinueReduceRejectDistRatio_s{};
+    // map_unit_param at offset 0x80
+    const float* mTerritoryArea_m{};
+    // map_unit_param at offset 0x88
+    const bool* mEnableNoEntryAreaCheck_m{};
+    // aitree_variable at offset 0x90
+    float* mFramesStuckOnTerrain_a{};
+    // aitree_variable at offset 0x98
+    bool* mIsStuckOnTerrain_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRoamCheckWater.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/AI/aiAnimalRoamCheckWater.h"
+
+namespace uking::ai {
+
+AnimalRoamCheckWater::AnimalRoamCheckWater(const InitArg& arg) : AnimalRoam(arg) {}
+
+AnimalRoamCheckWater::~AnimalRoamCheckWater() = default;
+
+bool AnimalRoamCheckWater::init_(sead::Heap* heap) {
+    return AnimalRoam::init_(heap);
+}
+
+void AnimalRoamCheckWater::enter_(ksys::act::ai::InlineParamPack* params) {
+    AnimalRoam::enter_(params);
+}
+
+void AnimalRoamCheckWater::leave_() {
+    AnimalRoam::leave_();
+}
+
+void AnimalRoamCheckWater::loadParams_() {
+    AnimalRoam::loadParams_();
+    getStaticParam(&mWaterLevelLimitLower_s, "WaterLevelLimitLower");
+    getStaticParam(&mWaterLevelLimitUpper_s, "WaterLevelLimitUpper");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRoamCheckWater.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Game/AI/AI/aiAnimalRoam.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalRoamCheckWater : public AnimalRoam {
+    SEAD_RTTI_OVERRIDE(AnimalRoamCheckWater, AnimalRoam)
+public:
+    explicit AnimalRoamCheckWater(const InitArg& arg);
+    ~AnimalRoamCheckWater() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0xf8
+    const float* mWaterLevelLimitLower_s{};
+    // static_param at offset 0x100
+    const float* mWaterLevelLimitUpper_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRushAttack.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/AI/aiAnimalRushAttack.h"
+
+namespace uking::ai {
+
+AnimalRushAttack::AnimalRushAttack(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AnimalRushAttack::~AnimalRushAttack() = default;
+
+bool AnimalRushAttack::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AnimalRushAttack::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AnimalRushAttack::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AnimalRushAttack::loadParams_() {
+    getStaticParam(&mUpdateTargetPosTime_s, "UpdateTargetPosTime");
+    getStaticParam(&mAttackPosOffsetLength_s, "AttackPosOffsetLength");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalRushAttack.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalRushAttack : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AnimalRushAttack, ksys::act::ai::Ai)
+public:
+    explicit AnimalRushAttack(const InitArg& arg);
+    ~AnimalRushAttack() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const int* mUpdateTargetPosTime_s{};
+    // static_param at offset 0x40
+    const float* mAttackPosOffsetLength_s{};
+    // dynamic_param at offset 0x48
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalTimelineAI.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAnimalTimelineAI.h"
+
+namespace uking::ai {
+
+AnimalTimelineAI::AnimalTimelineAI(const InitArg& arg) : TimelineAI(arg) {}
+
+AnimalTimelineAI::~AnimalTimelineAI() = default;
+
+bool AnimalTimelineAI::init_(sead::Heap* heap) {
+    return TimelineAI::init_(heap);
+}
+
+void AnimalTimelineAI::enter_(ksys::act::ai::InlineParamPack* params) {
+    TimelineAI::enter_(params);
+}
+
+void AnimalTimelineAI::leave_() {
+    TimelineAI::leave_();
+}
+
+void AnimalTimelineAI::loadParams_() {
+    TimelineAI::loadParams_();
+    getAITreeVariable(&mDomesticAnimalRailName_a, "DomesticAnimalRailName");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAnimalTimelineAI.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Game/AI/AI/aiTimelineAI.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AnimalTimelineAI : public TimelineAI {
+    SEAD_RTTI_OVERRIDE(AnimalTimelineAI, TimelineAI)
+public:
+    explicit AnimalTimelineAI(const InitArg& arg);
+    ~AnimalTimelineAI() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // aitree_variable at offset 0x40
+    sead::SafeString* mDomesticAnimalRailName_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearFromTargetFrontAfterChase.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/AI/aiAppearFromTargetFrontAfterChase.h"
+
+namespace uking::ai {
+
+AppearFromTargetFrontAfterChase::AppearFromTargetFrontAfterChase(const InitArg& arg)
+    : AppearNearTarget(arg) {}
+
+AppearFromTargetFrontAfterChase::~AppearFromTargetFrontAfterChase() = default;
+
+void AppearFromTargetFrontAfterChase::enter_(ksys::act::ai::InlineParamPack* params) {
+    AppearNearTarget::enter_(params);
+}
+
+void AppearFromTargetFrontAfterChase::leave_() {
+    AppearNearTarget::leave_();
+}
+
+void AppearFromTargetFrontAfterChase::loadParams_() {
+    AppearNearTarget::loadParams_();
+    getStaticParam(&mAppearDist_s, "AppearDist");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearFromTargetFrontAfterChase.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Game/AI/AI/aiAppearNearTarget.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AppearFromTargetFrontAfterChase : public AppearNearTarget {
+    SEAD_RTTI_OVERRIDE(AppearFromTargetFrontAfterChase, AppearNearTarget)
+public:
+    explicit AppearFromTargetFrontAfterChase(const InitArg& arg);
+    ~AppearFromTargetFrontAfterChase() override;
+
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x90
+    const float* mAppearDist_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearFromTargetFrontGround.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAppearFromTargetFrontGround.h"
+
+namespace uking::ai {
+
+AppearFromTargetFrontGround::AppearFromTargetFrontGround(const InitArg& arg)
+    : AppearNearTarget(arg) {}
+
+AppearFromTargetFrontGround::~AppearFromTargetFrontGround() = default;
+
+bool AppearFromTargetFrontGround::init_(sead::Heap* heap) {
+    return AppearNearTarget::init_(heap);
+}
+
+void AppearFromTargetFrontGround::enter_(ksys::act::ai::InlineParamPack* params) {
+    AppearNearTarget::enter_(params);
+}
+
+void AppearFromTargetFrontGround::leave_() {
+    AppearNearTarget::leave_();
+}
+
+void AppearFromTargetFrontGround::loadParams_() {
+    AppearNearTarget::loadParams_();
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearFromTargetFrontGround.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Game/AI/AI/aiAppearNearTarget.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AppearFromTargetFrontGround : public AppearNearTarget {
+    SEAD_RTTI_OVERRIDE(AppearFromTargetFrontGround, AppearNearTarget)
+public:
+    explicit AppearFromTargetFrontGround(const InitArg& arg);
+    ~AppearFromTargetFrontGround() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearNearTarget.cpp

@@ -0,0 +1,28 @@
+#include "Game/AI/AI/aiAppearNearTarget.h"
+
+namespace uking::ai {
+
+AppearNearTarget::AppearNearTarget(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AppearNearTarget::~AppearNearTarget() = default;
+
+bool AppearNearTarget::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void AppearNearTarget::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AppearNearTarget::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AppearNearTarget::loadParams_() {
+    getStaticParam(&mDist_s, "Dist");
+    getStaticParam(&mTeraDist_s, "TeraDist");
+    getMapUnitParam(&mNearCreateAppearID_m, "NearCreateAppearID");
+    getAITreeVariable(&mIsStopFallCheck_a, "IsStopFallCheck");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearNearTarget.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AppearNearTarget : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AppearNearTarget, ksys::act::ai::Ai)
+public:
+    explicit AppearNearTarget(const InitArg& arg);
+    ~AppearNearTarget() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mDist_s{};
+    // static_param at offset 0x40
+    const float* mTeraDist_s{};
+    // map_unit_param at offset 0x48
+    const int* mNearCreateAppearID_m{};
+    // aitree_variable at offset 0x50
+    bool* mIsStopFallCheck_a{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearNearTargetOutOfScrnGnd.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiAppearNearTargetOutOfScrnGnd.h"
+
+namespace uking::ai {
+
+AppearNearTargetOutOfScrnGnd::AppearNearTargetOutOfScrnGnd(const InitArg& arg)
+    : AppearNearTarget(arg) {}
+
+AppearNearTargetOutOfScrnGnd::~AppearNearTargetOutOfScrnGnd() = default;
+
+bool AppearNearTargetOutOfScrnGnd::init_(sead::Heap* heap) {
+    return AppearNearTarget::init_(heap);
+}
+
+void AppearNearTargetOutOfScrnGnd::enter_(ksys::act::ai::InlineParamPack* params) {
+    AppearNearTarget::enter_(params);
+}
+
+void AppearNearTargetOutOfScrnGnd::leave_() {
+    AppearNearTarget::leave_();
+}
+
+void AppearNearTargetOutOfScrnGnd::loadParams_() {
+    AppearNearTarget::loadParams_();
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAppearNearTargetOutOfScrnGnd.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Game/AI/AI/aiAppearNearTarget.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AppearNearTargetOutOfScrnGnd : public AppearNearTarget {
+    SEAD_RTTI_OVERRIDE(AppearNearTargetOutOfScrnGnd, AppearNearTarget)
+public:
+    explicit AppearNearTargetOutOfScrnGnd(const InitArg& arg);
+    ~AppearNearTargetOutOfScrnGnd() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArmorSearchKorokRoot.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiArmorSearchKorokRoot.h"
+
+namespace uking::ai {
+
+ArmorSearchKorokRoot::ArmorSearchKorokRoot(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+ArmorSearchKorokRoot::~ArmorSearchKorokRoot() = default;
+
+bool ArmorSearchKorokRoot::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void ArmorSearchKorokRoot::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void ArmorSearchKorokRoot::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void ArmorSearchKorokRoot::loadParams_() {
+    getStaticParam(&mSearchKorokDis_s, "SearchKorokDis");
+    getStaticParam(&mSearchRefreshFrame_s, "SearchRefreshFrame");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArmorSearchKorokRoot.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class ArmorSearchKorokRoot : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(ArmorSearchKorokRoot, ksys::act::ai::Ai)
+public:
+    explicit ArmorSearchKorokRoot(const InitArg& arg);
+    ~ArmorSearchKorokRoot() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mSearchKorokDis_s{};
+    // static_param at offset 0x40
+    const float* mSearchRefreshFrame_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAroundEnemyCheckSelect.cpp

@@ -0,0 +1,21 @@
+#include "Game/AI/AI/aiAroundEnemyCheckSelect.h"
+
+namespace uking::ai {
+
+AroundEnemyCheckSelect::AroundEnemyCheckSelect(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+AroundEnemyCheckSelect::~AroundEnemyCheckSelect() = default;
+
+void AroundEnemyCheckSelect::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void AroundEnemyCheckSelect::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void AroundEnemyCheckSelect::loadParams_() {
+    getStaticParam(&mCheckDist_s, "CheckDist");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiAroundEnemyCheckSelect.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class AroundEnemyCheckSelect : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(AroundEnemyCheckSelect, ksys::act::ai::Ai)
+public:
+    explicit AroundEnemyCheckSelect(const InitArg& arg);
+    ~AroundEnemyCheckSelect() override;
+
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x38
+    const float* mCheckDist_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrow.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/AI/aiArrow.h"
+
+namespace uking::ai {
+
+Arrow::Arrow(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+Arrow::~Arrow() = default;
+
+bool Arrow::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void Arrow::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void Arrow::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void Arrow::loadParams_() {}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrow.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class Arrow : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(Arrow, ksys::act::ai::Ai)
+public:
+    explicit Arrow(const InitArg& arg);
+    ~Arrow() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrowChargeAndShoot.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/AI/aiArrowChargeAndShoot.h"
+
+namespace uking::ai {
+
+ArrowChargeAndShoot::ArrowChargeAndShoot(const InitArg& arg) : SeqTwoAction(arg) {}
+
+ArrowChargeAndShoot::~ArrowChargeAndShoot() = default;
+
+bool ArrowChargeAndShoot::init_(sead::Heap* heap) {
+    return SeqTwoAction::init_(heap);
+}
+
+void ArrowChargeAndShoot::enter_(ksys::act::ai::InlineParamPack* params) {
+    SeqTwoAction::enter_(params);
+}
+
+void ArrowChargeAndShoot::leave_() {
+    SeqTwoAction::leave_();
+}
+
+void ArrowChargeAndShoot::loadParams_() {
+    SeqTwoAction::loadParams_();
+    getStaticParam(&mWeaponIdx_s, "WeaponIdx");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrowChargeAndShoot.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Game/AI/AI/aiSeqTwoAction.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class ArrowChargeAndShoot : public SeqTwoAction {
+    SEAD_RTTI_OVERRIDE(ArrowChargeAndShoot, SeqTwoAction)
+public:
+    explicit ArrowChargeAndShoot(const InitArg& arg);
+    ~ArrowChargeAndShoot() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    // static_param at offset 0x50
+    const int* mWeaponIdx_s{};
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrowDelete.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/AI/aiArrowDelete.h"
+
+namespace uking::ai {
+
+ArrowDelete::ArrowDelete(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
+
+ArrowDelete::~ArrowDelete() = default;
+
+bool ArrowDelete::init_(sead::Heap* heap) {
+    return ksys::act::ai::Ai::init_(heap);
+}
+
+void ArrowDelete::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Ai::enter_(params);
+}
+
+void ArrowDelete::leave_() {
+    ksys::act::ai::Ai::leave_();
+}
+
+void ArrowDelete::loadParams_() {}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrowDelete.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class ArrowDelete : public ksys::act::ai::Ai {
+    SEAD_RTTI_OVERRIDE(ArrowDelete, ksys::act::ai::Ai)
+public:
+    explicit ArrowDelete(const InitArg& arg);
+    ~ArrowDelete() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+};
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrowStickAndPick.cpp

@@ -0,0 +1,21 @@
+#include "Game/AI/AI/aiArrowStickAndPick.h"
+
+namespace uking::ai {
+
+ArrowStickAndPick::ArrowStickAndPick(const InitArg& arg) : CommonPickedItem(arg) {}
+
+ArrowStickAndPick::~ArrowStickAndPick() = default;
+
+void ArrowStickAndPick::enter_(ksys::act::ai::InlineParamPack* params) {
+    CommonPickedItem::enter_(params);
+}
+
+void ArrowStickAndPick::loadParams_() {
+    CommonPickedItem::loadParams_();
+    getDynamicParam(&mStickPos_d, "StickPos");
+    getDynamicParam(&mStickPosDiv_d, "StickPosDiv");
+    getDynamicParam(&mStickActor_d, "StickActor");
+    getDynamicParam(&mStickBodyName_d, "StickBodyName");
+}
+
+}  // namespace uking::ai

src/Game/AI/AI/aiArrowStickAndPick.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Game/AI/AI/aiCommonPickedItem.h"
+#include "KingSystem/ActorSystem/actAiAi.h"
+
+namespace uking::ai {
+
+class ArrowStickAndPick : public CommonPickedItem {
+    SEAD_RTTI_OVERRIDE(ArrowStickAndPick, CommonPickedItem)
+public:
+    explicit ArrowStickAndPick(const InitArg& arg);
+    ~ArrowStickAndPick() override;
+
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void loadParams_() override;
+
+protected:
+    // dynamic_param at offset 0xe8
+    sead::Vector3f* mStickPos_d{};
+    // dynamic_param at offset 0xf0
+    sead::Vector3f* mStickPosDiv_d{};
+    // dynamic_param at offset 0xf8
+    ksys::act::BaseProcLink* mStickActor_d{};
+    // dynamic_param at offset 0x100
+    sead::SafeString* mStickBodyName_d{};
+};
+
+}  // namespace uking::ai