ksys/res: Start adding AttCheck

Most of the check() functions are unimplemented because they require
doing more physics/collision stuff.

src/KingSystem/ActorSystem/actActorParamMgr.cpp

@@ -12,7 +12,6 @@
 #include "KingSystem/Resource/resResourceAnimInfo.h"
 #include "KingSystem/Resource/resResourceArchive.h"
 #include "KingSystem/Resource/resResourceAttClient.h"
-#include "KingSystem/Resource/resResourceAttClientList.h"
 #include "KingSystem/Resource/resResourceAwareness.h"
 #include "KingSystem/Resource/resResourceBoneControl.h"
 #include "KingSystem/Resource/resResourceChemical.h"

src/KingSystem/Resource/CMakeLists.txt

@@ -148,10 +148,10 @@ target_sources(uking PRIVATE
   resResourceASResourceExtension.h
   resResourceASSetting.cpp
   resResourceASSetting.h
+  resResourceAttCheck.cpp
+  resResourceAttCheck.h
   resResourceAttClient.cpp
   resResourceAttClient.h
-  resResourceAttClientList.cpp
-  resResourceAttClientList.h
   resResourceArchive.cpp
   resResourceArchive.h
   resResourceAwareness.cpp

src/KingSystem/Resource/resResourceAttCheck.cpp

@@ -0,0 +1,200 @@
+#include "KingSystem/Resource/resResourceAttCheck.h"
+
+namespace ksys::res {
+
+void AttCheck::m4() {}
+
+bool AttCheck::check() {
+    return true;
+}
+
+float AttCheck::m6() {
+    return -1.0;
+}
+
+bool AttCheckLine::parse(const CreateArg& arg) {
+    mRadius.init(0.0, "Radius", "半径", "Min=0,Max=10", &mObj);
+    mAsLineOfSight.init(false, "AsLineOfSight", "視線を透かすコリジョンを無視する", "", &mObj);
+    return true;
+}
+
+bool AttCheckArea::parse(const CreateArg& arg) {
+    mAttPos.init(&mObj);
+    mFromPlayer.init(false, "FromPlayer", "目標側基準", "", &mObj);
+    return true;
+}
+
+bool AttCheckAreaSphere::parse(const CreateArg& arg) {
+    mForceEditModelArea.init(false, "ForceEditModelArea", "(モデル範囲)強制編集", "", &mObj);
+    mRadius.init(0.0, "Radius", "(モデル範囲)半径", "Min=0.f,Max=100.f", &mObj);
+    mFixedRadius.init(-1.0, "FixedRadius", "(アテンション範囲)半径", "Min=-1.f,Max=100.f", &mObj);
+    mForceEditMargin.init(false, "ForceEditMargin", "(あそびの範囲)強制編集", "", &mObj);
+    mMarginRadius.init(1.0, "MarginRadius", "(あそびの範囲)半径", "Min=0.f,Max=100.f", &mObj);
+    return AttCheckArea::parse(arg);
+}
+
+bool AttCheckAreaFan::parse(const CreateArg& arg) {
+    mAngleCheckIgnoreLockOn.init(false, "AngleCheckIgnoreLockOn", "ロックオン時も角度チェック有効",
+                                 "", &mObj);
+    mForceEditModelArea.init(false, "ForceEditModelArea", "(モデル範囲)強制編集", "", &mObj);
+    mRadius.init(0.0, "Radius", "(モデル範囲)半径", "Min=0.f,Max=100.f", &mObj);
+    mTop.init(0.0, "Top", "(モデル範囲)上辺", "Min=-100.f,Max=100.f", &mObj);
+    mBottom.init(0.0, "Bottom", "(モデル範囲)下辺", "Min=-100.f,Max=100.f", &mObj);
+    mAngle.init(0.0, "Angle", "(アテンション範囲)角度", "Min=0.f,Max=3.1415f", &mObj);
+    mFixedRadius.init(-1.0, "FixedRadius", "(アテンション範囲)半径", "Min=-1.f,Max=100.f", &mObj);
+    mFixedTop.init(-1.0, "FixedTop", "(アテンション範囲)上辺", "Min=-1.f,Max=100.f", &mObj);
+    mFixedBottom.init(-1.0, "FixedBottom", "(アテンション範囲)下辺", "Min=-1.f,Max=100.f", &mObj);
+    mForceEditMargin.init(false, "ForceEditMargin", "(あそびの範囲)強制編集", "", &mObj);
+    mMarginRadius.init(1.0, "MarginRadius", "(あそびの範囲)半径", "Min=0.f,Max=100.f", &mObj);
+    mMarginTop.init(1.0, "MarginTop", "(あそびの範囲)上辺", "Min=0.f,Max=100.f", &mObj);
+    mMarginBottom.init(1.0, "MarginBottom", "(あそびの範囲)下辺", "Min=0.f,Max=100.f", &mObj);
+    return AttCheckArea::parse(arg);
+}
+
+bool AttCheckAreaCylinderFan::parse(const CreateArg& arg) {
+    mAngleCheckIgnoreLockOn.init(false, "AngleCheckIgnoreLockOn", "ロックオン時も角度チェック有効",
+                                 "", &mObj);
+    mForceEditModelArea.init(false, "ForceEditModelArea", "(モデル範囲)強制編集", "", &mObj);
+    mRadius.init(0.0, "Radius", "(モデル範囲)半径", "Min=0.f,Max=100.f", &mObj);
+    mTop.init(0.0, "Top", "(モデル範囲)上辺", "Min=-100.f,Max=100.f", &mObj);
+    mBottom.init(0.0, "Bottom", "(モデル範囲)下辺", "Min=-100.f,Max=100.f", &mObj);
+    mAngle.init(0.0, "Angle", "(アテンション範囲)角度", "Min=0.f,Max=3.1415f", &mObj);
+    mFixedRadiusCylinder.init(-1.0, "FixedRadiusCylinder", "(アテンション範囲)円柱の半径",
+                              "Min=-1.f,Max=100.f", &mObj);
+    mFixedRadiusFan.init(-1.0, "FixedRadiusFan", "(アテンション範囲)扇形の半径",
+                         "Min=-1.f,Max=100.f", &mObj);
+    mFixedTop.init(-1.0, "FixedTop", "(アテンション範囲)上辺", "Min=-1.f,Max=100.f", &mObj);
+    mFixedBottom.init(-1.0, "FixedBottom", "(アテンション範囲)下辺", "Min=-1.f,Max=100.f", &mObj);
+    mForceEditMargin.init(false, "ForceEditMargin", "(あそびの範囲)強制編集", "", &mObj);
+    mMarginRadiusCylinder.init(1.0, "MarginRadiusCylinder", "(あそびの範囲)円柱の半径",
+                               "Min=0.f,Max=100.f", &mObj);
+    mMarginRadiusFan.init(1.0, "MarginRadiusFan", "(あそびの範囲)扇形の半径", "Min=0.f,Max=100.f",
+                          &mObj);
+    mMarginTop.init(1.0, "MarginTop", "(あそびの範囲)上辺", "Min=0.f,Max=100.f", &mObj);
+    mMarginBottom.init(1.0, "MarginBottom", "(あそびの範囲)下辺", "Min=0.f,Max=100.f", &mObj);
+    return AttCheckArea::parse(arg);
+}
+
+bool AttCheckAreaBox::parse(const CreateArg& arg) {
+    mForceEditModelArea.init(false, "ForceEditModelArea", "(モデル範囲)強制編集", "", &mObj);
+    mMin.init(sead::Vector3f::zero, "Min", "(モデル範囲)最小", "Min=-100.f,Max=100.f", &mObj);
+    mMax.init(sead::Vector3f::zero, "Max", "(モデル範囲)最大", "Min=-100.f,Max=100.f", &mObj);
+    mFixedMin.init(-1 * sead::Vector3f::ones, "FixedMin", "(アテンション範囲)最小",
+                   "Min=-1.f,Max=100.f", &mObj);
+    mFixedMax.init(-1 * sead::Vector3f::ones, "FixedMax", "(アテンション範囲)最大",
+                   "Min=-1.f,Max=100.f", &mObj);
+    mForceEditMargin.init(false, "ForceEditMargin", "(あそびの範囲)強制編集", "", &mObj);
+    mMarginMin.init(sead::Vector3f::ones, "MarginMin", "(あそびの範囲)最小", "Min=-100.f,Max=100.f",
+                    &mObj);
+    mMarginMax.init(sead::Vector3f::ones, "MarginMax", "(あそびの範囲)最大", "Min=-100.f,Max=100.f",
+                    &mObj);
+    return AttCheckArea::parse(arg);
+}
+
+AttCheckEachOtherArea::AttCheckEachOtherArea(AttCheckType type) : AttCheck(type) {}
+
+bool AttCheckEachOtherArea::parse(const CreateArg& arg) {
+    mForceEditModelArea.init(false, "ForceEditModelArea", "(モデル範囲)強制編集", "", &mObj);
+    mRadius.init(0.0, "Radius", "(モデル範囲)半径", "Min=0.f,Max=100.f", &mObj);
+    mTop.init(0.0, "Top", "(モデル範囲)上辺", "Min=-100.f,Max=100.f", &mObj);
+    mBottom.init(0.0, "Bottom", "(モデル範囲)下辺", "Min=-100.f,Max=100.f", &mObj);
+    mFixedRadius.init(-1.0, "FixedRadius", "(アテンション範囲)半径", "Min=-1.f,Max=100.f", &mObj);
+    mFixedTop.init(-1.0, "FixedTop", "(アテンション範囲)上辺", "Min=-1.f,Max=100.f", &mObj);
+    mFixedBottom.init(-1.0, "FixedBottom", "(アテンション範囲)下辺", "Min=-1.f,Max=100.f", &mObj);
+    mForceEditMargin.init(false, "ForceEditMargin", "(あそびの範囲)強制編集", "", &mObj);
+    mMarginRadius.init(1.0, "MarginRadius", "(あそびの範囲)半径", "Min=0.f,Max=100.f", &mObj);
+    mMarginTop.init(1.0, "MarginTop", "(あそびの範囲)上辺", "Min=0.f,Max=100.f", &mObj);
+    mMarginBottom.init(1.0, "MarginBottom", "(あそびの範囲)下辺", "Min=0.f,Max=100.f", &mObj);
+    mOffsetTop.init(0.0, "OffsetTop", "(アテンションを出される側の範囲オフセット)上辺",
+                    "Min=-100,Max=100", &mObj);
+    mOffsetBottom.init(0.0, "OffsetBottom", "(アテンションを出される側の範囲オフセット)下辺",
+                       "Min=-100,Max=100", &mObj);
+    return AttCheck::parse(arg);
+}
+
+bool AttCheckAngle::parse(const CreateArg& arg) {
+    mAttPos.init(&mObj);
+    mAngle.init(0.0, "Angle", "角度", "Min=0.f,Max=3.1415f", &mObj);
+    return AttCheck::parse(arg);
+}
+
+bool AttCheck::parse(const CreateArg& arg) {
+    return true;
+}
+
+namespace {
+struct AttCheckFactory {
+    const char* name;
+    AttCheck* (*make)(AttCheckType type, sead::Heap* heap);
+};
+
+template <typename T>
+static constexpr AttCheckFactory makeFactory(const char* name) {
+    AttCheckFactory factory{};
+    factory.name = name;
+    factory.make = [](AttCheckType type, sead::Heap* heap) -> AttCheck* {
+        return new (heap) T(type);
+    };
+    return factory;
+}
+
+sead::SafeArray<AttCheckFactory, 19> sFactories{{
+    makeFactory<AttCheckLine>("Line"),
+    makeFactory<AttCheckScreen>("Screen"),
+    makeFactory<AttCheckAreaSphere>("AreaSphere"),
+    makeFactory<AttCheckAreaFan>("AreaFan"),
+    makeFactory<AttCheckAreaCylinderFan>("AreaCylinderFan"),
+    makeFactory<AttCheckAreaBox>("AreaBox"),
+    makeFactory<AttCheckEachOtherArea>("EachOtherArea"),
+    makeFactory<AttCheckAngle>("Angle"),
+    makeFactory<AttCheckWeight>("Weight"),
+    makeFactory<AttCheckRideHorse>("RideHorse"),
+    makeFactory<AttCheckRideSpace>("RideSpace"),
+    makeFactory<AttCheckSwim>("Swim"),
+    makeFactory<AttCheckCarry>("Carry"),
+    makeFactory<AttCheckNoCarry>("NoCarry"),
+    makeFactory<AttCheckGrab>("Grab"),
+    makeFactory<AttCheckBootFirstTower>("BootFirstTower"),
+    makeFactory<AttCheckFireContact>("FireContact"),
+    makeFactory<AttCheckCharacterOn>("CharacterOn"),
+    makeFactory<AttCheckUnderWater>("UnderWater"),
+}};
+}  // namespace
+
+AttCheck* AttCheck::make(const CreateArg& arg) {
+    const auto Parameters = agl::utl::getResParameterObj(arg.res_list, "Parameters");
+    if (!Parameters)
+        return nullptr;
+
+    int type = sFactories.size();
+    const auto CheckType = agl::utl::getResParameter(Parameters, "CheckType");
+    const sead::SafeString check_type_str = CheckType.getData<char>();
+    for (int i = 0; i < sFactories.size(); ++i) {
+        if (check_type_str == sFactories[i].name) {
+            type = i;
+            break;
+        }
+    }
+
+    if (type == sFactories.size())
+        return nullptr;
+
+    auto* check = sFactories[type].make(AttCheckType(type), arg.heap);
+    if (!check)
+        return nullptr;
+
+    if (!check->init(arg)) {
+        delete check;
+        return nullptr;
+    }
+
+    return check;
+}
+
+bool AttCheck::init(const AttCheck::CreateArg& arg) {
+    mList.addObj(&mObj, "Parameters");
+    mUserData = arg.user_data;
+    return parse(arg);
+}
+
+}  // namespace ksys::res

src/KingSystem/Resource/resResourceAttCheck.h

@@ -0,0 +1,326 @@
+#pragma once
+
+#include <agl/Utils/aglParameter.h>
+#include <agl/Utils/aglParameterList.h>
+#include <agl/Utils/aglParameterObj.h>
+#include <prim/seadRuntimeTypeInfo.h>
+#include "KingSystem/Resource/resResourceAttClient.h"
+
+namespace ksys::res {
+
+enum class AttCheckType {
+    Line,
+    Screen,
+    AreaSphere,
+    AreaFan,
+    AreaCylinderFan,
+    AreaBox,
+    EachOtherArea,
+    Angle,
+    Weight,
+    RideHorse,
+    RideSpace,
+    Swim,
+    Carry,
+    NoCarry,
+    Grab,
+    BootFirstTower,
+    FireContact,
+    CharacterOn,
+    UnderWater,
+};
+
+class AttCheck {
+    SEAD_RTTI_BASE(AttCheck)
+public:
+    struct CreateArg {
+        agl::utl::ResParameterList res_list;
+        sead::Heap* heap;
+        void* user_data;
+    };
+
+    static AttCheck* make(const CreateArg& arg);
+
+    explicit AttCheck(AttCheckType type) : mType{type} {}
+    virtual ~AttCheck() = default;
+
+    // FIXME: signatures and names
+    virtual void m4();
+    virtual bool check();
+    virtual float m6();
+    virtual void m7() {}
+
+    virtual bool parse(const CreateArg& arg);
+
+protected:
+    bool init(const CreateArg& arg);
+
+    void* mUserData = nullptr;
+    AttCheckType mType{};
+    agl::utl::ParameterObj mObj;
+    agl::utl::ParameterList mList;
+};
+
+class AttCheckLine : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckLine, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+    bool parse(const CreateArg& arg) override;
+
+private:
+    agl::utl::Parameter<float> mRadius;
+    agl::utl::Parameter<bool> mAsLineOfSight;
+};
+
+class AttCheckScreen : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckScreen, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckArea : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckArea, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    void m4() override;
+    bool check() override;
+    float m6() override;
+    void m7() override;
+    bool parse(const CreateArg& arg) override;
+
+    virtual bool m9() { return true; }
+    virtual float m10() { return 0; }
+    virtual void m11() {}
+
+protected:
+    AttPos mAttPos;
+    agl::utl::Parameter<bool> mFromPlayer;
+};
+
+class AttCheckAreaSphere : public AttCheckArea {
+    SEAD_RTTI_OVERRIDE(AttCheckAreaSphere, AttCheckArea)
+public:
+    using AttCheckArea::AttCheckArea;
+
+    bool parse(const CreateArg& arg) override;
+    bool m9() override;
+    float m10() override;
+    void m11() override;
+
+private:
+    agl::utl::Parameter<bool> mForceEditModelArea;
+    agl::utl::Parameter<float> mRadius;
+    agl::utl::Parameter<float> mFixedRadius;
+    agl::utl::Parameter<bool> mForceEditMargin;
+    agl::utl::Parameter<float> mMarginRadius;
+};
+
+class AttCheckAreaFan : public AttCheckArea {
+    SEAD_RTTI_OVERRIDE(AttCheckAreaFan, AttCheckArea)
+public:
+    using AttCheckArea::AttCheckArea;
+
+    bool parse(const CreateArg& arg) override;
+    bool m9() override;
+    float m10() override;
+    void m11() override;
+
+private:
+    agl::utl::Parameter<bool> mAngleCheckIgnoreLockOn;
+    agl::utl::Parameter<bool> mForceEditModelArea;
+    agl::utl::Parameter<float> mRadius;
+    agl::utl::Parameter<float> mAngle;
+    agl::utl::Parameter<float> mTop;
+    agl::utl::Parameter<float> mBottom;
+    agl::utl::Parameter<float> mMarginRadius;
+    agl::utl::Parameter<float> mMarginTop;
+    agl::utl::Parameter<float> mMarginBottom;
+    agl::utl::Parameter<bool> mForceEditMargin;
+    agl::utl::Parameter<float> mFixedRadius;
+    agl::utl::Parameter<float> mFixedTop;
+    agl::utl::Parameter<float> mFixedBottom;
+};
+
+class AttCheckAreaCylinderFan : public AttCheckArea {
+    SEAD_RTTI_OVERRIDE(AttCheckAreaCylinderFan, AttCheckArea)
+public:
+    using AttCheckArea::AttCheckArea;
+
+    bool parse(const CreateArg& arg) override;
+    bool m9() override;
+    float m10() override;
+
+private:
+    agl::utl::Parameter<bool> mAngleCheckIgnoreLockOn;
+    agl::utl::Parameter<bool> mForceEditModelArea;
+    agl::utl::Parameter<float> mRadius;
+    agl::utl::Parameter<float> mTop;
+    agl::utl::Parameter<float> mBottom;
+    agl::utl::Parameter<float> mAngle;
+    agl::utl::Parameter<float> mFixedRadiusCylinder;
+    agl::utl::Parameter<float> mFixedRadiusFan;
+    agl::utl::Parameter<float> mFixedTop;
+    agl::utl::Parameter<float> mFixedBottom;
+    agl::utl::Parameter<bool> mForceEditMargin;
+    agl::utl::Parameter<float> mMarginRadiusCylinder;
+    agl::utl::Parameter<float> mMarginRadiusFan;
+    agl::utl::Parameter<float> mMarginTop;
+    agl::utl::Parameter<float> mMarginBottom;
+};
+
+class AttCheckAreaBox : public AttCheckArea {
+    SEAD_RTTI_OVERRIDE(AttCheckAreaBox, AttCheckArea)
+public:
+    explicit AttCheckAreaBox(AttCheckType type) : AttCheckArea(type) {}
+
+    bool parse(const CreateArg& arg) override;
+    bool m9() override;
+    float m10() override;
+    void m11() override;
+
+private:
+    agl::utl::Parameter<bool> mForceEditModelArea;
+    agl::utl::Parameter<sead::Vector3f> mMin;
+    agl::utl::Parameter<sead::Vector3f> mMax;
+    agl::utl::Parameter<sead::Vector3f> mFixedMin;
+    agl::utl::Parameter<sead::Vector3f> mFixedMax;
+    agl::utl::Parameter<bool> mForceEditMargin;
+    agl::utl::Parameter<sead::Vector3f> mMarginMin;
+    agl::utl::Parameter<sead::Vector3f> mMarginMax;
+};
+
+class AttCheckEachOtherArea : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckEachOtherArea, AttCheck)
+public:
+    explicit AttCheckEachOtherArea(AttCheckType type);
+
+    void m4() override;
+    bool check() override;
+    float m6() override;
+    void m7() override;
+    bool parse(const CreateArg& arg) override;
+
+private:
+    agl::utl::Parameter<bool> mForceEditModelArea;
+    agl::utl::Parameter<float> mRadius;
+    agl::utl::Parameter<float> mTop;
+    agl::utl::Parameter<float> mBottom;
+    agl::utl::Parameter<bool> mForceEditMargin;
+    agl::utl::Parameter<float> mMarginRadius;
+    agl::utl::Parameter<float> mMarginTop;
+    agl::utl::Parameter<float> mMarginBottom;
+    agl::utl::Parameter<float> mFixedRadius;
+    agl::utl::Parameter<float> mFixedTop;
+    agl::utl::Parameter<float> mFixedBottom;
+    agl::utl::Parameter<float> mOffsetTop;
+    agl::utl::Parameter<float> mOffsetBottom;
+};
+
+class AttCheckAngle : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckAngle, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    void m4() override;
+    bool check() override;
+    bool parse(const CreateArg& arg) override;
+
+private:
+    AttPos mAttPos;
+    agl::utl::Parameter<float> mAngle;
+};
+
+class AttCheckWeight : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckWeight, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckRideHorse : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckRideHorse, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckRideSpace : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckRideSpace, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckSwim : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckSwim, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckCarry : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckCarry, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckNoCarry : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckNoCarry, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckGrab : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckGrab, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckBootFirstTower : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckBootFirstTower, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckFireContact : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckFireContact, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckCharacterOn : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckCharacterOn, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+class AttCheckUnderWater : public AttCheck {
+    SEAD_RTTI_OVERRIDE(AttCheckUnderWater, AttCheck)
+public:
+    using AttCheck::AttCheck;
+
+    bool check() override;
+};
+
+}  // namespace ksys::res

