Generate actions

src/Game/AI/Action/actionASPlaySimpleAnmDriven.cpp

@@ -0,0 +1,32 @@
+#include "Game/AI/Action/actionASPlaySimpleAnmDriven.h"
+
+namespace uking::action {
+
+ASPlaySimpleAnmDriven::ASPlaySimpleAnmDriven(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+ASPlaySimpleAnmDriven::~ASPlaySimpleAnmDriven() = default;
+
+bool ASPlaySimpleAnmDriven::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void ASPlaySimpleAnmDriven::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void ASPlaySimpleAnmDriven::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void ASPlaySimpleAnmDriven::loadParams_() {
+    getStaticParam(&mIsIgnoreSame_s, "IsIgnoreSame");
+    getStaticParam(&mIsChangeable_s, "IsChangeable");
+    getStaticParam(&mResetTransBoneOnLeave_s, "ResetTransBoneOnLeave");
+    getStaticParam(&mASName_s, "ASName");
+}
+
+void ASPlaySimpleAnmDriven::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionASPlaySimpleAnmDriven.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ASPlaySimpleAnmDriven : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(ASPlaySimpleAnmDriven, ksys::act::ai::Action)
+public:
+    explicit ASPlaySimpleAnmDriven(const InitArg& arg);
+    ~ASPlaySimpleAnmDriven() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const bool* mIsIgnoreSame_s{};
+    // static_param at offset 0x28
+    const bool* mIsChangeable_s{};
+    // static_param at offset 0x30
+    const bool* mResetTransBoneOnLeave_s{};
+    // static_param at offset 0x38
+    sead::SafeString mASName_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionActionEx.cpp

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

src/Game/AI/Action/actionActionEx.h

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

src/Game/AI/Action/actionActionWithAS.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/Action/actionActionWithAS.h"
+
+namespace uking::action {
+
+ActionWithAS::ActionWithAS(const InitArg& arg) : ActionWithPosAngReduce(arg) {}
+
+ActionWithAS::~ActionWithAS() = default;
+
+bool ActionWithAS::init_(sead::Heap* heap) {
+    return ActionWithPosAngReduce::init_(heap);
+}
+
+void ActionWithAS::enter_(ksys::act::ai::InlineParamPack* params) {
+    ActionWithPosAngReduce::enter_(params);
+}
+
+void ActionWithAS::leave_() {
+    ActionWithPosAngReduce::leave_();
+}
+
+void ActionWithAS::loadParams_() {
+    getStaticParam(&mPosReduceRatio_s, "PosReduceRatio");
+    getStaticParam(&mAngReduceRatio_s, "AngReduceRatio");
+}
+
+void ActionWithAS::calc_() {
+    ActionWithPosAngReduce::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionActionWithAS.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Game/AI/Action/actionActionWithPosAngReduce.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ActionWithAS : public ActionWithPosAngReduce {
+    SEAD_RTTI_OVERRIDE(ActionWithAS, ActionWithPosAngReduce)
+public:
+    explicit ActionWithAS(const InitArg& arg);
+    ~ActionWithAS() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const float* mPosReduceRatio_s{};
+    // static_param at offset 0x28
+    const float* mAngReduceRatio_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionActionWithPosAngReduce.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/Action/actionActionWithPosAngReduce.h"
+
+namespace uking::action {
+
+ActionWithPosAngReduce::ActionWithPosAngReduce(const InitArg& arg) : ActionEx(arg) {}
+
+ActionWithPosAngReduce::~ActionWithPosAngReduce() = default;
+
+bool ActionWithPosAngReduce::init_(sead::Heap* heap) {
+    return ActionEx::init_(heap);
+}
+
+void ActionWithPosAngReduce::enter_(ksys::act::ai::InlineParamPack* params) {
+    ActionEx::enter_(params);
+}
+
+void ActionWithPosAngReduce::leave_() {
+    ActionEx::leave_();
+}
+
+void ActionWithPosAngReduce::loadParams_() {
+    getStaticParam(&mPosReduceRatio_s, "PosReduceRatio");
+    getStaticParam(&mAngReduceRatio_s, "AngReduceRatio");
+}
+
+void ActionWithPosAngReduce::calc_() {
+    ActionEx::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionActionWithPosAngReduce.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Game/AI/Action/actionActionEx.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ActionWithPosAngReduce : public ActionEx {
+    SEAD_RTTI_OVERRIDE(ActionWithPosAngReduce, ActionEx)
+public:
+    explicit ActionWithPosAngReduce(const InitArg& arg);
+    ~ActionWithPosAngReduce() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const float* mPosReduceRatio_s{};
+    // static_param at offset 0x28
+    const float* mAngReduceRatio_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionActivateAttackSensor.cpp

@@ -0,0 +1,42 @@
+#include "Game/AI/Action/actionActivateAttackSensor.h"
+
+namespace uking::action {
+
+ActivateAttackSensor::ActivateAttackSensor(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+ActivateAttackSensor::~ActivateAttackSensor() = default;
+
+bool ActivateAttackSensor::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void ActivateAttackSensor::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void ActivateAttackSensor::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void ActivateAttackSensor::loadParams_() {
+    getStaticParam(&mAtDamage_s, "AtDamage");
+    getStaticParam(&mAtPower_s, "AtPower");
+    getStaticParam(&mAtPowerReduce_s, "AtPowerReduce");
+    getStaticParam(&mAtImpact_s, "AtImpact");
+    getStaticParam(&mAtShieldBreakPower_s, "AtShieldBreakPower");
+    getStaticParam(&mAtType_s, "AtType");
+    getStaticParam(&mAtAttr_s, "AtAttr");
+    getStaticParam(&mAtDirType_s, "AtDirType");
+    getStaticParam(&mFramesActive_s, "FramesActive");
+    getStaticParam(&mIsSuccessFinishCounterEnd_s, "IsSuccessFinishCounterEnd");
+    getStaticParam(&mIsChangeable_s, "IsChangeable");
+    getStaticParam(&mUseMapUnitParamForDamage_s, "UseMapUnitParamForDamage");
+    getStaticParam(&mAtkSensorName_s, "AtkSensorName");
+    getMapUnitParam(&mAttackPower_m, "AttackPower");
+}
+
+void ActivateAttackSensor::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionActivateAttackSensor.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ActivateAttackSensor : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(ActivateAttackSensor, ksys::act::ai::Action)
+public:
+    explicit ActivateAttackSensor(const InitArg& arg);
+    ~ActivateAttackSensor() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mAtDamage_s{};
+    // static_param at offset 0x28
+    const int* mAtPower_s{};
+    // static_param at offset 0x30
+    const int* mAtPowerReduce_s{};
+    // static_param at offset 0x38
+    const int* mAtImpact_s{};
+    // static_param at offset 0x40
+    const int* mAtShieldBreakPower_s{};
+    // static_param at offset 0x48
+    const int* mAtType_s{};
+    // static_param at offset 0x50
+    const int* mAtAttr_s{};
+    // static_param at offset 0x58
+    const int* mAtDirType_s{};
+    // static_param at offset 0x60
+    const float* mFramesActive_s{};
+    // static_param at offset 0x68
+    const bool* mIsSuccessFinishCounterEnd_s{};
+    // static_param at offset 0x70
+    const bool* mIsChangeable_s{};
+    // static_param at offset 0x78
+    const bool* mUseMapUnitParamForDamage_s{};
+    // static_param at offset 0x80
+    sead::SafeString mAtkSensorName_s{};
+    // map_unit_param at offset 0x90
+    const int* mAttackPower_m{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorAreaInOutSendMessage.cpp

@@ -0,0 +1,29 @@
+#include "Game/AI/Action/actionActorAreaInOutSendMessage.h"
+
+namespace uking::action {
+
+ActorAreaInOutSendMessage::ActorAreaInOutSendMessage(const InitArg& arg) : AreaTagAction(arg) {}
+
+ActorAreaInOutSendMessage::~ActorAreaInOutSendMessage() = default;
+
+bool ActorAreaInOutSendMessage::init_(sead::Heap* heap) {
+    return AreaTagAction::init_(heap);
+}
+
+void ActorAreaInOutSendMessage::enter_(ksys::act::ai::InlineParamPack* params) {
+    AreaTagAction::enter_(params);
+}
+
+void ActorAreaInOutSendMessage::leave_() {
+    AreaTagAction::leave_();
+}
+
+void ActorAreaInOutSendMessage::loadParams_() {
+    getStaticParam(&mBufferNum_s, "BufferNum");
+}
+
+void ActorAreaInOutSendMessage::calc_() {
+    AreaTagAction::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorAreaInOutSendMessage.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Game/AI/Action/actionAreaTagAction.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ActorAreaInOutSendMessage : public AreaTagAction {
+    SEAD_RTTI_OVERRIDE(ActorAreaInOutSendMessage, AreaTagAction)
+public:
+    explicit ActorAreaInOutSendMessage(const InitArg& arg);
+    ~ActorAreaInOutSendMessage() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x38
+    const int* mBufferNum_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorInfoToGameDataFloat.cpp

@@ -0,0 +1,32 @@
+#include "Game/AI/Action/actionActorInfoToGameDataFloat.h"
+
+namespace uking::action {
+
+ActorInfoToGameDataFloat::ActorInfoToGameDataFloat(const InitArg& arg)
+    : ksys::act::ai::Action(arg) {}
+
+ActorInfoToGameDataFloat::~ActorInfoToGameDataFloat() = default;
+
+bool ActorInfoToGameDataFloat::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void ActorInfoToGameDataFloat::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void ActorInfoToGameDataFloat::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void ActorInfoToGameDataFloat::loadParams_() {
+    getDynamicParam(&mActorName_d, "ActorName");
+    getDynamicParam(&mGameDataFloatToName_d, "GameDataFloatToName");
+    getDynamicParam(&mParameterName_d, "ParameterName");
+}
+
+void ActorInfoToGameDataFloat::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorInfoToGameDataFloat.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ActorInfoToGameDataFloat : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(ActorInfoToGameDataFloat, ksys::act::ai::Action)
+public:
+    explicit ActorInfoToGameDataFloat(const InitArg& arg);
+    ~ActorInfoToGameDataFloat() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // dynamic_param at offset 0x20
+    sead::SafeString* mActorName_d{};
+    // dynamic_param at offset 0x30
+    sead::SafeString* mGameDataFloatToName_d{};
+    // dynamic_param at offset 0x40
+    sead::SafeString* mParameterName_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorInfoToGameDataInt.cpp

@@ -0,0 +1,31 @@
+#include "Game/AI/Action/actionActorInfoToGameDataInt.h"
+
+namespace uking::action {
+
+ActorInfoToGameDataInt::ActorInfoToGameDataInt(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+ActorInfoToGameDataInt::~ActorInfoToGameDataInt() = default;
+
+bool ActorInfoToGameDataInt::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void ActorInfoToGameDataInt::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void ActorInfoToGameDataInt::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void ActorInfoToGameDataInt::loadParams_() {
+    getDynamicParam(&mActorName_d, "ActorName");
+    getDynamicParam(&mGameDataIntToName_d, "GameDataIntToName");
+    getDynamicParam(&mParameterName_d, "ParameterName");
+}
+
+void ActorInfoToGameDataInt::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorInfoToGameDataInt.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ActorInfoToGameDataInt : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(ActorInfoToGameDataInt, ksys::act::ai::Action)
+public:
+    explicit ActorInfoToGameDataInt(const InitArg& arg);
+    ~ActorInfoToGameDataInt() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // dynamic_param at offset 0x20
+    sead::SafeString* mActorName_d{};
+    // dynamic_param at offset 0x30
+    sead::SafeString* mGameDataIntToName_d{};
+    // dynamic_param at offset 0x40
+    sead::SafeString* mParameterName_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorInfoToGameDataVec3.cpp

@@ -0,0 +1,32 @@
+#include "Game/AI/Action/actionActorInfoToGameDataVec3.h"
+
+namespace uking::action {
+
+ActorInfoToGameDataVec3::ActorInfoToGameDataVec3(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+ActorInfoToGameDataVec3::~ActorInfoToGameDataVec3() = default;
+
+bool ActorInfoToGameDataVec3::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void ActorInfoToGameDataVec3::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void ActorInfoToGameDataVec3::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void ActorInfoToGameDataVec3::loadParams_() {
+    getDynamicParam(&mActorName_d, "ActorName");
+    getDynamicParam(&mUniqueName_d, "UniqueName");
+    getDynamicParam(&mGameDataVec3fToName_d, "GameDataVec3fToName");
+    getDynamicParam(&mParameterName_d, "ParameterName");
+}
+
+void ActorInfoToGameDataVec3::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionActorInfoToGameDataVec3.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class ActorInfoToGameDataVec3 : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(ActorInfoToGameDataVec3, ksys::act::ai::Action)
+public:
+    explicit ActorInfoToGameDataVec3(const InitArg& arg);
+    ~ActorInfoToGameDataVec3() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // dynamic_param at offset 0x20
+    sead::SafeString* mActorName_d{};
+    // dynamic_param at offset 0x30
+    sead::SafeString* mUniqueName_d{};
+    // dynamic_param at offset 0x40
+    sead::SafeString* mGameDataVec3fToName_d{};
+    // dynamic_param at offset 0x50
+    sead::SafeString* mParameterName_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAddAutoPlacementCreator.cpp

@@ -0,0 +1,31 @@
+#include "Game/AI/Action/actionAddAutoPlacementCreator.h"
+
+namespace uking::action {
+
+AddAutoPlacementCreator::AddAutoPlacementCreator(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AddAutoPlacementCreator::~AddAutoPlacementCreator() = default;
+
+bool AddAutoPlacementCreator::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AddAutoPlacementCreator::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AddAutoPlacementCreator::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AddAutoPlacementCreator::loadParams_() {
+    getMapUnitParam(&mCount_m, "Count");
+    getMapUnitParam(&mActorName_m, "ActorName");
+    getMapUnitParam(&mShape_m, "Shape");
+}
+
+void AddAutoPlacementCreator::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAddAutoPlacementCreator.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AddAutoPlacementCreator : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AddAutoPlacementCreator, ksys::act::ai::Action)
+public:
+    explicit AddAutoPlacementCreator(const InitArg& arg);
+    ~AddAutoPlacementCreator() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // map_unit_param at offset 0x20
+    const int* mCount_m{};
+    // map_unit_param at offset 0x28
+    sead::SafeString mActorName_m{};
+    // map_unit_param at offset 0x38
+    sead::SafeString mShape_m{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAddNoUseTerritoryCounter.cpp

@@ -0,0 +1,33 @@
+#include "Game/AI/Action/actionAddNoUseTerritoryCounter.h"
+
+namespace uking::action {
+
+AddNoUseTerritoryCounter::AddNoUseTerritoryCounter(const InitArg& arg)
+    : ksys::act::ai::Action(arg) {}
+
+AddNoUseTerritoryCounter::~AddNoUseTerritoryCounter() = default;
+
+bool AddNoUseTerritoryCounter::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AddNoUseTerritoryCounter::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AddNoUseTerritoryCounter::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AddNoUseTerritoryCounter::loadParams_() {
+    getStaticParam(&mCounter_s, "Counter");
+    getStaticParam(&mCamDist_s, "CamDist");
+    getMapUnitParam(&mTerritoryArea_m, "TerritoryArea");
+    getAITreeVariable(&mIsUseTerritory_a, "IsUseTerritory");
+}
+
+void AddNoUseTerritoryCounter::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAddNoUseTerritoryCounter.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AddNoUseTerritoryCounter : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AddNoUseTerritoryCounter, ksys::act::ai::Action)
+public:
+    explicit AddNoUseTerritoryCounter(const InitArg& arg);
+    ~AddNoUseTerritoryCounter() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mCounter_s{};
+    // static_param at offset 0x28
+    const float* mCamDist_s{};
+    // map_unit_param at offset 0x30
+    const float* mTerritoryArea_m{};
+    // aitree_variable at offset 0x38
+    bool* mIsUseTerritory_a{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAddRigidBody.cpp

@@ -0,0 +1,29 @@
+#include "Game/AI/Action/actionAddRigidBody.h"
+
+namespace uking::action {
+
+AddRigidBody::AddRigidBody(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AddRigidBody::~AddRigidBody() = default;
+
+bool AddRigidBody::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AddRigidBody::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AddRigidBody::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AddRigidBody::loadParams_() {
+    getStaticParam(&mResetLayer_s, "ResetLayer");
+}
+
+void AddRigidBody::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAddRigidBody.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AddRigidBody : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AddRigidBody, ksys::act::ai::Action)
+public:
+    explicit AddRigidBody(const InitArg& arg);
+    ~AddRigidBody() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const bool* mResetLayer_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAdvanceTime.cpp

@@ -0,0 +1,32 @@
+#include "Game/AI/Action/actionAdvanceTime.h"
+
+namespace uking::action {
+
+AdvanceTime::AdvanceTime(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AdvanceTime::~AdvanceTime() = default;
+
+bool AdvanceTime::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AdvanceTime::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AdvanceTime::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AdvanceTime::loadParams_() {
+    getDynamicParam(&mDestTime_d, "DestTime");
+    getDynamicParam(&mDirectTime_d, "DirectTime");
+    getDynamicParam(&mPassTime_d, "PassTime");
+    getDynamicParam(&mActReset_d, "ActReset");
+}
+
+void AdvanceTime::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAdvanceTime.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AdvanceTime : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AdvanceTime, ksys::act::ai::Action)
+public:
+    explicit AdvanceTime(const InitArg& arg);
+    ~AdvanceTime() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // dynamic_param at offset 0x20
+    int* mDestTime_d{};
+    // dynamic_param at offset 0x28
+    int* mDirectTime_d{};
+    // dynamic_param at offset 0x30
+    int* mPassTime_d{};
+    // dynamic_param at offset 0x38
+    bool* mActReset_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAirOctaFloat.cpp

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

src/Game/AI/Action/actionAirOctaFloat.h

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

src/Game/AI/Action/actionAirOctaFloatBase.cpp

@@ -0,0 +1,32 @@
+#include "Game/AI/Action/actionAirOctaFloatBase.h"
+
+namespace uking::action {
+
+AirOctaFloatBase::AirOctaFloatBase(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AirOctaFloatBase::~AirOctaFloatBase() = default;
+
+bool AirOctaFloatBase::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AirOctaFloatBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AirOctaFloatBase::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AirOctaFloatBase::loadParams_() {
+    getStaticParam(&mAmplitude_s, "Amplitude");
+    getStaticParam(&mGoalDistance_s, "GoalDistance");
+    getStaticParam(&mGoalInSuccessEnd_s, "GoalInSuccessEnd");
+    getAITreeVariable(&mAirOctaDataMgr_a, "AirOctaDataMgr");
+}
+
+void AirOctaFloatBase::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAirOctaFloatBase.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AirOctaFloatBase : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AirOctaFloatBase, ksys::act::ai::Action)
+public:
+    explicit AirOctaFloatBase(const InitArg& arg);
+    ~AirOctaFloatBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const float* mAmplitude_s{};
+    // static_param at offset 0x28
+    const float* mGoalDistance_s{};
+    // static_param at offset 0x30
+    const bool* mGoalInSuccessEnd_s{};
+    // aitree_variable at offset 0x38
+    void* mAirOctaDataMgr_a{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAirOctaMgr.cpp

@@ -0,0 +1,34 @@
+#include "Game/AI/Action/actionAirOctaMgr.h"
+
+namespace uking::action {
+
+AirOctaMgr::AirOctaMgr(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AirOctaMgr::~AirOctaMgr() = default;
+
+bool AirOctaMgr::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AirOctaMgr::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AirOctaMgr::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AirOctaMgr::loadParams_() {
+    getStaticParam(&mLeaveDistance_s, "LeaveDistance");
+    getStaticParam(&mLeaveDownY_s, "LeaveDownY");
+    getStaticParam(&monGraundEscapeDist_s, "onGraundEscapeDist");
+    getStaticParam(&mPlayerLostTime_s, "PlayerLostTime");
+    getMapUnitParam(&mMoveDis_m, "MoveDis");
+    getMapUnitParam(&mReactHorn_m, "ReactHorn");
+}
+
+void AirOctaMgr::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAirOctaMgr.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AirOctaMgr : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AirOctaMgr, ksys::act::ai::Action)
+public:
+    explicit AirOctaMgr(const InitArg& arg);
+    ~AirOctaMgr() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const float* mLeaveDistance_s{};
+    // static_param at offset 0x28
+    const float* mLeaveDownY_s{};
+    // static_param at offset 0x30
+    const float* monGraundEscapeDist_s{};
+    // static_param at offset 0x38
+    const float* mPlayerLostTime_s{};
+    // map_unit_param at offset 0x40
+    const float* mMoveDis_m{};
+    // map_unit_param at offset 0x48
+    const bool* mReactHorn_m{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAirOctaNoticeTurn.cpp

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

src/Game/AI/Action/actionAirOctaNoticeTurn.h

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

src/Game/AI/Action/actionAirOctaReactionKorog.cpp

@@ -0,0 +1,31 @@
+#include "Game/AI/Action/actionAirOctaReactionKorog.h"
+
+namespace uking::action {
+
+AirOctaReactionKorog::AirOctaReactionKorog(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AirOctaReactionKorog::~AirOctaReactionKorog() = default;
+
+bool AirOctaReactionKorog::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AirOctaReactionKorog::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AirOctaReactionKorog::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AirOctaReactionKorog::loadParams_() {
+    getStaticParam(&mEndState_s, "EndState");
+    getStaticParam(&mSpeed_s, "Speed");
+    getStaticParam(&mAS_s, "AS");
+}
+
+void AirOctaReactionKorog::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAirOctaReactionKorog.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AirOctaReactionKorog : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AirOctaReactionKorog, ksys::act::ai::Action)
+public:
+    explicit AirOctaReactionKorog(const InitArg& arg);
+    ~AirOctaReactionKorog() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mEndState_s{};
+    // static_param at offset 0x28
+    const float* mSpeed_s{};
+    // static_param at offset 0x30
+    sead::SafeString mAS_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAirOctaWoodBridge.cpp

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

src/Game/AI/Action/actionAirOctaWoodBridge.h

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

src/Game/AI/Action/actionAirWallAction.cpp

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

src/Game/AI/Action/actionAirWallAction.h

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

src/Game/AI/Action/actionAirWallCurseGanon.cpp

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

src/Game/AI/Action/actionAirWallCurseGanon.h

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

src/Game/AI/Action/actionAirWallHorse.cpp

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

src/Game/AI/Action/actionAirWallHorse.h

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

src/Game/AI/Action/actionAlarmLynelTag.cpp

@@ -0,0 +1,29 @@
+#include "Game/AI/Action/actionAlarmLynelTag.h"
+
+namespace uking::action {
+
+AlarmLynelTag::AlarmLynelTag(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AlarmLynelTag::~AlarmLynelTag() = default;
+
+bool AlarmLynelTag::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AlarmLynelTag::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AlarmLynelTag::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AlarmLynelTag::loadParams_() {
+    getMapUnitParam(&mAlarmPoint_m, "AlarmPoint");
+}
+
+void AlarmLynelTag::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAlarmLynelTag.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AlarmLynelTag : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AlarmLynelTag, ksys::act::ai::Action)
+public:
+    explicit AlarmLynelTag(const InitArg& arg);
+    ~AlarmLynelTag() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // map_unit_param at offset 0x20
+    const int* mAlarmPoint_m{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAlertNearbyEnemies.cpp

@@ -0,0 +1,33 @@
+#include "Game/AI/Action/actionAlertNearbyEnemies.h"
+
+namespace uking::action {
+
+AlertNearbyEnemies::AlertNearbyEnemies(const InitArg& arg) : PlayASForAnimalUnit(arg) {}
+
+AlertNearbyEnemies::~AlertNearbyEnemies() = default;
+
+bool AlertNearbyEnemies::init_(sead::Heap* heap) {
+    return PlayASForAnimalUnit::init_(heap);
+}
+
+void AlertNearbyEnemies::enter_(ksys::act::ai::InlineParamPack* params) {
+    PlayASForAnimalUnit::enter_(params);
+}
+
+void AlertNearbyEnemies::leave_() {
+    PlayASForAnimalUnit::leave_();
+}
+
+void AlertNearbyEnemies::loadParams_() {
+    PlayASForAnimalUnit::loadParams_();
+    getStaticParam(&mAlertRange_s, "AlertRange");
+    getStaticParam(&mAlertTime_s, "AlertTime");
+    getStaticParam(&mNoiseLevel_s, "NoiseLevel");
+    getStaticParam(&mUseNoise_s, "UseNoise");
+}
+
+void AlertNearbyEnemies::calc_() {
+    PlayASForAnimalUnit::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAlertNearbyEnemies.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Game/AI/Action/actionPlayASForAnimalUnit.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AlertNearbyEnemies : public PlayASForAnimalUnit {
+    SEAD_RTTI_OVERRIDE(AlertNearbyEnemies, PlayASForAnimalUnit)
+public:
+    explicit AlertNearbyEnemies(const InitArg& arg);
+    ~AlertNearbyEnemies() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x60
+    const float* mAlertRange_s{};
+    // static_param at offset 0x68
+    const float* mAlertTime_s{};
+    // static_param at offset 0x70
+    const float* mNoiseLevel_s{};
+    // static_param at offset 0x78
+    const bool* mUseNoise_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAmbushThrown.cpp

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

src/Game/AI/Action/actionAmbushThrown.h

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

src/Game/AI/Action/actionAnchorSummon.cpp

@@ -0,0 +1,33 @@
+#include "Game/AI/Action/actionAnchorSummon.h"
+
+namespace uking::action {
+
+AnchorSummon::AnchorSummon(const InitArg& arg) : ActionWithPosAngReduce(arg) {}
+
+AnchorSummon::~AnchorSummon() = default;
+
+bool AnchorSummon::init_(sead::Heap* heap) {
+    return ActionWithPosAngReduce::init_(heap);
+}
+
+void AnchorSummon::enter_(ksys::act::ai::InlineParamPack* params) {
+    ActionWithPosAngReduce::enter_(params);
+}
+
+void AnchorSummon::leave_() {
+    ActionWithPosAngReduce::leave_();
+}
+
+void AnchorSummon::loadParams_() {
+    ActionWithPosAngReduce::loadParams_();
+    getStaticParam(&mASName_s, "ASName");
+    getDynamicParam(&mSummonActor_d, "SummonActor");
+    getDynamicParam(&mSummonActorEquip1_d, "SummonActorEquip1");
+    getDynamicParam(&mSummonActorEquip2_d, "SummonActorEquip2");
+}
+
+void AnchorSummon::calc_() {
+    ActionWithPosAngReduce::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnchorSummon.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Game/AI/Action/actionActionWithPosAngReduce.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnchorSummon : public ActionWithPosAngReduce {
+    SEAD_RTTI_OVERRIDE(AnchorSummon, ActionWithPosAngReduce)
+public:
+    explicit AnchorSummon(const InitArg& arg);
+    ~AnchorSummon() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x30
+    sead::SafeString mASName_s{};
+    // dynamic_param at offset 0x40
+    sead::SafeString* mSummonActor_d{};
+    // dynamic_param at offset 0x50
+    sead::SafeString* mSummonActorEquip1_d{};
+    // dynamic_param at offset 0x60
+    sead::SafeString* mSummonActorEquip2_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAngry.cpp

@@ -0,0 +1,29 @@
+#include "Game/AI/Action/actionAngry.h"
+
+namespace uking::action {
+
+Angry::Angry(const InitArg& arg) : ActionWithAS(arg) {}
+
+Angry::~Angry() = default;
+
+bool Angry::init_(sead::Heap* heap) {
+    return ActionWithAS::init_(heap);
+}
+
+void Angry::enter_(ksys::act::ai::InlineParamPack* params) {
+    ActionWithAS::enter_(params);
+}
+
+void Angry::leave_() {
+    ActionWithAS::leave_();
+}
+
+void Angry::loadParams_() {
+    ActionWithPosAngReduce::loadParams_();
+}
+
+void Angry::calc_() {
+    ActionWithAS::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAngry.h

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

src/Game/AI/Action/actionAnimMatrixDriven.cpp

@@ -0,0 +1,34 @@
+#include "Game/AI/Action/actionAnimMatrixDriven.h"
+
+namespace uking::action {
+
+AnimMatrixDriven::AnimMatrixDriven(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimMatrixDriven::~AnimMatrixDriven() = default;
+
+bool AnimMatrixDriven::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimMatrixDriven::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimMatrixDriven::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimMatrixDriven::loadParams_() {
+    getDynamicParam(&mASSlot_d, "ASSlot");
+    getDynamicParam(&mSequenceBank_d, "SequenceBank");
+    getDynamicParam(&mStartFrame_d, "StartFrame");
+    getDynamicParam(&mIsIgnoreSame_d, "IsIgnoreSame");
+    getDynamicParam(&mIsChangeable_d, "IsChangeable");
+    getDynamicParam(&mASName_d, "ASName");
+}
+
+void AnimMatrixDriven::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimMatrixDriven.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimMatrixDriven : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimMatrixDriven, ksys::act::ai::Action)
+public:
+    explicit AnimMatrixDriven(const InitArg& arg);
+    ~AnimMatrixDriven() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // dynamic_param at offset 0x20
+    int* mASSlot_d{};
+    // dynamic_param at offset 0x28
+    int* mSequenceBank_d{};
+    // dynamic_param at offset 0x30
+    float* mStartFrame_d{};
+    // dynamic_param at offset 0x38
+    bool* mIsIgnoreSame_d{};
+    // dynamic_param at offset 0x40
+    bool* mIsChangeable_d{};
+    // dynamic_param at offset 0x48
+    sead::SafeString* mASName_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimTimingAttackMove.cpp

@@ -0,0 +1,34 @@
+#include "Game/AI/Action/actionAnimTimingAttackMove.h"
+
+namespace uking::action {
+
+AnimTimingAttackMove::AnimTimingAttackMove(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimTimingAttackMove::~AnimTimingAttackMove() = default;
+
+bool AnimTimingAttackMove::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimTimingAttackMove::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimTimingAttackMove::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimTimingAttackMove::loadParams_() {
+    getStaticParam(&mJumpHeight_s, "JumpHeight");
+    getStaticParam(&mMaxSpeed_s, "MaxSpeed");
+    getStaticParam(&mIsRound_s, "IsRound");
+    getStaticParam(&mASName_s, "ASName");
+    getStaticParam(&mRigidBodyName_s, "RigidBodyName");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+void AnimTimingAttackMove::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimTimingAttackMove.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimTimingAttackMove : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimTimingAttackMove, ksys::act::ai::Action)
+public:
+    explicit AnimTimingAttackMove(const InitArg& arg);
+    ~AnimTimingAttackMove() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const float* mJumpHeight_s{};
+    // static_param at offset 0x28
+    const float* mMaxSpeed_s{};
+    // static_param at offset 0x30
+    const bool* mIsRound_s{};
+    // static_param at offset 0x38
+    sead::SafeString mASName_s{};
+    // static_param at offset 0x48
+    sead::SafeString mRigidBodyName_s{};
+    // dynamic_param at offset 0x58
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalASPlayCheckMoveDir.cpp

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

src/Game/AI/Action/actionAnimalASPlayCheckMoveDir.h

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

src/Game/AI/Action/actionAnimalASPlayWithLegTurn.cpp

@@ -0,0 +1,33 @@
+#include "Game/AI/Action/actionAnimalASPlayWithLegTurn.h"
+
+namespace uking::action {
+
+AnimalASPlayWithLegTurn::AnimalASPlayWithLegTurn(const InitArg& arg) : ForkAnimalASPlay(arg) {}
+
+AnimalASPlayWithLegTurn::~AnimalASPlayWithLegTurn() = default;
+
+bool AnimalASPlayWithLegTurn::init_(sead::Heap* heap) {
+    return ForkAnimalASPlay::init_(heap);
+}
+
+void AnimalASPlayWithLegTurn::enter_(ksys::act::ai::InlineParamPack* params) {
+    ForkAnimalASPlay::enter_(params);
+}
+
+void AnimalASPlayWithLegTurn::leave_() {
+    ForkAnimalASPlay::leave_();
+}
+
+void AnimalASPlayWithLegTurn::loadParams_() {
+    ForkAnimalASPlay::loadParams_();
+    getStaticParam(&mRotSpeed_s, "RotSpeed");
+    getStaticParam(&mRotAccRatio_s, "RotAccRatio");
+    getStaticParam(&mRotRatio_s, "RotRatio");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+void AnimalASPlayWithLegTurn::calc_() {
+    ForkAnimalASPlay::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalASPlayWithLegTurn.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Game/AI/Action/actionForkAnimalASPlay.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalASPlayWithLegTurn : public ForkAnimalASPlay {
+    SEAD_RTTI_OVERRIDE(AnimalASPlayWithLegTurn, ForkAnimalASPlay)
+public:
+    explicit AnimalASPlayWithLegTurn(const InitArg& arg);
+    ~AnimalASPlayWithLegTurn() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x60
+    const float* mRotSpeed_s{};
+    // static_param at offset 0x68
+    const float* mRotAccRatio_s{};
+    // static_param at offset 0x70
+    const float* mRotRatio_s{};
+    // dynamic_param at offset 0x78
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalEatAction.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/Action/actionAnimalEatAction.h"
+
+namespace uking::action {
+
+AnimalEatAction::AnimalEatAction(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimalEatAction::~AnimalEatAction() = default;
+
+bool AnimalEatAction::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimalEatAction::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimalEatAction::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimalEatAction::loadParams_() {
+    getStaticParam(&mMinFramesPlayWaitAS_s, "MinFramesPlayWaitAS");
+    getDynamicParam(&mTargetActor_d, "TargetActor");
+}
+
+void AnimalEatAction::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalEatAction.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalEatAction : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimalEatAction, ksys::act::ai::Action)
+public:
+    explicit AnimalEatAction(const InitArg& arg);
+    ~AnimalEatAction() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const float* mMinFramesPlayWaitAS_s{};
+    // dynamic_param at offset 0x28
+    ksys::act::BaseProcLink* mTargetActor_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalElectricParalysis.cpp

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

src/Game/AI/Action/actionAnimalElectricParalysis.h

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

src/Game/AI/Action/actionAnimalFollow.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/Action/actionAnimalFollow.h"
+
+namespace uking::action {
+
+AnimalFollow::AnimalFollow(const InitArg& arg) : AnimalFollowBase(arg) {}
+
+AnimalFollow::~AnimalFollow() = default;
+
+bool AnimalFollow::init_(sead::Heap* heap) {
+    return AnimalFollowBase::init_(heap);
+}
+
+void AnimalFollow::enter_(ksys::act::ai::InlineParamPack* params) {
+    AnimalFollowBase::enter_(params);
+}
+
+void AnimalFollow::leave_() {
+    AnimalFollowBase::leave_();
+}
+
+void AnimalFollow::loadParams_() {
+    AnimalFollowBase::loadParams_();
+    getStaticParam(&mDistanceKept_s, "DistanceKept");
+}
+
+void AnimalFollow::calc_() {
+    AnimalFollowBase::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalFollow.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Game/AI/Action/actionAnimalFollowBase.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalFollow : public AnimalFollowBase {
+    SEAD_RTTI_OVERRIDE(AnimalFollow, AnimalFollowBase)
+public:
+    explicit AnimalFollow(const InitArg& arg);
+    ~AnimalFollow() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0xc0
+    const float* mDistanceKept_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalFollowBase.cpp

@@ -0,0 +1,46 @@
+#include "Game/AI/Action/actionAnimalFollowBase.h"
+
+namespace uking::action {
+
+AnimalFollowBase::AnimalFollowBase(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimalFollowBase::~AnimalFollowBase() = default;
+
+bool AnimalFollowBase::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimalFollowBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimalFollowBase::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimalFollowBase::loadParams_() {
+    getStaticParam(&mUseGearType_s, "UseGearType");
+    getStaticParam(&mWaitDistanceToLeader_s, "WaitDistanceToLeader");
+    getStaticParam(&mGear1DistanceToLeader_s, "Gear1DistanceToLeader");
+    getStaticParam(&mGear2DistanceToLeader_s, "Gear2DistanceToLeader");
+    getStaticParam(&mGear3DistanceToLeader_s, "Gear3DistanceToLeader");
+    getStaticParam(&mDistanceFactorAtGearDown_s, "DistanceFactorAtGearDown");
+    getStaticParam(&mWaitDistanceIncreaseDistance_s, "WaitDistanceIncreaseDistance");
+    getStaticParam(&mWaitDistanceIncreasePerFrame_s, "WaitDistanceIncreasePerFrame");
+    getStaticParam(&mAutoStopAndTurnDistance_s, "AutoStopAndTurnDistance");
+    getStaticParam(&mDesiredDirAngleDeltaSecMax_s, "DesiredDirAngleDeltaSecMax");
+    getStaticParam(&mNavMeshCharacterRadiusScale_s, "NavMeshCharacterRadiusScale");
+    getStaticParam(&mCanUseHorseGearInput_s, "CanUseHorseGearInput");
+    getStaticParam(&mIsAutoGearDownEnabled_s, "IsAutoGearDownEnabled");
+    getStaticParam(&mIsEndAtAutoStop_s, "IsEndAtAutoStop");
+    getStaticParam(&mUseMinRadius_s, "UseMinRadius");
+    getStaticParam(&mIsAvoidNavMeshActor_s, "IsAvoidNavMeshActor");
+    getStaticParam(&mIsTargetPosEqualToLeaderPos_s, "IsTargetPosEqualToLeaderPos");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+void AnimalFollowBase::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalFollowBase.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalFollowBase : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimalFollowBase, ksys::act::ai::Action)
+public:
+    explicit AnimalFollowBase(const InitArg& arg);
+    ~AnimalFollowBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mUseGearType_s{};
+    // static_param at offset 0x28
+    const float* mWaitDistanceToLeader_s{};
+    // static_param at offset 0x30
+    const float* mGear1DistanceToLeader_s{};
+    // static_param at offset 0x38
+    const float* mGear2DistanceToLeader_s{};
+    // static_param at offset 0x40
+    const float* mGear3DistanceToLeader_s{};
+    // static_param at offset 0x48
+    const float* mDistanceFactorAtGearDown_s{};
+    // static_param at offset 0x50
+    const float* mWaitDistanceIncreaseDistance_s{};
+    // static_param at offset 0x58
+    const float* mWaitDistanceIncreasePerFrame_s{};
+    // static_param at offset 0x60
+    const float* mAutoStopAndTurnDistance_s{};
+    // static_param at offset 0x68
+    const float* mDesiredDirAngleDeltaSecMax_s{};
+    // static_param at offset 0x70
+    const float* mNavMeshCharacterRadiusScale_s{};
+    // static_param at offset 0x78
+    const bool* mCanUseHorseGearInput_s{};
+    // static_param at offset 0x80
+    const bool* mIsAutoGearDownEnabled_s{};
+    // static_param at offset 0x88
+    const bool* mIsEndAtAutoStop_s{};
+    // static_param at offset 0x90
+    const bool* mUseMinRadius_s{};
+    // static_param at offset 0x98
+    const bool* mIsAvoidNavMeshActor_s{};
+    // static_param at offset 0xa0
+    const bool* mIsTargetPosEqualToLeaderPos_s{};
+    // dynamic_param at offset 0xa8
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalFreeze.cpp

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

src/Game/AI/Action/actionAnimalFreeze.h

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

src/Game/AI/Action/actionAnimalLegTurnAutoSpeed.cpp

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

src/Game/AI/Action/actionAnimalLegTurnAutoSpeed.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Game/AI/Action/actionForkAnimalASPlay.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalLegTurnAutoSpeed : public ForkAnimalASPlay {
+    SEAD_RTTI_OVERRIDE(AnimalLegTurnAutoSpeed, ForkAnimalASPlay)
+public:
+    explicit AnimalLegTurnAutoSpeed(const InitArg& arg);
+    ~AnimalLegTurnAutoSpeed() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // dynamic_param at offset 0x60
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMove.cpp

@@ -0,0 +1,31 @@
+#include "Game/AI/Action/actionAnimalMove.h"
+
+namespace uking::action {
+
+AnimalMove::AnimalMove(const InitArg& arg) : AnimalMoveBase(arg) {}
+
+AnimalMove::~AnimalMove() = default;
+
+bool AnimalMove::init_(sead::Heap* heap) {
+    return AnimalMoveBase::init_(heap);
+}
+
+void AnimalMove::enter_(ksys::act::ai::InlineParamPack* params) {
+    AnimalMoveBase::enter_(params);
+}
+
+void AnimalMove::leave_() {
+    AnimalMoveBase::leave_();
+}
+
+void AnimalMove::loadParams_() {
+    AnimalMoveBase::loadParams_();
+    getStaticParam(&mWeaponIdx_s, "WeaponIdx");
+    getStaticParam(&mFinRadius_s, "FinRadius");
+}
+
+void AnimalMove::calc_() {
+    AnimalMoveBase::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMove.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Game/AI/Action/actionAnimalMoveBase.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalMove : public AnimalMoveBase {
+    SEAD_RTTI_OVERRIDE(AnimalMove, AnimalMoveBase)
+public:
+    explicit AnimalMove(const InitArg& arg);
+    ~AnimalMove() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x70
+    const int* mWeaponIdx_s{};
+    // static_param at offset 0x78
+    const float* mFinRadius_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMoveBase.cpp

@@ -0,0 +1,37 @@
+#include "Game/AI/Action/actionAnimalMoveBase.h"
+
+namespace uking::action {
+
+AnimalMoveBase::AnimalMoveBase(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimalMoveBase::~AnimalMoveBase() = default;
+
+bool AnimalMoveBase::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimalMoveBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimalMoveBase::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimalMoveBase::loadParams_() {
+    getStaticParam(&mMinUseGear_s, "MinUseGear");
+    getStaticParam(&mMaxUseGear_s, "MaxUseGear");
+    getStaticParam(&mUseGearType_s, "UseGearType");
+    getStaticParam(&mMinGearAtAutoGearDown_s, "MinGearAtAutoGearDown");
+    getStaticParam(&mGoalDistanceTolerance_s, "GoalDistanceTolerance");
+    getStaticParam(&mCanUseHorseGearInput_s, "CanUseHorseGearInput");
+    getStaticParam(&mIsAutoGearDownEnabled_s, "IsAutoGearDownEnabled");
+    getStaticParam(&mHasToDecelerateNearGoal_s, "HasToDecelerateNearGoal");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+void AnimalMoveBase::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMoveBase.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalMoveBase : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimalMoveBase, ksys::act::ai::Action)
+public:
+    explicit AnimalMoveBase(const InitArg& arg);
+    ~AnimalMoveBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mMinUseGear_s{};
+    // static_param at offset 0x28
+    const int* mMaxUseGear_s{};
+    // static_param at offset 0x30
+    const int* mUseGearType_s{};
+    // static_param at offset 0x38
+    const int* mMinGearAtAutoGearDown_s{};
+    // static_param at offset 0x40
+    const float* mGoalDistanceTolerance_s{};
+    // static_param at offset 0x48
+    const bool* mCanUseHorseGearInput_s{};
+    // static_param at offset 0x50
+    const bool* mIsAutoGearDownEnabled_s{};
+    // static_param at offset 0x58
+    const bool* mHasToDecelerateNearGoal_s{};
+    // dynamic_param at offset 0x60
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMoveGuidedBase.cpp

@@ -0,0 +1,38 @@
+#include "Game/AI/Action/actionAnimalMoveGuidedBase.h"
+
+namespace uking::action {
+
+AnimalMoveGuidedBase::AnimalMoveGuidedBase(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimalMoveGuidedBase::~AnimalMoveGuidedBase() = default;
+
+bool AnimalMoveGuidedBase::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimalMoveGuidedBase::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimalMoveGuidedBase::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimalMoveGuidedBase::loadParams_() {
+    getStaticParam(&mMinUseGear_s, "MinUseGear");
+    getStaticParam(&mMaxUseGear_s, "MaxUseGear");
+    getStaticParam(&mUseGearType_s, "UseGearType");
+    getStaticParam(&mAutoStopAndTurnMode_s, "AutoStopAndTurnMode");
+    getStaticParam(&mMinGearAtAutoGearDown_s, "MinGearAtAutoGearDown");
+    getStaticParam(&mGoalDistanceTolerance_s, "GoalDistanceTolerance");
+    getStaticParam(&mCanUseHorseGearInput_s, "CanUseHorseGearInput");
+    getStaticParam(&mIsAutoGearDownEnabled_s, "IsAutoGearDownEnabled");
+    getStaticParam(&mHasToDecelerateNearGoal_s, "HasToDecelerateNearGoal");
+    getStaticParam(&mWaitUntilPathSucceeded_s, "WaitUntilPathSucceeded");
+}
+
+void AnimalMoveGuidedBase::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMoveGuidedBase.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalMoveGuidedBase : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimalMoveGuidedBase, ksys::act::ai::Action)
+public:
+    explicit AnimalMoveGuidedBase(const InitArg& arg);
+    ~AnimalMoveGuidedBase() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mMinUseGear_s{};
+    // static_param at offset 0x28
+    const int* mMaxUseGear_s{};
+    // static_param at offset 0x30
+    const int* mUseGearType_s{};
+    // static_param at offset 0x38
+    const int* mAutoStopAndTurnMode_s{};
+    // static_param at offset 0x40
+    const int* mMinGearAtAutoGearDown_s{};
+    // static_param at offset 0x48
+    const float* mGoalDistanceTolerance_s{};
+    // static_param at offset 0x50
+    const bool* mCanUseHorseGearInput_s{};
+    // static_param at offset 0x58
+    const bool* mIsAutoGearDownEnabled_s{};
+    // static_param at offset 0x60
+    const bool* mHasToDecelerateNearGoal_s{};
+    // static_param at offset 0x68
+    const bool* mWaitUntilPathSucceeded_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMoveStraightTimed.cpp

@@ -0,0 +1,37 @@
+#include "Game/AI/Action/actionAnimalMoveStraightTimed.h"
+
+namespace uking::action {
+
+AnimalMoveStraightTimed::AnimalMoveStraightTimed(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimalMoveStraightTimed::~AnimalMoveStraightTimed() = default;
+
+bool AnimalMoveStraightTimed::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimalMoveStraightTimed::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimalMoveStraightTimed::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimalMoveStraightTimed::loadParams_() {
+    getStaticParam(&mFramesUntilFinish_s, "FramesUntilFinish");
+    getStaticParam(&mMinUseGear_s, "MinUseGear");
+    getStaticParam(&mMaxUseGear_s, "MaxUseGear");
+    getStaticParam(&mUseGearType_s, "UseGearType");
+    getStaticParam(&mMinGearAtAutoGearDown_s, "MinGearAtAutoGearDown");
+    getStaticParam(&mLOSCheckTimeAhead_s, "LOSCheckTimeAhead");
+    getStaticParam(&mIsFinishOnLOSCheckFail_s, "IsFinishOnLOSCheckFail");
+    getStaticParam(&mUseDesiredMoveDir_s, "UseDesiredMoveDir");
+    getStaticParam(&mIsAutoGearDownEnabled_s, "IsAutoGearDownEnabled");
+}
+
+void AnimalMoveStraightTimed::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalMoveStraightTimed.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalMoveStraightTimed : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimalMoveStraightTimed, ksys::act::ai::Action)
+public:
+    explicit AnimalMoveStraightTimed(const InitArg& arg);
+    ~AnimalMoveStraightTimed() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mFramesUntilFinish_s{};
+    // static_param at offset 0x28
+    const int* mMinUseGear_s{};
+    // static_param at offset 0x30
+    const int* mMaxUseGear_s{};
+    // static_param at offset 0x38
+    const int* mUseGearType_s{};
+    // static_param at offset 0x40
+    const int* mMinGearAtAutoGearDown_s{};
+    // static_param at offset 0x48
+    const float* mLOSCheckTimeAhead_s{};
+    // static_param at offset 0x50
+    const bool* mIsFinishOnLOSCheckFail_s{};
+    // static_param at offset 0x58
+    const bool* mUseDesiredMoveDir_s{};
+    // static_param at offset 0x60
+    const bool* mIsAutoGearDownEnabled_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalNavMeshMove.cpp

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

src/Game/AI/Action/actionAnimalNavMeshMove.h

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

src/Game/AI/Action/actionAnimalNoCheckMove.cpp

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

src/Game/AI/Action/actionAnimalNoCheckMove.h

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

src/Game/AI/Action/actionAnimalPlayASAndKeepOnGround.cpp

@@ -0,0 +1,33 @@
+#include "Game/AI/Action/actionAnimalPlayASAndKeepOnGround.h"
+
+namespace uking::action {
+
+AnimalPlayASAndKeepOnGround::AnimalPlayASAndKeepOnGround(const InitArg& arg)
+    : PlayASForAnimalUnit(arg) {}
+
+AnimalPlayASAndKeepOnGround::~AnimalPlayASAndKeepOnGround() = default;
+
+bool AnimalPlayASAndKeepOnGround::init_(sead::Heap* heap) {
+    return PlayASForAnimalUnit::init_(heap);
+}
+
+void AnimalPlayASAndKeepOnGround::enter_(ksys::act::ai::InlineParamPack* params) {
+    PlayASForAnimalUnit::enter_(params);
+}
+
+void AnimalPlayASAndKeepOnGround::leave_() {
+    PlayASForAnimalUnit::leave_();
+}
+
+void AnimalPlayASAndKeepOnGround::loadParams_() {
+    PlayASForAnimalUnit::loadParams_();
+    getStaticParam(&mDownImpulseScale_s, "DownImpulseScale");
+    getStaticParam(&mIsUseDownImpulse_s, "IsUseDownImpulse");
+    getAITreeVariable(&mIsChangeableStateFreeFall_a, "IsChangeableStateFreeFall");
+}
+
+void AnimalPlayASAndKeepOnGround::calc_() {
+    PlayASForAnimalUnit::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalPlayASAndKeepOnGround.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "Game/AI/Action/actionPlayASForAnimalUnit.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalPlayASAndKeepOnGround : public PlayASForAnimalUnit {
+    SEAD_RTTI_OVERRIDE(AnimalPlayASAndKeepOnGround, PlayASForAnimalUnit)
+public:
+    explicit AnimalPlayASAndKeepOnGround(const InitArg& arg);
+    ~AnimalPlayASAndKeepOnGround() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x60
+    const float* mDownImpulseScale_s{};
+    // static_param at offset 0x68
+    const bool* mIsUseDownImpulse_s{};
+    // aitree_variable at offset 0x70
+    bool* mIsChangeableStateFreeFall_a{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalStop.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/Action/actionAnimalStop.h"
+
+namespace uking::action {
+
+AnimalStop::AnimalStop(const InitArg& arg) : HorseWaitAction(arg) {}
+
+AnimalStop::~AnimalStop() = default;
+
+bool AnimalStop::init_(sead::Heap* heap) {
+    return HorseWaitAction::init_(heap);
+}
+
+void AnimalStop::enter_(ksys::act::ai::InlineParamPack* params) {
+    HorseWaitAction::enter_(params);
+}
+
+void AnimalStop::leave_() {
+    HorseWaitAction::leave_();
+}
+
+void AnimalStop::loadParams_() {
+    HorseWaitAction::loadParams_();
+    getStaticParam(&mIsFixAxisY_s, "IsFixAxisY");
+}
+
+void AnimalStop::calc_() {
+    HorseWaitAction::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalStop.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Game/AI/Action/actionHorseWaitAction.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalStop : public HorseWaitAction {
+    SEAD_RTTI_OVERRIDE(AnimalStop, HorseWaitAction)
+public:
+    explicit AnimalStop(const InitArg& arg);
+    ~AnimalStop() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x60
+    const bool* mIsFixAxisY_s{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalTurn.cpp

@@ -0,0 +1,33 @@
+#include "Game/AI/Action/actionAnimalTurn.h"
+
+namespace uking::action {
+
+AnimalTurn::AnimalTurn(const InitArg& arg) : PlayASForAnimalUnit(arg) {}
+
+AnimalTurn::~AnimalTurn() = default;
+
+bool AnimalTurn::init_(sead::Heap* heap) {
+    return PlayASForAnimalUnit::init_(heap);
+}
+
+void AnimalTurn::enter_(ksys::act::ai::InlineParamPack* params) {
+    PlayASForAnimalUnit::enter_(params);
+}
+
+void AnimalTurn::leave_() {
+    PlayASForAnimalUnit::leave_();
+}
+
+void AnimalTurn::loadParams_() {
+    PlayASForAnimalUnit::loadParams_();
+    getStaticParam(&mAnimPlayRate_s, "AnimPlayRate");
+    getStaticParam(&mFinishAngleRange_s, "FinishAngleRange");
+    getStaticParam(&mRotateAngleMax_s, "RotateAngleMax");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+void AnimalTurn::calc_() {
+    PlayASForAnimalUnit::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimalTurn.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Game/AI/Action/actionPlayASForAnimalUnit.h"
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimalTurn : public PlayASForAnimalUnit {
+    SEAD_RTTI_OVERRIDE(AnimalTurn, PlayASForAnimalUnit)
+public:
+    explicit AnimalTurn(const InitArg& arg);
+    ~AnimalTurn() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x60
+    const float* mAnimPlayRate_s{};
+    // static_param at offset 0x68
+    const float* mFinishAngleRange_s{};
+    // static_param at offset 0x70
+    const float* mRotateAngleMax_s{};
+    // dynamic_param at offset 0x78
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimeDrivenTurn.cpp

@@ -0,0 +1,37 @@
+#include "Game/AI/Action/actionAnimeDrivenTurn.h"
+
+namespace uking::action {
+
+AnimeDrivenTurn::AnimeDrivenTurn(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnimeDrivenTurn::~AnimeDrivenTurn() = default;
+
+bool AnimeDrivenTurn::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnimeDrivenTurn::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnimeDrivenTurn::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnimeDrivenTurn::loadParams_() {
+    getStaticParam(&mAllowChangeableFrame_s, "AllowChangeableFrame");
+    getStaticParam(&mAnimPlayRate_s, "AnimPlayRate");
+    getStaticParam(&mFinishAngleRange_s, "FinishAngleRange");
+    getStaticParam(&mRotateAngleMax_s, "RotateAngleMax");
+    getStaticParam(&mIsIgnoreSameAS_s, "IsIgnoreSameAS");
+    getStaticParam(&mIsAllowAnimeDrivenNoChangeAS_s, "IsAllowAnimeDrivenNoChangeAS");
+    getStaticParam(&mASKeyName_s, "ASKeyName");
+    getStaticParam(&mTargetBone_s, "TargetBone");
+    getDynamicParam(&mTargetPos_d, "TargetPos");
+}
+
+void AnimeDrivenTurn::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnimeDrivenTurn.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiAction.h"
+
+namespace uking::action {
+
+class AnimeDrivenTurn : public ksys::act::ai::Action {
+    SEAD_RTTI_OVERRIDE(AnimeDrivenTurn, ksys::act::ai::Action)
+public:
+    explicit AnimeDrivenTurn(const InitArg& arg);
+    ~AnimeDrivenTurn() override;
+
+    bool init_(sead::Heap* heap) override;
+    void enter_(ksys::act::ai::InlineParamPack* params) override;
+    void leave_() override;
+    void loadParams_() override;
+
+protected:
+    void calc_() override;
+
+    // static_param at offset 0x20
+    const int* mAllowChangeableFrame_s{};
+    // static_param at offset 0x28
+    const float* mAnimPlayRate_s{};
+    // static_param at offset 0x30
+    const float* mFinishAngleRange_s{};
+    // static_param at offset 0x38
+    const float* mRotateAngleMax_s{};
+    // static_param at offset 0x40
+    const bool* mIsIgnoreSameAS_s{};
+    // static_param at offset 0x48
+    const bool* mIsAllowAnimeDrivenNoChangeAS_s{};
+    // static_param at offset 0x50
+    sead::SafeString mASKeyName_s{};
+    // static_param at offset 0x60
+    sead::SafeString mTargetBone_s{};
+    // dynamic_param at offset 0x70
+    sead::Vector3f* mTargetPos_d{};
+};
+
+}  // namespace uking::action

src/Game/AI/Action/actionAnmArmorBindAction.cpp

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

src/Game/AI/Action/actionAnmArmorBindAction.h

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

src/Game/AI/Action/actionAnmBackMove.cpp

@@ -0,0 +1,31 @@
+#include "Game/AI/Action/actionAnmBackMove.h"
+
+namespace uking::action {
+
+AnmBackMove::AnmBackMove(const InitArg& arg) : ksys::act::ai::Action(arg) {}
+
+AnmBackMove::~AnmBackMove() = default;
+
+bool AnmBackMove::init_(sead::Heap* heap) {
+    return ksys::act::ai::Action::init_(heap);
+}
+
+void AnmBackMove::enter_(ksys::act::ai::InlineParamPack* params) {
+    ksys::act::ai::Action::enter_(params);
+}
+
+void AnmBackMove::leave_() {
+    ksys::act::ai::Action::leave_();
+}
+
+void AnmBackMove::loadParams_() {
+    getStaticParam(&mPosReduceRatio_s, "PosReduceRatio");
+    getStaticParam(&mRotReduceRatio_s, "RotReduceRatio");
+    getStaticParam(&mASName_s, "ASName");
+}
+
+void AnmBackMove::calc_() {
+    ksys::act::ai::Action::calc_();
+}
+
+}  // namespace uking::action