src/KingSystem/Resource/resResourceAttClient.cpp

@@ -1,3 +1,22 @@
 #include "KingSystem/Resource/resResourceAttClient.h"
 
-namespace ksys::res {}  // namespace ksys::res
+namespace ksys::res {
+
+AttClient::~AttClient() {
+    // TODO
+    mChecks.freeBuffer();
+}
+
+void AttClient::doCreate_(u8*, u32, sead::Heap*) {}
+
+AttPos::AttPos() = default;
+
+void AttPos::init(agl::utl::IParameterObj* obj, const char* node_key, const char* offset_key,
+                  const char* rotate_key, const char* y_rot_only_key) {
+    node.init("", node_key, "ノード", "", obj);
+    offset.init(sead::Vector3f::zero, offset_key, "オフセット", "Min=-100.f,Max=100.f", obj);
+    rotate.init(sead::Vector3f::zero, rotate_key, "回転", "Min=-3.1415f,Max=3.1415f", obj);
+    y_rot_only.init(false, y_rot_only_key, "Ｙ軸回転のみ有効", "", obj);
+}
+
+}  // namespace ksys::res

src/KingSystem/Resource/resResourceAttClient.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <agl/Utils/aglParameter.h>
+#include <agl/Utils/aglParameterList.h>
 #include <agl/Utils/aglParameterObj.h>
 #include <container/seadBuffer.h>
 #include <prim/seadSafeString.h>
@@ -11,6 +12,22 @@
 
 namespace ksys::res {
 
+struct AttPos {
+    AttPos();
+
+    void init(agl::utl::IParameterObj* obj, const char* node_key = "Node",
+              const char* offset_key = "Offset", const char* rotate_key = "Rotate",
+              const char* y_rot_only_key = "YRotOnly");
+
+    // TODO: more functions
+
+    agl::utl::Parameter<sead::SafeString> node;
+    agl::utl::Parameter<sead::Vector3f> offset;
+    agl::utl::Parameter<sead::Vector3f> rotate;
+    agl::utl::Parameter<bool> y_rot_only;
+};
+KSYS_CHECK_SIZE_NX150(AttPos, 0x98);
+
 class AttClient : public ParamIO, public Resource {
     SEAD_RTTI_OVERRIDE(AttClient, Resource)
 public:
@@ -25,7 +42,7 @@ public:
     const sead::SafeString& getPriorityTypeStr() const { return mPriorityTypeStr; }
     const sead::Buffer<Check*>& getChecks() const { return mChecks; }
 
-    void doCreate_(u8*, u32, sead::Heap*) override {}
+    void doCreate_(u8*, u32, sead::Heap*) override;
     bool needsParse() const override { return true; }
     bool parse_(u8* data, size_t size, sead::Heap* heap) override;
 
@@ -42,4 +59,44 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(AttClient, 0x428);
 
+class AttClientList : public ParamIO, public Resource {
+    SEAD_RTTI_OVERRIDE(AttClientList, Resource)
+public:
+    struct Client {
+        const char* getFileName() const { return file_name.ref().cstr(); }
+
+        agl::utl::Parameter<sead::SafeString> name;
+        agl::utl::Parameter<sead::SafeString> file_name;
+        agl::utl::Parameter<bool> is_valid;
+        agl::utl::ParameterObj obj;
+        AttClient* client;
+    };
+    KSYS_CHECK_SIZE_NX150(Client, 0xa8);
+
+    AttClientList() : ParamIO("atcllist", 0) {}
+    ~AttClientList() override;
+    AttClientList(const AttClientList&) = delete;
+    auto operator=(const AttClientList&) = delete;
+
+    const AttPos& getAttPos() const { return mAttPos; }
+    bool isForceEdit() const { return mForceEdit.ref(); }
+    const sead::Buffer<Client>& getClients() const { return mClients; }
+
+    void addClient_(s32 index, AttClient* client) { mClients[index].client = client; }
+
+    void doCreate_(u8* buffer, u32 buffer_size, sead::Heap* heap) override;
+    bool needsParse() const override { return true; }
+    bool parse_(u8* data, size_t size, sead::Heap* heap) override;
+    bool finishParsing_() override;
+    bool m7_() override;
+
+private:
+    agl::utl::ParameterList mAttClientsList;
+    agl::utl::ParameterObj mAttPosObj;
+    AttPos mAttPos;
+    agl::utl::Parameter<bool> mForceEdit;
+    sead::Buffer<Client> mClients;
+};
+KSYS_CHECK_SIZE_NX150(AttClientList, 0x3f0);
+
 }  // namespace ksys::res

src/KingSystem/Resource/resResourceAttClientList.cpp

@@ -1 +0,0 @@
-#include "KingSystem/Resource/resResourceAttClientList.h"

src/KingSystem/Resource/resResourceAttClientList.h

@@ -1,65 +0,0 @@
-#pragma once
-
-#include <agl/Utils/aglParameter.h>
-#include <agl/Utils/aglParameterList.h>
-#include <agl/Utils/aglParameterObj.h>
-#include <container/seadBuffer.h>
-#include "KingSystem/Resource/resResource.h"
-#include "KingSystem/Utils/ParamIO.h"
-#include "KingSystem/Utils/Types.h"
-
-namespace ksys::res {
-
-class AttClient;
-
-class AttClientList : public ParamIO, public Resource {
-    SEAD_RTTI_OVERRIDE(AttClientList, Resource)
-public:
-    struct AttPos {
-        AttPos();
-
-        agl::utl::Parameter<sead::SafeString> _0;
-        agl::utl::Parameter<sead::Vector3f> _28;
-        agl::utl::Parameter<sead::Vector3f> _50;
-        agl::utl::Parameter<bool> _78;
-    };
-    KSYS_CHECK_SIZE_NX150(AttPos, 0x98);
-
-    struct Client {
-        const char* getFileName() const { return file_name.ref().cstr(); }
-
-        agl::utl::Parameter<sead::SafeString> name;
-        agl::utl::Parameter<sead::SafeString> file_name;
-        agl::utl::Parameter<bool> is_valid;
-        agl::utl::ParameterObj obj;
-        AttClient* client;
-    };
-    KSYS_CHECK_SIZE_NX150(Client, 0xa8);
-
-    AttClientList() : ParamIO("atcllist", 0) {}
-    ~AttClientList() override;
-    AttClientList(const AttClientList&) = delete;
-    auto operator=(const AttClientList&) = delete;
-
-    const AttPos& getAttPos() const { return mAttPos; }
-    bool isForceEdit() const { return mForceEdit.ref(); }
-    const sead::Buffer<Client>& getClients() const { return mClients; }
-
-    void addClient_(s32 index, AttClient* client) { mClients[index].client = client; }
-
-    void doCreate_(u8* buffer, u32 buffer_size, sead::Heap* heap) override;
-    bool needsParse() const override { return true; }
-    bool parse_(u8* data, size_t size, sead::Heap* heap) override;
-    bool finishParsing_() override;
-    bool m7_() override;
-
-private:
-    agl::utl::ParameterList mAttClientsList;
-    agl::utl::ParameterObj mAttPosObj;
-    AttPos mAttPos;
-    agl::utl::Parameter<bool> mForceEdit;
-    sead::Buffer<Client> mClients;
-};
-KSYS_CHECK_SIZE_NX150(AttClientList, 0x3f0);
-
-}  // namespace ksys::res