ksys/res: Start implementing ASResource classes

data/uking_functions.csv

@@ -90767,7 +90767,7 @@
 0x00000071011611c8,nullsub_4591,4,
 0x00000071011611cc,nullsub_4592,4,
 0x00000071011611d0,sub_71011611D0,140,_ZNK4sead15RuntimeTypeInfo6DeriveIN4ksys3res13ASParamParserEE9isDerivedEPKNS0_9InterfaceE
-0x000000710116125c,sub_710116125C,140,
+0x000000710116125c,sub_710116125C,140,_ZNK4sead15RuntimeTypeInfo6DeriveIN4ksys3res10ASResourceEE9isDerivedEPKNS0_9InterfaceE
 0x00000071011612e8,sub_71011612E8,140,
 0x0000007101161374,sub_7101161374,140,
 0x0000007101161400,sub_7101161400,140,
@@ -94225,7 +94225,7 @@
 0x000000710125e150,sub_710125E150,8,
 0x000000710125e158,sub_710125E158,92,
 0x000000710125e1b4,sub_710125E1B4,372,
-0x000000710125e328,sub_710125E328,140,
+0x000000710125e328,sub_710125E328,140,_ZNK4sead15RuntimeTypeInfo6DeriveIN4ksys3res15ASAssetResourceEE9isDerivedEPKNS0_9InterfaceE
 0x000000710125e3b4,sub_710125E3B4,48,
 0x000000710125e3e4,sub_710125E3E4,72,
 0x000000710125e42c,sub_710125E42C,376,
@@ -94254,7 +94254,7 @@
 0x000000710125faac,sub_710125FAAC,288,
 0x000000710125fbcc,sub_710125FBCC,92,
 0x000000710125fc28,sub_710125FC28,36,
-0x000000710125fc4c,sub_710125FC4C,140,
+0x000000710125fc4c,sub_710125FC4C,140,_ZNK4sead15RuntimeTypeInfo6DeriveIN4ksys3res22ASResourceWithChildrenEE9isDerivedEPKNS0_9InterfaceE
 0x000000710125fcd8,sub_710125FCD8,48,
 0x000000710125fd08,sub_710125FD08,296,
 0x000000710125fe30,sub_710125FE30,168,
@@ -96482,67 +96482,67 @@
 0x00000071012ed128,sub_71012ED128,92,_ZThn632_NK4ksys3res8AnimInfo18getRuntimeTypeInfoEv
 0x00000071012ed184,sub_71012ED184,8,_ZThn632_NK4ksys3res8AnimInfo10needsParseEv
 0x00000071012ed18c,sub_71012ED18C,372,_ZN4ksys3res8AnimInfo33checkDerivedRuntimeTypeInfoStaticEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012ed300,sub_71012ED300,104,
+0x00000071012ed300,sub_71012ED300,104,_ZN4ksys3res10ASResource5parseERKNS1_9ParseArgsE
 0x00000071012ed368,sub_71012ED368,32,
 0x00000071012ed388,sub_71012ED388,32,
-0x00000071012ed3a8,sub_71012ED3A8,628,
+0x00000071012ed3a8,sub_71012ED3A8,628,_ZNK4ksys3res10ASResource15findStringIndexERKN4sead14SafeStringBaseIcEE
-0x00000071012ed61c,sub_71012ED61C,12,
+0x00000071012ed61c,sub_71012ED61C,12,_ZN4ksys3res10ASResource13getDefaultStrEv
-0x00000071012ed628,sub_71012ED628,240,
+0x00000071012ed628,sub_71012ED628,240,_ZNK4ksys3res10ASResource12findIntIndexEi
-0x00000071012ed718,sub_71012ED718,104,
+0x00000071012ed718,sub_71012ED718,104,_ZN4ksys3res22ASResourceWithChildrenD1Ev
-0x00000071012ed780,sub_71012ED780,92,
+0x00000071012ed780,sub_71012ED780,92,_ZN4ksys3res22ASResourceWithChildrenD0Ev
-0x00000071012ed7dc,sub_71012ED7DC,392,
+0x00000071012ed7dc,sub_71012ED7DC,392,_ZN4ksys3res22ASResourceWithChildren7doParseERKNS0_10ASResource9ParseArgsE?
-0x00000071012ed964,sub_71012ED964,216,
+0x00000071012ed964,sub_71012ED964,216,_ZN4ksys3res22ASResourceWithChildren15callOnChildren_EMNS0_10ASResourceEFivE
-0x00000071012eda3c,sub_71012EDA3C,172,
+0x00000071012eda3c,sub_71012EDA3C,172,_ZN4ksys3res31ASSequencePlayContainerResource7doParseERKNS0_10ASResource9ParseArgsE
-0x00000071012edae8,sub_71012EDAE8,224,
+0x00000071012edae8,sub_71012EDAE8,224,_ZN4ksys3res31ASSequencePlayContainerResource15callOnChildren_EMNS0_10ASResourceEFivE
-0x00000071012edbc8,sub_71012EDBC8,220,
+0x00000071012edbc8,sub_71012EDBC8,220,_ZN4ksys3res31ASSequencePlayContainerResource2m7Ev
-0x00000071012edca4,sub_71012EDCA4,196,
+0x00000071012edca4,sub_71012EDCA4,196,_ZNK4ksys3res31ASSequencePlayContainerResource8getValueEi
-0x00000071012edd68,sub_71012EDD68,232,
+0x00000071012edd68,sub_71012EDD68,232,_ZN4ksys3res18ASSelectorResource7doParseERKNS0_10ASResource9ParseArgsE
-0x00000071012ede50,sub_71012EDE50,224,
+0x00000071012ede50,sub_71012EDE50,224,_ZN4ksys3res18ASSelectorResource15callOnChildren_EMNS0_10ASResourceEFivE
-0x00000071012edf30,sub_71012EDF30,288,
+0x00000071012edf30,sub_71012EDF30,288,_ZN4ksys3res17ASBlenderResource7doParseERKNS0_10ASResource9ParseArgsE
-0x00000071012ee050,sub_71012EE050,340,
+0x00000071012ee050,sub_71012EE050,340,_ZN4ksys3res17ASBlenderResource15callOnChildren_EMNS0_10ASResourceEFivE
-0x00000071012ee1a4,sub_71012EE1A4,168,
+0x00000071012ee1a4,sub_71012EE1A4,168,_ZN4ksys3res15ASAssetResource7doParseERKNS0_10ASResource9ParseArgsE
-0x00000071012ee24c,sub_71012EE24C,356,
+0x00000071012ee24c,sub_71012EE24C,356,_ZN4ksys3res22ASSkeltalAssetResource7doParseERKNS0_10ASResource9ParseArgsE
-0x00000071012ee3b0,sub_71012EE3B0,236,
+0x00000071012ee3b0,sub_71012EE3B0,236,_ZN4ksys3res10ASResource4makeERKNS1_16MakeResourceArgsE
-0x00000071012ee49c,sub_71012EE49C,204,
+0x00000071012ee49c,sub_71012EE49C,204,_ZNK4ksys3res22ASResourceWithChildren27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012ee568,sub_71012EE568,92,
+0x00000071012ee568,sub_71012EE568,92,_ZNK4ksys3res22ASResourceWithChildren18getRuntimeTypeInfoEv
-0x00000071012ee5c4,sub_71012EE5C4,20,
+0x00000071012ee5c4,sub_71012EE5C4,20,_ZN4ksys3res22ASResourceWithChildren2m4Ev
-0x00000071012ee5d8,sub_71012EE5D8,20,
+0x00000071012ee5d8,sub_71012EE5D8,20,_ZN4ksys3res22ASResourceWithChildren2m5Ev
-0x00000071012ee5ec,sub_71012EE5EC,40,
+0x00000071012ee5ec,sub_71012EE5EC,40,_ZN4ksys3res22ASResourceWithChildren2m6Ev
-0x00000071012ee614,sub_71012EE614,8,
+0x00000071012ee614,sub_71012EE614,8,_ZN4ksys3res10ASResource2m7Ev
-0x00000071012ee61c,sub_71012EE61C,288,
+0x00000071012ee61c,sub_71012EE61C,288,_ZNK4ksys3res31ASSequencePlayContainerResource27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012ee73c,sub_71012EE73C,92,
+0x00000071012ee73c,sub_71012EE73C,92,_ZNK4ksys3res31ASSequencePlayContainerResource18getRuntimeTypeInfoEv
-0x00000071012ee798,sub_71012EE798,136,
+0x00000071012ee798,sub_71012EE798,136,_ZN4ksys3res31ASSequencePlayContainerResourceD2Ev
-0x00000071012ee820,sub_71012EE820,124,
+0x00000071012ee820,sub_71012EE820,124,_ZN4ksys3res31ASSequencePlayContainerResourceD0Ev
-0x00000071012ee89c,sub_71012EE89C,288,
+0x00000071012ee89c,sub_71012EE89C,288,_ZNK4ksys3res18ASSelectorResource27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012ee9bc,sub_71012EE9BC,92,
+0x00000071012ee9bc,sub_71012EE9BC,92,_ZNK4ksys3res18ASSelectorResource18getRuntimeTypeInfoEv
-0x00000071012eea18,sub_71012EEA18,140,
+0x00000071012eea18,sub_71012EEA18,140,_ZN4ksys3res18ASSelectorResourceD2Ev
-0x00000071012eeaa4,sub_71012EEAA4,128,
+0x00000071012eeaa4,sub_71012EEAA4,128,_ZN4ksys3res18ASSelectorResourceD0Ev
-0x00000071012eeb24,sub_71012EEB24,288,
+0x00000071012eeb24,sub_71012EEB24,288,_ZNK4ksys3res17ASBlenderResource27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012eec44,sub_71012EEC44,92,
+0x00000071012eec44,sub_71012EEC44,92,_ZNK4ksys3res17ASBlenderResource18getRuntimeTypeInfoEv
-0x00000071012eeca0,sub_71012EECA0,144,
+0x00000071012eeca0,sub_71012EECA0,144,_ZN4ksys3res17ASBlenderResourceD2Ev
-0x00000071012eed30,sub_71012EED30,132,
+0x00000071012eed30,sub_71012EED30,132,_ZN4ksys3res17ASBlenderResourceD0Ev
-0x00000071012eedb4,sub_71012EEDB4,204,
+0x00000071012eedb4,sub_71012EEDB4,204,_ZNK4ksys3res15ASAssetResource27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012eee80,sub_71012EEE80,92,
+0x00000071012eee80,sub_71012EEE80,92,_ZNK4ksys3res15ASAssetResource18getRuntimeTypeInfoEv
-0x00000071012eeedc,sub_71012EEEDC,88,
+0x00000071012eeedc,sub_71012EEEDC,88,_ZN4ksys3res17ASAssetExResourceD0Ev
-0x00000071012eef34,sub_71012EEF34,8,
+0x00000071012eef34,sub_71012EEF34,8,_ZN4ksys3res10ASResource2m4Ev
-0x00000071012eef3c,sub_71012EEF3C,8,
+0x00000071012eef3c,sub_71012EEF3C,8,_ZN4ksys3res10ASResource2m5Ev
-0x00000071012eef44,sub_71012EEF44,8,
+0x00000071012eef44,sub_71012EEF44,8,_ZN4ksys3res10ASResource2m6Ev
-0x00000071012eef4c,sub_71012EEF4C,288,
+0x00000071012eef4c,sub_71012EEF4C,288,_ZNK4ksys3res22ASSkeltalAssetResource27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012ef06c,sub_71012EF06C,92,
+0x00000071012ef06c,sub_71012EF06C,92,_ZNK4ksys3res22ASSkeltalAssetResource18getRuntimeTypeInfoEv
-0x00000071012ef0c8,sub_71012EF0C8,112,
+0x00000071012ef0c8,sub_71012EF0C8,112,_ZN4ksys3res22ASSkeltalAssetResourceD2Ev
-0x00000071012ef138,sub_71012EF138,100,
+0x00000071012ef138,sub_71012EF138,100,_ZN4ksys3res22ASSkeltalAssetResourceD0Ev
 0x00000071012ef19c,sub_71012EF19C,8,
-0x00000071012ef1a4,sub_71012EF1A4,244,
+0x00000071012ef1a4,sub_71012EF1A4,244,_ZN4ksys3res12_GLOBAL__N_115resFactoryImpl_INS0_17ASBlenderResourceEEEPNS0_10ASResourceEiRKNS4_16MakeResourceArgsE
 0x00000071012ef298,sub_71012EF298,84,
-0x00000071012ef2ec,sub_71012EF2EC,220,
+0x00000071012ef2ec,sub_71012EF2EC,220,_ZN4ksys3res12_GLOBAL__N_115resFactoryImpl_INS0_18ASSelectorResourceEEEPNS0_10ASResourceEiRKNS4_16MakeResourceArgsE
 0x00000071012ef3c8,sub_71012EF3C8,84,
 0x00000071012ef41c,sub_71012EF41C,84,
 0x00000071012ef470,sub_71012EF470,84,
-0x00000071012ef4c4,sub_71012EF4C4,240,
+0x00000071012ef4c4,sub_71012EF4C4,240,_ZN4ksys3res12_GLOBAL__N_115resFactoryImpl_INS0_17ASAssetExResourceEEEPNS0_10ASResourceEiRKNS4_16MakeResourceArgsE
 0x00000071012ef5b4,sub_71012EF5B4,84,
 0x00000071012ef608,sub_71012EF608,84,
 0x00000071012ef65c,sub_71012EF65C,84,
-0x00000071012ef6b0,sub_71012EF6B0,136,
+0x00000071012ef6b0,sub_71012EF6B0,136,_ZN4ksys3res12_GLOBAL__N_115resFactoryImpl_INS0_10ASResourceEEEPS3_iRKNS3_16MakeResourceArgsE
 0x00000071012ef738,sub_71012EF738,84,
 0x00000071012ef78c,sub_71012EF78C,84,
 0x00000071012ef7e0,sub_71012EF7E0,84,
@@ -96558,13 +96558,13 @@
 0x00000071012efb28,sub_71012EFB28,84,
 0x00000071012efb7c,sub_71012EFB7C,84,
 0x00000071012efbd0,sub_71012EFBD0,84,
-0x00000071012efc24,sub_71012EFC24,208,
+0x00000071012efc24,sub_71012EFC24,208,_ZN4ksys3res12_GLOBAL__N_115resFactoryImpl_INS0_31ASSequencePlayContainerResourceEEEPNS0_10ASResourceEiRKNS4_16MakeResourceArgsE
 0x00000071012efcf4,sub_71012EFCF4,84,
-0x00000071012efd48,sub_71012EFD48,300,
+0x00000071012efd48,sub_71012EFD48,300,_ZN4ksys3res12_GLOBAL__N_115resFactoryImpl_INS0_22ASSkeltalAssetResourceEEEPNS0_10ASResourceEiRKNS4_16MakeResourceArgsE
 0x00000071012efe74,sub_71012EFE74,84,
 0x00000071012efec8,sub_71012EFEC8,84,
 0x00000071012eff1c,sub_71012EFF1C,84,
-0x00000071012eff70,sub_71012EFF70,160,
+0x00000071012eff70,sub_71012EFF70,160,_ZN4ksys3res12_GLOBAL__N_115resFactoryImpl_INS0_22ASResourceWithChildrenEEEPNS0_10ASResourceEiRKNS4_16MakeResourceArgsE
 0x00000071012f0010,sub_71012F0010,84,
 0x00000071012f0064,sub_71012F0064,84,
 0x00000071012f00b8,sub_71012F00B8,84,
@@ -96573,16 +96573,16 @@
 0x00000071012f01b4,sub_71012F01B4,84,
 0x00000071012f0208,sub_71012F0208,84,
 0x00000071012f025c,sub_71012F025C,84,
-0x00000071012f02b0,sub_71012F02B0,112,
+0x00000071012f02b0,sub_71012F02B0,112,_ZNK4ksys3res10ASResource27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012f0320,sub_71012F0320,92,
+0x00000071012f0320,sub_71012F0320,92,_ZNK4ksys3res10ASResource18getRuntimeTypeInfoEv
-0x00000071012f037c,sub_71012F037C,68,
+0x00000071012f037c,sub_71012F037C,68,_ZN4ksys3res10ASResourceD2Ev
-0x00000071012f03c0,sub_71012F03C0,52,
+0x00000071012f03c0,sub_71012F03C0,52,_ZN4ksys3res10ASResourceD0Ev
-0x00000071012f03f4,sub_71012F03F4,8,
+0x00000071012f03f4,sub_71012F03F4,8,_ZN4ksys3res10ASResource7doParseERKNS1_9ParseArgsE
-0x00000071012f03fc,sub_71012F03FC,288,
+0x00000071012f03fc,sub_71012F03FC,288,_ZNK4ksys3res17ASAssetExResource27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
-0x00000071012f051c,sub_71012F051C,92,
+0x00000071012f051c,sub_71012F051C,92,_ZNK4ksys3res17ASAssetExResource18getRuntimeTypeInfoEv
-0x00000071012f0578,sub_71012F0578,100,
+0x00000071012f0578,sub_71012F0578,100,_ZN4ksys3res15ASAssetResourceD2Ev
-0x00000071012f05dc,sub_71012F05DC,88,
+0x00000071012f05dc,sub_71012F05DC,88,_ZN4ksys3res15ASAssetResourceD0Ev
-0x00000071012f0634,sub_71012F0634,8,
+0x00000071012f0634,sub_71012F0634,8,_ZN4ksys3res17ASAssetExResource2m5Ev
 0x00000071012f063c,sub_71012F063C,708,_ZN4ksys3res17ASFrameCtrlParser5parseERKNS0_13ASParamParser9ParseArgsE
 0x00000071012f0900,sub_71012F0900,1036,_ZN4ksys3res21ASTriggerEventsParser5parseERKNS0_13ASParamParser9ParseArgsE
 0x00000071012f0d0c,sub_71012F0D0C,952,_ZN4ksys3res18ASHoldEventsParser5parseERKNS0_13ASParamParser9ParseArgsE

lib/agl

@@ -1 +1 @@
-Subproject commit e19bb5df959a18aac742395ec993a27d0a571688
+Subproject commit 24e9d779f586bb9ba37aa8b901d458a5e5721b24

src/KingSystem/Resource/CMakeLists.txt

@@ -144,6 +144,8 @@ target_sources(uking PRIVATE
   resResourceASList.h
   resResourceASResource.cpp
   resResourceASResource.h
+  resResourceASResourceExtension.cpp
+  resResourceASResourceExtension.h
   resResourceASSetting.cpp
   resResourceASSetting.h
   resResourceAttClient.cpp

src/KingSystem/Resource/resResourceAS.h

@@ -10,11 +10,11 @@
 
 namespace ksys::res {
 
+class ASResource;
+
 class AS : public ParamIO, public Resource {
     SEAD_RTTI_OVERRIDE(AS, Resource)
 public:
-    struct Element {};
-
     AS();
 
     void doCreate_(u8*, u32, sead::Heap*) override {}
@@ -22,10 +22,16 @@ public:
     bool parse_(u8* data, size_t size, sead::Heap* heap) override;
     void finalize_() override;
 
+    const sead::Buffer<ASResource*>& getElementResources() const { return mElementResources; }
+    const auto& getRandomRateMin() const { return *mRandomRateMin; }
+    const auto& getRandomRateMax() const { return *mRandomRateMax; }
+    const auto& getForbidPartialDemoAs() const { return *mForbidPartialDemoAS; }
+    const auto& getUseIk() const { return *mUseIK; }
+
 private:
     friend class ASList;
 
-    sead::Buffer<Element*> mElements;
+    sead::Buffer<ASResource*> mElementResources;
     agl::utl::ParameterList mElementsList;
 
     agl::utl::ParameterObj mCommonParams;

src/KingSystem/Resource/resResourceASResource.cpp

@@ -1,339 +1,375 @@
 #include "KingSystem/Resource/resResourceASResource.h"
-#include <container/seadSafeArray.h>
+#include <limits>
-#include <optional>
 #include <prim/seadSafeString.h>
-#include "KingSystem/ActorSystem/actASSetting.h"
+#include "KingSystem/Resource/resResourceAS.h"
-#include "KingSystem/Resource/resResourceASSetting.h"
+
+namespace ksys::as {
+class Element;
+}
 
 namespace ksys::res {
 
-bool ASFrameCtrlParser::parse(const ASParamParser::ParseArgs& args) {
+namespace {
-    mRate.init(1.0, "Rate", "再生速度", "Min=0.f,Max=10.f", &mObj);
-    mStartFrame.init(0.0, "StartFrame", "開始フレーム", "Min=0.f,Max=100.f", &mObj);
-    mEndFrame.init(-1.0, "EndFrame", "終了フレーム", "Min=-1.f,Max=100.f", &mObj);
-    mLoopStopCount.init(-1.0, "LoopStopCount", "ループ停止回数", "Min=-1.f,Max=10.f", &mObj);
-    mLoopStopCountRandom.init(0.0, "LoopStopCountRandom", "ランダムループ追加回数",
-                              "Min=0.f,Max=10.f", &mObj);
-    mReversePlay.init(false, "ReversePlay", "逆再生", "", &mObj);
-    mUseGlobalFrame.init(false, "UseGlobalFrame", "グローバルフレーム使う", "", &mObj);
-    mFootType.init(0, "FootType", "足解決", "", &mObj);
-    mConnect.init(false, "Connect", "接続", "", &mObj);
-    mAnmLoop.init(0, "AnmLoop", "ループ設定", "", &mObj);
 
-    mList.addObj(&mObj, "FrameCtrl0");
+struct ASElementFactory {
-    return true;
+    const char* name;
-}
+    ASResource* (*make_res)(int type_index, const ASResource::MakeResourceArgs& args);
+    // FIXME: signature
+    as::Element* (*make)();
+    /// Arbitrary value that is passed to the Element class
+    int value;
+};
 
-bool ASTriggerEventsParser::parse(const ASParamParser::ParseArgs& args) {
+sead::SafeString sStr_default = "default";
-    const int num_objs = args.res_list.getResParameterObjNum();
-    if (num_objs == 0)
-        return true;
-
-    if (!mEvents.tryAllocBuffer(num_objs, args.heap))
-        return false;
-
-    auto it = mEvents.begin();
-    const auto end = mEvents.end();
-
-    sead::FixedSafeString<32> obj_name{"Event"};
-    const auto obj_name_prefix_len = obj_name.calcLength();
-
-    auto res_it = args.res_list.objBegin();
-    const auto res_end = args.res_list.objEnd();
-
-    while (res_it != res_end && it != end) {
-        u32 type_index = -1;
-        const auto TypeIndex = agl::utl::getResParameter(res_it.getObj(), "TypeIndex");
-        if (TypeIndex.ptr())
-            type_index = *TypeIndex.getData<int>();
-
-        // TODO: add a TypeIndex enum
-        it->type_index = type_index > 33 ? 88 : int(type_index) + 54;
-
-        it->frame.init(0.0, "Frame", "フレーム", "Min=0.f,Max=100.f", &it->obj);
-        it->value.init("", "Value", "値", "", &it->obj);
-
-        obj_name.trim(obj_name_prefix_len);
-        obj_name.appendWithFormat("%d", it.getIndex());
-        mList.addObj(&it->obj, obj_name);
-
-        ++res_it;
-        ++it;
-    }
-
-    return true;
-}
-
-bool ASHoldEventsParser::parse(const ASParamParser::ParseArgs& args) {
-    const int num_objs = args.res_list.getResParameterObjNum();
-    if (num_objs == 0)
-        return true;
-
-    if (!mEvents.tryAllocBuffer(num_objs, args.heap))
-        return false;
-
-    auto it = mEvents.begin();
-    const auto end = mEvents.end();
-
-    sead::FixedSafeString<32> obj_name{"Event"};
-    const auto obj_name_prefix_len = obj_name.calcLength();
-
-    auto res_it = args.res_list.objBegin();
-    const auto res_end = args.res_list.objEnd();
-
-    while (res_it != res_end && it != end) {
-        u32 type_index = -1;
-        const auto TypeIndex = agl::utl::getResParameter(res_it.getObj(), "TypeIndex");
-        if (TypeIndex.ptr())
-            type_index = *TypeIndex.getData<int>();
-
-        // TODO: add a TypeIndex enum
-        it->type_index = type_index > 53 ? 88 : int(type_index);
-
-        it->start_frame.init(0.0, "StartFrame", "開始フレーム", "Min=0.f,Max=100.f", &it->obj);
-        it->end_frame.init(0.0, "EndFrame", "終了フレーム", "Min=0.f,Max=100.f", &it->obj);
-        it->value.init("", "Value", "値", "", &it->obj);
-
-        obj_name.trim(obj_name_prefix_len);
-        obj_name.appendWithFormat("%d", it.getIndex());
-        mList.addObj(&it->obj, obj_name);
-
-        ++res_it;
-        ++it;
-    }
-
-    return true;
-}
-
-bool ASStringArrayParser::parse(const ASParamParser::ParseArgs& args) {
-    const int size = args.res_list.getResParameterObj(0).getNum();
-    if (size != 0) {
-        if (!mValues.tryAllocBuffer(size, args.heap))
-            return false;
-
-        sead::FixedSafeString<32> param_name{"Value"};
-        const auto param_name_prefix_len = param_name.calcLength();
-
-        for (int i = 0; i < size; ++i) {
-            param_name.trim(param_name_prefix_len);
-            param_name.appendWithFormat("%d", i);
-            mValues[i].value.init("", param_name, "値", "", &mObj);
-        }
-    }
-
-    mList.addObj(&mObj, "StringArray0");
-    return true;
-}
-
-bool ASRangesParser::parse(const ASParamParser::ParseArgs& args) {
-    const int num_objs = args.res_list.getResParameterObjNum();
-    if (num_objs == 0)
-        return true;
-
-    if (!mRanges.tryAllocBuffer(num_objs, args.heap))
-        return false;
-
-    auto it = mRanges.begin();
-    const auto end = mRanges.end();
-
-    sead::FixedSafeString<32> obj_name{"Range"};
-    const auto obj_name_prefix_len = obj_name.calcLength();
-
-    auto res_it = args.res_list.objBegin();
-    const auto res_end = args.res_list.objEnd();
-
-    while (res_it != res_end && it != end) {
-        obj_name.trim(obj_name_prefix_len);
-        obj_name.appendWithFormat("%d", it.getIndex());
-
-        it->start.init(0.0, "Start", "開始", "Min=0.f,Max=1.f", &it->obj);
-        it->end.init(0.0, "End", "終了", "Min=0.f,Max=1.f", &it->obj);
-
-        mList.addObj(&it->obj, obj_name);
-
-        ++res_it;
-        ++it;
-    }
-
-    return true;
-}
-
-bool ASFloatArrayParser::parse(const ASParamParser::ParseArgs& args) {
-    const int size = args.res_list.getResParameterObj(0).getNum();
-    if (size != 0) {
-        if (!mValues.tryAllocBuffer(size, args.heap))
-            return false;
-
-        sead::FixedSafeString<32> param_name{"Value"};
-        const auto param_name_prefix_len = param_name.calcLength();
-
-        for (int i = 0; i < size; ++i) {
-            param_name.trim(param_name_prefix_len);
-            param_name.appendWithFormat("%d", i);
-            mValues[i].value.init(1.0, param_name, "値", "", &mObj);
-        }
-    }
-
-    mList.addObj(&mObj, "FloatArray0");
-    return true;
-}
-
-bool ASIntArrayParser::parse(const ASParamParser::ParseArgs& args) {
-    const int size = args.res_list.getResParameterObj(0).getNum();
-    if (size != 0) {
-        if (!mValues.tryAllocBuffer(size, args.heap))
-            return false;
-
-        sead::FixedSafeString<32> param_name{"Value"};
-        const auto param_name_prefix_len = param_name.calcLength();
-
-        for (int i = 0; i < size; ++i) {
-            param_name.trim(param_name_prefix_len);
-            param_name.appendWithFormat("%d", i);
-            mValues[i].value.init(1, param_name, "値", "", &mObj);
-        }
-    }
-
-    mList.addObj(&mObj, "IntArray0");
-    return true;
-}
-
-bool ASBitIndexParser::parse(const ASParamParser::ParseArgs& args) {
-    const auto obj = args.res_list.getResParameterObj(0);
-    if (obj.getNum() < 1)
-        return true;
-
-    const auto TypeIndex = agl::utl::getResParameter(obj, "TypeIndex");
-    if (!TypeIndex.ptr())
-        return true;
-
-    mTypeIndex = *TypeIndex.getData<int>();
-    return true;
-}
 
 template <typename T>
-static ASParamParser* factoryImpl_(sead::Heap* heap) {
+ASResource* resFactoryImpl_(int type_index, const ASResource::MakeResourceArgs& arg) {
-    return new (heap) T;
+    return new (arg.heap) T(type_index, arg.index);
 }
 
-static ASParamParser* dummyASParserFactoryImpl_(sead::Heap*) {
+// FIXME: make functions
-    return nullptr;
+sead::SafeArray<ASElementFactory, 107> sFactories{{
-}
+    /* 000 */ {"AbsTemperatureBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 24},
+    /* 001 */ {"AbsTemperatureSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 24},
+    /* 002 */ {"ArmorSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 57},
+    /* 003 */ {"ArrowSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 60},
+    /* 004 */ {"AttentionSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 48},
+    /* 005 */ {"BoneBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 28},
+    /* 006 */ {"BoneVisibilityAsset", resFactoryImpl_<ASAssetExResource>, nullptr, -1},
+    /* 007 */ {"BoolSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 66},
+    /* 008 */ {"ButtonSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 46},
+    /* 009 */ {"ChargeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 42},
 
-namespace {
+    /* 010 */ {"ClearMatAnmAsset", resFactoryImpl_<ASResource>, nullptr, -1},
-struct Factory {
+    /* 011 */ {"ComboSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 43},
-    const char* name;
+    /* 012 */ {"DiffAngleYBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 26},
-    ASParamParser* (*make)(sead::Heap* heap);
+    /* 013 */ {"DiffAngleYSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 26},
-};
+    /* 014 */ {"DirectionAngleBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 9},
+    /* 015 */ {"DirectionAngleSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 9},
+    /* 016 */ {"DistanceBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 16},
+    /* 017 */ {"DistanceSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 16},
+    /* 018 */ {"DungeonClearSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 64},
+    /* 019 */ {"DungeonNumberSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 41},
 
-sead::SafeArray<Factory, ASParamParser::NumTypes> sASFactories{{
+    /* 020 */ {"EmotionSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 55},
-    {"FrameCtrl", factoryImpl_<ASFrameCtrlParser>},
+    /* 021 */ {"EventFlagSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 65},
-    {"TriggerEvents", factoryImpl_<ASTriggerEventsParser>},
+    /* 022 */ {"EyeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 37},
-    {"HoldEvents", factoryImpl_<ASHoldEventsParser>},
+    /* 023 */ {"EyebrowSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 38},
-    {"StringArray", factoryImpl_<ASStringArrayParser>},
+    /* 024 */ {"FaceEmotionSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 56},
-    {"Ranges", factoryImpl_<ASRangesParser>},
+    /* 025 */ {"FootBLLifeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 34},
-    {"FloatArray", factoryImpl_<ASFloatArrayParser>},
+    /* 026 */ {"FootBRLifeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 33},
-    {"IntArray", factoryImpl_<ASIntArrayParser>},
+    /* 027 */ {"FootFLLifeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 32},
-    {"BitIndex", factoryImpl_<ASBitIndexParser>},
+    /* 028 */ {"FootFRLifeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 31},
-    {"BlenderBone", dummyASParserFactoryImpl_},
+    /* 029 */ {"ForwardBentBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 18},
+
+    /* 030 */ {"ForwardBentSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 18},
+    /* 031 */ {"GearSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 64},
+    /* 032 */ {"GenerationSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 35},
+    /* 033 */ {"GrabTypeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 49},
+    /* 034 */ {"GroundNormalBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 21},
+    /* 035 */ {"GroundNormalSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 21},
+    /* 036 */ {"GroundNormalSideBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 22},
+    /* 037 */ {"GroundNormalSideSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 22},
+    /* 038 */ {"MaskSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 58},
+    /* 039 */ {"MatVisibilityAsset", resFactoryImpl_<ASAssetExResource>, nullptr, -1},
+
+    /* 040 */ {"MouthSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 36},
+    /* 041 */ {"NoAnmAsset", resFactoryImpl_<ASResource>, nullptr, -1},
+    /* 042 */ {"NoLoopStickAngleBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 7},
+    /* 043 */ {"NoLoopStickAngleSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 7},
+    /* 044 */ {"NodePosSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 63},
+    /* 045 */ {"PersonalitySelector", resFactoryImpl_<ASSelectorResource>, nullptr, 50},
+    /* 046 */ {"PostureSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 59},
+    /* 047 */ {"PreASSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 51},
+    /* 048 */ {"PreExclusionRandomSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 30},
+    /* 049 */ {"RandomSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 30},
+
+    /* 050 */ {"RideSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 61},
+    /* 051 */ {"RightStickAngleBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 8},
+    /* 052 */ {"RightStickAngleSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 8},
+    /* 053 */ {"RightStickValueBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 3},
+    /* 054 */ {"RightStickValueSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 3},
+    /* 055 */ {"RightStickXBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 4},
+    /* 056 */ {"RightStickXSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 4},
+    /* 057 */ {"RightStickYBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 5},
+    /* 058 */ {"RightStickYSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 5},
+    /* 059 */ {"SelfHeightSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 39},
+
+    /* 060 */ {"SelfWeightSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 40},
+    /* 061 */
+    {"SequencePlayContainer", resFactoryImpl_<ASSequencePlayContainerResource>, nullptr, -1},
+    /* 062 */ {"ShaderParamAsset", resFactoryImpl_<ASAssetExResource>, nullptr, -1},
+    /* 063 */ {"ShaderParamColorAsset", resFactoryImpl_<ASAssetExResource>, nullptr, -1},
+    /* 064 */ {"ShaderParamTexSRTAsset", resFactoryImpl_<ASAssetExResource>, nullptr, -1},
+    /* 065 */ {"SizeBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 17},
+    /* 066 */ {"SizeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 17},
+    /* 067 */ {"SkeltalAsset", resFactoryImpl_<ASSkeltalAssetResource>, nullptr, -1},
+    /* 068 */ {"SpeedBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 19},
+    /* 069 */ {"SpeedSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 19},
+
+    /* 070 */ {"StickAngleBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 6},
+    /* 071 */ {"StickAngleSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 6},
+    /* 072 */ {"StickValueBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 0},
+    /* 073 */ {"StickValueSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 0},
+    /* 074 */ {"StickXBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 1},
+    /* 075 */ {"StickXSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 1},
+    /* 076 */ {"StickYBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 2},
+    /* 077 */ {"StickYSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 2},
+    /* 078 */ {"StressBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 14},
+    /* 079 */ {"StressSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 14},
+
+    /* 080 */ {"SyncPlayContainer", resFactoryImpl_<ASResourceWithChildren>, nullptr, -1},
+    /* 081 */ {"TemperatureBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 23},
+    /* 082 */ {"TemperatureSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 23},
+    /* 083 */ {"TexturePatternAsset", resFactoryImpl_<ASAssetExResource>, nullptr, -1},
+    /* 084 */ {"TimeSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 52},
+    /* 085 */ {"TiredBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 13},
+    /* 086 */ {"TiredSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 13},
+    /* 087 */ {"UseItemSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 62},
+    /* 088 */ {"UserAngle2Blender", resFactoryImpl_<ASBlenderResource>, nullptr, 12},
+    /* 089 */ {"UserAngle2Selector", resFactoryImpl_<ASSelectorResource>, nullptr, 12},
+
+    /* 090 */ {"UserAngleBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 11},
+    /* 091 */ {"UserAngleSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 11},
+    /* 092 */ {"UserSpeedBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 10},
+    /* 093 */ {"UserSpeedSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 10},
+    /* 094 */ {"VariationSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 47},
+    /* 095 */ {"WallAngleBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 15},
+    /* 096 */ {"WallAngleSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 15},
+    /* 097 */ {"WeaponDetailSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 45},
+    /* 098 */ {"WeaponSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 44},
+    /* 099 */ {"WeatherSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 53},
+
+    /* 100 */ {"WeightBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 25},
+    /* 101 */ {"WeightSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 25},
+    /* 102 */ {"WindVelocityBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 27},
+    /* 103 */ {"YSpeedBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 20},
+    /* 104 */ {"YSpeedSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 20},
+    /* 105 */ {"ZEx00ExposureBlender", resFactoryImpl_<ASBlenderResource>, nullptr, 29},
+    /* 106 */ {"ZEx00ExposureSelector", resFactoryImpl_<ASSelectorResource>, nullptr, 29},
 }};
+
 }  // namespace
 
-ASExtensions::~ASExtensions() {
+bool ASResource::parse(const ASResource::ParseArgs& args) {
-    for (auto*& parser : mParsers) {
+    if (!doParse(args))
-        if (parser && parser->getType() != ASParamParser::Type::BlenderBone)
-            delete parser;
-        parser = nullptr;
-    }
-    mParsers.freeBuffer();
-}
-
-bool ASExtensions::parse(const ASExtensions::ParseArgs& args) {
-    const auto Extend = agl::utl::getResParameterList(args.res_list, "Extend");
-    if (!Extend)
-        return true;
-
-    const auto num_extensions = Extend.getResParameterListNum();
-    if (num_extensions == 0)
-        return true;
-
-    if (!mParsers.tryAllocBuffer(num_extensions, args.heap))
         return false;
-    for (int i = 0, n = mParsers.size(); i < n; ++i)
-        mParsers(i) = nullptr;
 
-    auto it = mParsers.begin();
+    ASExtensions::ParseArgs parse_args{};
-    const auto end = mParsers.end();
-
-    ASParamParser::ParseArgs parse_args{};
-    parse_args.list = &mList;
     parse_args.heap = args.heap;
+    parse_args.list = &mList;
+    parse_args.res_list = args.list;
+    return mExtensions.parse(parse_args);
+}
 
-    auto res_it = Extend.listBegin();
+int ASResource::findStringIndex(const sead::SafeString& value) const {
-    const auto res_end = Extend.listEnd();
+    auto* parser = sead::DynamicCast<ASStringArrayParser>(
+        mExtensions.getParser(ASParamParser::Type::StringArray));
 
-    for (; it != end && res_it != res_end; ++it, ++res_it) {
+    if (!parser)
-        parse_args.res_list = res_it.getList();
+        return -1;
-        *it = makeParser(parse_args);
 
-        constexpr int bone = int(ASParamParser::Type::BlenderBone);
+    const u32 size = parser->getValues().size();
-        if (*it == nullptr && parse_args.res_list.getParameterListNameHash() !=
+    if (size == 0)
-                                  agl::utl::ParameterBase::calcHash(sASFactories[bone].name)) {
+        return -1;
+
+    for (u32 i = 0; i < size; ++i) {
+        if (value == *parser->getValues()[i].value)
+            return i;
+    }
+
+    const int default_idx = int(size - 1);
+    if (default_idx < 0)
+        return -1;
+    if (getDefaultStr() == *parser->getValues()[default_idx].value)
+        return default_idx;
+    return -1;
+}
+
+int ASResource::findIntIndex(int value) const {
+    auto* parser =
+        sead::DynamicCast<ASIntArrayParser>(mExtensions.getParser(ASParamParser::Type::IntArray));
+    if (parser) {
+        const u32 size = parser->getValues().size();
+        if (size == 0)
+            return -1;
+
+        for (u32 i = 0; i < size; ++i) {
+            if (*parser->getValues()[i].value == value)
+                return i;
+        }
+
+        const int default_idx = int(size - 1);
+        if (default_idx >= 0 &&
+            *parser->getValues()[default_idx].value == std::numeric_limits<int>::min()) {
+            return default_idx;
+        }
+    }
+    return -1;
+}
+
+const sead::SafeString& ASResource::getDefaultStr() {
+    return sStr_default;
+}
+
+ASResourceWithChildren::~ASResourceWithChildren() {
+    mChildren.freeBuffer();
+}
+
+// NON_MATCHING: getParameterData (redundant uxtw which leads to localised regalloc diffs)
+bool ASResourceWithChildren::doParse(const ASResource::ParseArgs& args) {
+    const auto Children = agl::utl::getResParameterObj(args.list, "Children");
+    if (!Children)
+        return true;
+
+    const auto size = Children.getNum();
+    if (size == 0)
+        return true;
+
+    if (!mChildren.tryAllocBuffer(size, args.heap))
         return false;
-        }
+    for (int i = 0, n = mChildren.size(); i < n; ++i)
+        mChildren(i) = nullptr;
+
+    for (auto it = mChildren.begin(), end = mChildren.end(); it != end; ++it) {
+        const auto idx = *Children.getParameterData<int>(it.getIndex());
+        *it = args.as->getElementResources()[idx];
     }
 
-    args.list->addList(&mList, "Extend");
     return true;
 }
 
-ASParamParser* ASExtensions::makeParser(const ASParamParser::ParseArgs& args) const {
+int ASResourceWithChildren::callOnChildren_(MemberFunction fn) {
-    const auto is_factory = [&args](int i) {
+    int ret = 0;
-        return args.res_list.getParameterListNameHash() ==
+    for (int i = 0; i < mChildren.size(); ++i)
-               agl::utl::ParameterBase::calcHash(sASFactories[i].name);
+        ret += (mChildren[i]->*fn)();
-    };
+    return ret;
-
-    std::optional<int> type;
-    for (int i = 0; i < ASParamParser::NumTypes - 1; ++i) {
-        if (!is_factory(i))
-            continue;
-        type = i;
-        break;
 }
 
-    if (!type.has_value() && is_factory(int(ASParamParser::Type::BlenderBone))) {
+bool ASSequencePlayContainerResource::doParse(const ASResource::ParseArgs& args) {
-        const auto obj = args.res_list.getResParameterObj(0);
+    if (!ASResourceWithChildren::doParse(args))
-        if (obj.getNum() > 0) {
+        return false;
-            const sead::SafeString name = obj.getResParameter(0).getData<const char>();
+
-            return act::ASSetting::instance()->getBoneParams(name);
+    mSequenceLoop.init(false, "SequenceLoop", "シーケンスループ", &mObj);
-        }
+
+    mList.addObj(&mObj, "Parameters");
+    return true;
 }
 
-    if (!type.has_value())
+int ASSequencePlayContainerResource::callOnChildren_(ASResourceWithChildren::MemberFunction fn) {
-        return nullptr;
+    int ret = 0;
+    for (int i = 0; i < mChildren.size(); ++i) {
+        int value = (mChildren[i]->*fn)();
+        if (u32(ret) <= u32(value))
+            ret = value;
+    }
+    return ret;
+}
 
-    const auto& factory = sASFactories[*type];
+int ASSequencePlayContainerResource::m7() {
-
+    auto* parser = sead::DynamicCast<ASFloatArrayParser>(
-    auto* parser = factory.make(args.heap);
+        mExtensions.getParser(ASParamParser::Type::FloatArray));
     if (!parser)
-        return nullptr;
+        return 0;
 
-    if (!parser->parse(args)) {
+    for (int i = 0, n = parser->getValues().size(); i < n; ++i) {
-        delete parser;
+        if (*parser->getValues()[i].value < 1.0)
-        return nullptr;
+            return 1;
+    }
+    return 0;
 }
 
-    args.list->addList(&parser->getList(), factory.name);
+float ASSequencePlayContainerResource::getValue(int index) const {
-    return parser;
+    auto* parser = sead::DynamicCast<ASFloatArrayParser>(
+        mExtensions.getParser(ASParamParser::Type::FloatArray));
+    if (!parser || parser->getValues().size() <= index)
+        return 1.0;
+    return *parser->getValues()[index].value;
 }
 
-ASParamParser* ASExtensions::getParser(ASParamParser::Type type) const {
+bool ASSelectorResource::doParse(const ASResource::ParseArgs& args) {
-    for (int i = 0, n = mParsers.size(); i < n; ++i) {
+    if (!ASResourceWithChildren::doParse(args))
-        auto* parser = mParsers[i];
+        return false;
-        if (parser && parser->getType() == type)
+
-            return parser;
+    mNoSync.init(false, "NoSync", "非同期", &mObj);
+    mJudgeOnce.init(true, "JudgeOnce", "初期化時のみ判定", &mObj);
+
+    mList.addObj(&mObj, "Parameters");
+    return true;
 }
+
+int ASSelectorResource::callOnChildren_(ASResourceWithChildren::MemberFunction fn) {
+    int ret = 0;
+    for (int i = 0; i < mChildren.size(); ++i) {
+        int value = (mChildren[i]->*fn)();
+        if (u32(ret) <= u32(value))
+            ret = value;
+    }
+    return ret;
+}
+
+bool ASBlenderResource::doParse(const ASResource::ParseArgs& args) {
+    if (!ASResourceWithChildren::doParse(args))
+        return false;
+
+    mNoSync.init(false, "NoSync", "非同期", &mObj);
+    mJudgeOnce.init(false, "JudgeOnce", "初期化時のみ判定", &mObj);
+    mInputLimit.init(-1.0, "InputLimit", "入力変化制限", &mObj);
+
+    mList.addObj(&mObj, "Parameters");
+    return true;
+}
+
+int ASBlenderResource::callOnChildren_(ASResourceWithChildren::MemberFunction fn) {
+    if (mChildren.size() == 0)
+        return 0;
+
+    const u32 first = (mChildren[0]->*fn)();
+
+    u32 max = first;
+    u32 previous = first;
+    for (int i = 1; i < mChildren.size(); ++i) {
+        const u32 current = (mChildren[i]->*fn)();
+        if (max <= previous + current)
+            max = previous + current;
+        previous = current;
+    }
+
+    if (max <= first + previous)
+        max = first + previous;
+
+    return max;
+}
+
+bool ASAssetResource::doParse(const ASResource::ParseArgs& args) {
+    mFileName.init("", "FileName", "ファイル名", &mObj);
+
+    mList.addObj(&mObj, "Parameters");
+    return true;
+}
+
+bool ASSkeltalAssetResource::doParse(const ASResource::ParseArgs& args) {
+    ASAssetResource::doParse(args);
+
+    mMorph.init(5.0, "Morph", "補間", "Min=0.f,Max=20.f", &mObj);
+    mResetMorph.init(5.0, "ResetMorph", "リセット時補間", "Min=0.f,Max=20.f", &mObj);
+    mInitAnmDriven.init(false, "InitAnmDriven", "初期アニメドリブン", "", &mObj);
+
+    return true;
+}
+
+ASResource* ASResource::make(const ASResource::MakeResourceArgs& args) {
+    const auto Parameters = agl::utl::getResParameterObj(args.list, "Parameters");
+
+    const auto TypeIndex = agl::utl::getResParameter(Parameters, "TypeIndex");
+    if (!TypeIndex.ptr())
         return nullptr;
+
+    const auto type_index = *TypeIndex.getData<int>();
+    if (u32(type_index) >= u32(sFactories.size()))
+        return nullptr;
+
+    return sFactories[type_index].make_res(type_index, args);
 }
 
 }  // namespace ksys::res

src/KingSystem/Resource/resResourceASResource.h

@@ -1,259 +1,170 @@
 #pragma once
 
-#include <agl/Utils/aglParameter.h>
 #include <agl/Utils/aglParameterList.h>
-#include <agl/Utils/aglParameterObj.h>
 #include <agl/Utils/aglResParameter.h>
-#include <array>
-#include <basis/seadTypes.h>
 #include <container/seadBuffer.h>
 #include <prim/seadRuntimeTypeInfo.h>
-#include "KingSystem/Utils/Types.h"
+#include "KingSystem/Resource/resResourceASResourceExtension.h"
-
-namespace sead {
-class Heap;
-}
 
 namespace ksys::res {
 
-class ASParamParser {
+class AS;
-    SEAD_RTTI_BASE(ASParamParser)
-public:
-    enum class Type {
-        FrameCtrl = 0,
-        TriggerEvents = 1,
-        HoldEvents = 2,
-        StringArray = 3,
-        Ranges = 4,
-        FloatArray = 5,
-        IntArray = 6,
-        BitIndex = 7,
-        BlenderBone = 8,
-    };
-    static constexpr int NumTypes = 9;
 
-    struct ParseArgs {
+class ASResource {
-        agl::utl::ParameterList* list;
+    SEAD_RTTI_BASE(ASResource)
-        agl::utl::ResParameterList res_list;
-        sead::Heap* heap;
-    };
-
-    explicit ASParamParser(Type type) : mType(type) {}
-    virtual ~ASParamParser() = default;
-    virtual bool parse(const ParseArgs& args) { return true; }
-
-    Type getType() const { return mType; }
-    agl::utl::ParameterList& getList() { return mList; }
-    const agl::utl::ParameterList& getList() const { return mList; }
-
-protected:
-    Type mType;
-    agl::utl::ParameterList mList;
-};
-KSYS_CHECK_SIZE_NX150(ASParamParser, 0x58);
-
-class ASExtensions {
 public:
     struct ParseArgs {
-        agl::utl::ResParameterList res_list;
+        agl::utl::ResParameterList list;
-        agl::utl::ParameterList* list;
         sead::Heap* heap;
+        AS* as;
     };
 
-    ASExtensions() = default;
+    struct MakeResourceArgs {
-    ~ASExtensions();
+        agl::utl::ResParameterList list;
-    ASExtensions(const ASExtensions&) = delete;
+        sead::Heap* heap;
-    auto operator=(const ASExtensions&) = delete;
+        void* x;
+        int index;
+    };
 
-    const sead::Buffer<ASParamParser*>& getParsers() const { return mParsers; }
+    ASResource(int type_index, int index) : mTypeIndex(type_index), mIndex(index) {}
-    ASParamParser* getParser(ASParamParser::Type type) const;
+    virtual ~ASResource() = default;
 
     bool parse(const ParseArgs& args);
 
-private:
+    virtual int m4() { return 0; }
-    ASParamParser* makeParser(const ASParamParser::ParseArgs& args) const;
+    virtual int m5() { return 0; }
+    virtual int m6() { return 1; }
+    virtual int m7() { return 0; }
 
+    static const sead::SafeString& getDefaultStr();
+    static ASResource* make(const MakeResourceArgs& args);
+
+    s16 getTypeIndex() const { return mTypeIndex; }
+    s16 getIndex() const { return mIndex; }
+    int findStringIndex(const sead::SafeString& value) const;
+    int findIntIndex(int value) const;
+
+protected:
+    virtual bool doParse(const ParseArgs& args) { return true; }
+
+    s16 mTypeIndex{};
+    s16 mIndex{};
     agl::utl::ParameterList mList;
-    sead::Buffer<ASParamParser*> mParsers;
+    ASExtensions mExtensions;
 };
 
-class ASFrameCtrlParser : public ASParamParser {
+class ASResourceWithChildren : public ASResource {
-    SEAD_RTTI_OVERRIDE(ASFrameCtrlParser, ASParamParser)
+    SEAD_RTTI_OVERRIDE(ASResourceWithChildren, ASResource)
 public:
-    ASFrameCtrlParser() : ASParamParser(Type::FrameCtrl) {}
+    using ASResource::ASResource;
+    ~ASResourceWithChildren() override;
+    ASResourceWithChildren(const ASResourceWithChildren&) = delete;
+    auto operator=(const ASResourceWithChildren&) = delete;
 
-    const auto& getRate() const { return *mRate; }
+    int m4() override { return callOnChildren_(&ASResource::m4); }
-    const auto& getStartFrame() const { return *mStartFrame; }
+    int m5() override { return callOnChildren_(&ASResource::m5); }
-    const auto& getEndFrame() const { return *mEndFrame; }
+    int m6() override { return callOnChildren_(&ASResource::m6) + 1; }
-    const auto& getLoopStopCount() const { return *mLoopStopCount; }
-    const auto& getLoopStopCountRandom() const { return *mLoopStopCountRandom; }
-    const auto& getReversePlay() const { return *mReversePlay; }
-    const auto& getUseGlobalFrame() const { return *mUseGlobalFrame; }
-    const auto& getConnect() const { return *mConnect; }
-    const auto& getFootType() const { return *mFootType; }
-    const auto& getAnmLoop() const { return *mAnmLoop; }
 
-    bool parse(const ParseArgs& args) override;
+protected:
+    using MemberFunction = int (ASResource::*)();
+
+    bool doParse(const ParseArgs& args) override;
+    virtual int callOnChildren_(MemberFunction fn);
+
+    sead::Buffer<ASResource*> mChildren;
+};
+
+class ASSequencePlayContainerResource : public ASResourceWithChildren {
+    SEAD_RTTI_OVERRIDE(ASSequencePlayContainerResource, ASResourceWithChildren)
+public:
+    using ASResourceWithChildren::ASResourceWithChildren;
+
+    const auto& getSequenceLoop() const { return *mSequenceLoop; }
+    float getValue(int index) const;
+
+protected:
+    bool doParse(const ParseArgs& args) override;
+    int callOnChildren_(MemberFunction fn) override;
+    int m7() override;
 
-private:
     agl::utl::ParameterObj mObj;
-    agl::utl::Parameter<float> mRate;
+    agl::utl::Parameter<bool> mSequenceLoop;
-    agl::utl::Parameter<float> mStartFrame;
-    agl::utl::Parameter<float> mEndFrame;
-    agl::utl::Parameter<float> mLoopStopCount;
-    agl::utl::Parameter<float> mLoopStopCountRandom;
-    agl::utl::Parameter<bool> mReversePlay;
-    agl::utl::Parameter<bool> mUseGlobalFrame;
-    agl::utl::Parameter<int> mConnect;
-    agl::utl::Parameter<int> mFootType;
-    agl::utl::Parameter<int> mAnmLoop;
 };
 
-class ASTriggerEventsParser : public ASParamParser {
+class ASSelectorResource : public ASResourceWithChildren {
-    SEAD_RTTI_OVERRIDE(ASTriggerEventsParser, ASParamParser)
+    SEAD_RTTI_OVERRIDE(ASSelectorResource, ASResourceWithChildren)
 public:
-    struct Event {
+    using ASResourceWithChildren::ASResourceWithChildren;
-        agl::utl::ParameterObj obj;
-        int type_index;
-        agl::utl::Parameter<float> frame;
-        agl::utl::Parameter<sead::SafeString> value;
-    };
 
-    ASTriggerEventsParser() : ASParamParser(Type::TriggerEvents) {}
+    const auto& getNoSync() const { return *mNoSync; }
-    ~ASTriggerEventsParser() override { mEvents.freeBuffer(); }
+    const auto& getJudgeOnce() const { return *mJudgeOnce; }
-    ASTriggerEventsParser(const ASTriggerEventsParser&) = delete;
-    auto operator=(const ASTriggerEventsParser&) = delete;
 
-    const sead::Buffer<Event>& getEvents() const { return mEvents; }
+protected:
+    bool doParse(const ParseArgs& args) override;
+    int callOnChildren_(MemberFunction fn) override;
 
-    bool parse(const ParseArgs& args) override;
-
-private:
-    sead::Buffer<Event> mEvents;
-};
-
-class ASHoldEventsParser : public ASParamParser {
-    SEAD_RTTI_OVERRIDE(ASHoldEventsParser, ASParamParser)
-public:
-    struct Event {
-        agl::utl::ParameterObj obj;
-        int type_index;
-        agl::utl::Parameter<float> start_frame;
-        agl::utl::Parameter<float> end_frame;
-        agl::utl::Parameter<sead::SafeString> value;
-    };
-
-    ASHoldEventsParser() : ASParamParser(Type::HoldEvents) {}
-    ~ASHoldEventsParser() override { mEvents.freeBuffer(); }
-    ASHoldEventsParser(const ASHoldEventsParser&) = delete;
-    auto operator=(const ASHoldEventsParser&) = delete;
-
-    const sead::Buffer<Event>& getEvents() const { return mEvents; }
-
-    bool parse(const ParseArgs& args) override;
-
-private:
-    sead::Buffer<Event> mEvents;
-};
-
-class ASStringArrayParser : public ASParamParser {
-    SEAD_RTTI_OVERRIDE(ASStringArrayParser, ASParamParser)
-public:
-    struct Value {
-        agl::utl::Parameter<sead::SafeString> value;
-    };
-
-    ASStringArrayParser() : ASParamParser(Type::StringArray) {}
-    ~ASStringArrayParser() override { mValues.freeBuffer(); }
-    ASStringArrayParser(const ASStringArrayParser&) = delete;
-    auto operator=(const ASStringArrayParser&) = delete;
-
-    const sead::Buffer<Value>& getValues() const { return mValues; }
-
-    bool parse(const ParseArgs& args) override;
-
-private:
     agl::utl::ParameterObj mObj;
-    sead::Buffer<Value> mValues;
+    agl::utl::Parameter<bool> mNoSync;
+    agl::utl::Parameter<bool> mJudgeOnce;
 };
 
-class ASRangesParser : public ASParamParser {
+class ASBlenderResource : public ASResourceWithChildren {
-    SEAD_RTTI_OVERRIDE(ASRangesParser, ASParamParser)
+    SEAD_RTTI_OVERRIDE(ASBlenderResource, ASResourceWithChildren)
 public:
-    struct Range {
+    using ASResourceWithChildren::ASResourceWithChildren;
-        agl::utl::ParameterObj obj;
-        agl::utl::Parameter<float> start;
-        agl::utl::Parameter<float> end;
-    };
 
-    ASRangesParser() : ASParamParser(Type::Ranges) {}
+    const auto& getNoSync() const { return *mNoSync; }
-    ~ASRangesParser() override { mRanges.freeBuffer(); }
+    const auto& getJudgeOnce() const { return *mJudgeOnce; }
-    ASRangesParser(const ASRangesParser&) = delete;
+    const auto& getInputLimit() const { return *mInputLimit; }
-    auto operator=(const ASRangesParser&) = delete;
 
-    const sead::Buffer<Range>& getRanges() const { return mRanges; }
+protected:
+    bool doParse(const ParseArgs& args) override;
+    int callOnChildren_(MemberFunction fn) override;
 
-    bool parse(const ParseArgs& args) override;
-
-private:
-    sead::Buffer<Range> mRanges;
-};
-
-class ASFloatArrayParser : public ASParamParser {
-    SEAD_RTTI_OVERRIDE(ASFloatArrayParser, ASParamParser)
-public:
-    struct Value {
-        agl::utl::Parameter<float> value;
-    };
-
-    ASFloatArrayParser() : ASParamParser(Type::FloatArray) {}
-
-    ~ASFloatArrayParser() override { mValues.freeBuffer(); }
-    ASFloatArrayParser(const ASFloatArrayParser&) = delete;
-    auto operator=(const ASFloatArrayParser&) = delete;
-
-    const sead::Buffer<Value>& getValues() const { return mValues; }
-
-    bool parse(const ParseArgs& args) override;
-
-private:
     agl::utl::ParameterObj mObj;
-    sead::Buffer<Value> mValues;
+    agl::utl::Parameter<bool> mNoSync;
+    agl::utl::Parameter<bool> mJudgeOnce;
+    agl::utl::Parameter<float> mInputLimit;
 };
 
-class ASIntArrayParser : public ASParamParser {
+class ASAssetResource : public ASResource {
-    SEAD_RTTI_OVERRIDE(ASIntArrayParser, ASParamParser)
+    SEAD_RTTI_OVERRIDE(ASAssetResource, ASResource)
 public:
-    struct Value {
+    using ASResource::ASResource;
-        agl::utl::Parameter<int> value;
-    };
 
-    ASIntArrayParser() : ASParamParser(Type::IntArray) {}
+    const sead::SafeString& getFileName() const { return *mFileName; }
 
-    ~ASIntArrayParser() override { mValues.freeBuffer(); }
+protected:
-    ASIntArrayParser(const ASIntArrayParser&) = delete;
+    bool doParse(const ParseArgs& args) override;
-    auto operator=(const ASIntArrayParser&) = delete;
 
-    const sead::Buffer<Value>& getValues() const { return mValues; }
-
-    bool parse(const ParseArgs& args) override;
-
-private:
     agl::utl::ParameterObj mObj;
-    sead::Buffer<Value> mValues;
+    agl::utl::Parameter<sead::SafeString> mFileName;
 };
 
-class ASBitIndexParser : public ASParamParser {
+class ASAssetExResource : public ASAssetResource {
-    SEAD_RTTI_OVERRIDE(ASBitIndexParser, ASParamParser)
+    SEAD_RTTI_OVERRIDE(ASAssetExResource, ASAssetResource)
 public:
-    ASBitIndexParser() : ASParamParser(Type::BitIndex) {}
+    using ASAssetResource::ASAssetResource;
 
-    int getBitIndex() const { return mTypeIndex; }
+protected:
+    int m5() override { return 1; }
+};
 
-    bool parse(const ParseArgs& args) override;
+class ASSkeltalAssetResource : public ASAssetResource {
+    SEAD_RTTI_OVERRIDE(ASSkeltalAssetResource, ASAssetResource)
+public:
+    using ASAssetResource::ASAssetResource;
 
-private:
+    const auto& getInitAnmDriven() const { return *mInitAnmDriven; }
-    int mTypeIndex = -1;
+    const auto& getMorph() const { return *mMorph; }
+    const auto& getResetMorph() const { return *mResetMorph; }
+
+protected:
+    bool doParse(const ParseArgs& args) override;
+
+    agl::utl::Parameter<int> mInitAnmDriven;
+    agl::utl::Parameter<float> mMorph;
+    agl::utl::Parameter<float> mResetMorph;
 };
 
 }  // namespace ksys::res

src/KingSystem/Resource/resResourceASResourceExtension.cpp

@@ -0,0 +1,339 @@
+#include "KingSystem/Resource/resResourceASResourceExtension.h"
+#include <container/seadSafeArray.h>
+#include <optional>
+#include <prim/seadSafeString.h>
+#include "KingSystem/ActorSystem/actASSetting.h"
+#include "KingSystem/Resource/resResourceASSetting.h"
+
+namespace ksys::res {
+
+bool ASFrameCtrlParser::parse(const ASParamParser::ParseArgs& args) {
+    mRate.init(1.0, "Rate", "再生速度", "Min=0.f,Max=10.f", &mObj);
+    mStartFrame.init(0.0, "StartFrame", "開始フレーム", "Min=0.f,Max=100.f", &mObj);
+    mEndFrame.init(-1.0, "EndFrame", "終了フレーム", "Min=-1.f,Max=100.f", &mObj);
+    mLoopStopCount.init(-1.0, "LoopStopCount", "ループ停止回数", "Min=-1.f,Max=10.f", &mObj);
+    mLoopStopCountRandom.init(0.0, "LoopStopCountRandom", "ランダムループ追加回数",
+                              "Min=0.f,Max=10.f", &mObj);
+    mReversePlay.init(false, "ReversePlay", "逆再生", "", &mObj);
+    mUseGlobalFrame.init(false, "UseGlobalFrame", "グローバルフレーム使う", "", &mObj);
+    mFootType.init(0, "FootType", "足解決", "", &mObj);
+    mConnect.init(false, "Connect", "接続", "", &mObj);
+    mAnmLoop.init(0, "AnmLoop", "ループ設定", "", &mObj);
+
+    mList.addObj(&mObj, "FrameCtrl0");
+    return true;
+}
+
+bool ASTriggerEventsParser::parse(const ASParamParser::ParseArgs& args) {
+    const int num_objs = args.res_list.getResParameterObjNum();
+    if (num_objs == 0)
+        return true;
+
+    if (!mEvents.tryAllocBuffer(num_objs, args.heap))
+        return false;
+
+    auto it = mEvents.begin();
+    const auto end = mEvents.end();
+
+    sead::FixedSafeString<32> obj_name{"Event"};
+    const auto obj_name_prefix_len = obj_name.calcLength();
+
+    auto res_it = args.res_list.objBegin();
+    const auto res_end = args.res_list.objEnd();
+
+    while (res_it != res_end && it != end) {
+        u32 type_index = -1;
+        const auto TypeIndex = agl::utl::getResParameter(res_it.getObj(), "TypeIndex");
+        if (TypeIndex.ptr())
+            type_index = *TypeIndex.getData<int>();
+
+        // TODO: add a TypeIndex enum
+        it->type_index = type_index > 33 ? 88 : int(type_index) + 54;
+
+        it->frame.init(0.0, "Frame", "フレーム", "Min=0.f,Max=100.f", &it->obj);
+        it->value.init("", "Value", "値", "", &it->obj);
+
+        obj_name.trim(obj_name_prefix_len);
+        obj_name.appendWithFormat("%d", it.getIndex());
+        mList.addObj(&it->obj, obj_name);
+
+        ++res_it;
+        ++it;
+    }
+
+    return true;
+}
+
+bool ASHoldEventsParser::parse(const ASParamParser::ParseArgs& args) {
+    const int num_objs = args.res_list.getResParameterObjNum();
+    if (num_objs == 0)
+        return true;
+
+    if (!mEvents.tryAllocBuffer(num_objs, args.heap))
+        return false;
+
+    auto it = mEvents.begin();
+    const auto end = mEvents.end();
+
+    sead::FixedSafeString<32> obj_name{"Event"};
+    const auto obj_name_prefix_len = obj_name.calcLength();
+
+    auto res_it = args.res_list.objBegin();
+    const auto res_end = args.res_list.objEnd();
+
+    while (res_it != res_end && it != end) {
+        u32 type_index = -1;
+        const auto TypeIndex = agl::utl::getResParameter(res_it.getObj(), "TypeIndex");
+        if (TypeIndex.ptr())
+            type_index = *TypeIndex.getData<int>();
+
+        // TODO: add a TypeIndex enum
+        it->type_index = type_index > 53 ? 88 : int(type_index);
+
+        it->start_frame.init(0.0, "StartFrame", "開始フレーム", "Min=0.f,Max=100.f", &it->obj);
+        it->end_frame.init(0.0, "EndFrame", "終了フレーム", "Min=0.f,Max=100.f", &it->obj);
+        it->value.init("", "Value", "値", "", &it->obj);
+
+        obj_name.trim(obj_name_prefix_len);
+        obj_name.appendWithFormat("%d", it.getIndex());
+        mList.addObj(&it->obj, obj_name);
+
+        ++res_it;
+        ++it;
+    }
+
+    return true;
+}
+
+bool ASStringArrayParser::parse(const ASParamParser::ParseArgs& args) {
+    const int size = args.res_list.getResParameterObj(0).getNum();
+    if (size != 0) {
+        if (!mValues.tryAllocBuffer(size, args.heap))
+            return false;
+
+        sead::FixedSafeString<32> param_name{"Value"};
+        const auto param_name_prefix_len = param_name.calcLength();
+
+        for (int i = 0; i < size; ++i) {
+            param_name.trim(param_name_prefix_len);
+            param_name.appendWithFormat("%d", i);
+            mValues[i].value.init("", param_name, "値", "", &mObj);
+        }
+    }
+
+    mList.addObj(&mObj, "StringArray0");
+    return true;
+}
+
+bool ASRangesParser::parse(const ASParamParser::ParseArgs& args) {
+    const int num_objs = args.res_list.getResParameterObjNum();
+    if (num_objs == 0)
+        return true;
+
+    if (!mRanges.tryAllocBuffer(num_objs, args.heap))
+        return false;
+
+    auto it = mRanges.begin();
+    const auto end = mRanges.end();
+
+    sead::FixedSafeString<32> obj_name{"Range"};
+    const auto obj_name_prefix_len = obj_name.calcLength();
+
+    auto res_it = args.res_list.objBegin();
+    const auto res_end = args.res_list.objEnd();
+
+    while (res_it != res_end && it != end) {
+        obj_name.trim(obj_name_prefix_len);
+        obj_name.appendWithFormat("%d", it.getIndex());
+
+        it->start.init(0.0, "Start", "開始", "Min=0.f,Max=1.f", &it->obj);
+        it->end.init(0.0, "End", "終了", "Min=0.f,Max=1.f", &it->obj);
+
+        mList.addObj(&it->obj, obj_name);
+
+        ++res_it;
+        ++it;
+    }
+
+    return true;
+}
+
+bool ASFloatArrayParser::parse(const ASParamParser::ParseArgs& args) {
+    const int size = args.res_list.getResParameterObj(0).getNum();
+    if (size != 0) {
+        if (!mValues.tryAllocBuffer(size, args.heap))
+            return false;
+
+        sead::FixedSafeString<32> param_name{"Value"};
+        const auto param_name_prefix_len = param_name.calcLength();
+
+        for (int i = 0; i < size; ++i) {
+            param_name.trim(param_name_prefix_len);
+            param_name.appendWithFormat("%d", i);
+            mValues[i].value.init(1.0, param_name, "値", "", &mObj);
+        }
+    }
+
+    mList.addObj(&mObj, "FloatArray0");
+    return true;
+}
+
+bool ASIntArrayParser::parse(const ASParamParser::ParseArgs& args) {
+    const int size = args.res_list.getResParameterObj(0).getNum();
+    if (size != 0) {
+        if (!mValues.tryAllocBuffer(size, args.heap))
+            return false;
+
+        sead::FixedSafeString<32> param_name{"Value"};
+        const auto param_name_prefix_len = param_name.calcLength();
+
+        for (int i = 0; i < size; ++i) {
+            param_name.trim(param_name_prefix_len);
+            param_name.appendWithFormat("%d", i);
+            mValues[i].value.init(1, param_name, "値", "", &mObj);
+        }
+    }
+
+    mList.addObj(&mObj, "IntArray0");
+    return true;
+}
+
+bool ASBitIndexParser::parse(const ASParamParser::ParseArgs& args) {
+    const auto obj = args.res_list.getResParameterObj(0);
+    if (obj.getNum() < 1)
+        return true;
+
+    const auto TypeIndex = agl::utl::getResParameter(obj, "TypeIndex");
+    if (!TypeIndex.ptr())
+        return true;
+
+    mTypeIndex = *TypeIndex.getData<int>();
+    return true;
+}
+
+template <typename T>
+static ASParamParser* factoryImpl_(sead::Heap* heap) {
+    return new (heap) T;
+}
+
+static ASParamParser* dummyASParserFactoryImpl_(sead::Heap*) {
+    return nullptr;
+}
+
+namespace {
+struct Factory {
+    const char* name;
+    ASParamParser* (*make)(sead::Heap* heap);
+};
+
+sead::SafeArray<Factory, ASParamParser::NumTypes> sASFactories{{
+    {"FrameCtrl", factoryImpl_<ASFrameCtrlParser>},
+    {"TriggerEvents", factoryImpl_<ASTriggerEventsParser>},
+    {"HoldEvents", factoryImpl_<ASHoldEventsParser>},
+    {"StringArray", factoryImpl_<ASStringArrayParser>},
+    {"Ranges", factoryImpl_<ASRangesParser>},
+    {"FloatArray", factoryImpl_<ASFloatArrayParser>},
+    {"IntArray", factoryImpl_<ASIntArrayParser>},
+    {"BitIndex", factoryImpl_<ASBitIndexParser>},
+    {"BlenderBone", dummyASParserFactoryImpl_},
+}};
+}  // namespace
+
+ASExtensions::~ASExtensions() {
+    for (auto*& parser : mParsers) {
+        if (parser && parser->getType() != ASParamParser::Type::BlenderBone)
+            delete parser;
+        parser = nullptr;
+    }
+    mParsers.freeBuffer();
+}
+
+bool ASExtensions::parse(const ASExtensions::ParseArgs& args) {
+    const auto Extend = agl::utl::getResParameterList(args.res_list, "Extend");
+    if (!Extend)
+        return true;
+
+    const auto num_extensions = Extend.getResParameterListNum();
+    if (num_extensions == 0)
+        return true;
+
+    if (!mParsers.tryAllocBuffer(num_extensions, args.heap))
+        return false;
+    for (int i = 0, n = mParsers.size(); i < n; ++i)
+        mParsers(i) = nullptr;
+
+    auto it = mParsers.begin();
+    const auto end = mParsers.end();
+
+    ASParamParser::ParseArgs parse_args{};
+    parse_args.list = &mList;
+    parse_args.heap = args.heap;
+
+    auto res_it = Extend.listBegin();
+    const auto res_end = Extend.listEnd();
+
+    for (; it != end && res_it != res_end; ++it, ++res_it) {
+        parse_args.res_list = res_it.getList();
+        *it = makeParser(parse_args);
+
+        constexpr int bone = int(ASParamParser::Type::BlenderBone);
+        if (*it == nullptr && parse_args.res_list.getParameterListNameHash() !=
+                                  agl::utl::ParameterBase::calcHash(sASFactories[bone].name)) {
+            return false;
+        }
+    }
+
+    args.list->addList(&mList, "Extend");
+    return true;
+}
+
+ASParamParser* ASExtensions::makeParser(const ASParamParser::ParseArgs& args) const {
+    const auto is_factory = [&args](int i) {
+        return args.res_list.getParameterListNameHash() ==
+               agl::utl::ParameterBase::calcHash(sASFactories[i].name);
+    };
+
+    std::optional<int> type;
+    for (int i = 0; i < ASParamParser::NumTypes - 1; ++i) {
+        if (!is_factory(i))
+            continue;
+        type = i;
+        break;
+    }
+
+    if (!type.has_value() && is_factory(int(ASParamParser::Type::BlenderBone))) {
+        const auto obj = args.res_list.getResParameterObj(0);
+        if (obj.getNum() > 0) {
+            const sead::SafeString name = obj.getResParameter(0).getData<const char>();
+            return act::ASSetting::instance()->getBoneParams(name);
+        }
+    }
+
+    if (!type.has_value())
+        return nullptr;
+
+    const auto& factory = sASFactories[*type];
+
+    auto* parser = factory.make(args.heap);
+    if (!parser)
+        return nullptr;
+
+    if (!parser->parse(args)) {
+        delete parser;
+        return nullptr;
+    }
+
+    args.list->addList(&parser->getList(), factory.name);
+    return parser;
+}
+
+ASParamParser* ASExtensions::getParser(ASParamParser::Type type) const {
+    for (int i = 0, n = mParsers.size(); i < n; ++i) {
+        auto* parser = mParsers[i];
+        if (parser && parser->getType() == type)
+            return parser;
+    }
+    return nullptr;
+}
+
+}  // namespace ksys::res

src/KingSystem/Resource/resResourceASResourceExtension.h

@@ -0,0 +1,259 @@
+#pragma once
+
+#include <agl/Utils/aglParameter.h>
+#include <agl/Utils/aglParameterList.h>
+#include <agl/Utils/aglParameterObj.h>
+#include <agl/Utils/aglResParameter.h>
+#include <array>
+#include <basis/seadTypes.h>
+#include <container/seadBuffer.h>
+#include <prim/seadRuntimeTypeInfo.h>
+#include "KingSystem/Utils/Types.h"
+
+namespace sead {
+class Heap;
+}
+
+namespace ksys::res {
+
+class ASParamParser {
+    SEAD_RTTI_BASE(ASParamParser)
+public:
+    enum class Type {
+        FrameCtrl = 0,
+        TriggerEvents = 1,
+        HoldEvents = 2,
+        StringArray = 3,
+        Ranges = 4,
+        FloatArray = 5,
+        IntArray = 6,
+        BitIndex = 7,
+        BlenderBone = 8,
+    };
+    static constexpr int NumTypes = 9;
+
+    struct ParseArgs {
+        agl::utl::ParameterList* list;
+        agl::utl::ResParameterList res_list;
+        sead::Heap* heap;
+    };
+
+    explicit ASParamParser(Type type) : mType(type) {}
+    virtual ~ASParamParser() = default;
+    virtual bool parse(const ParseArgs& args) { return true; }
+
+    Type getType() const { return mType; }
+    agl::utl::ParameterList& getList() { return mList; }
+    const agl::utl::ParameterList& getList() const { return mList; }
+
+protected:
+    Type mType;
+    agl::utl::ParameterList mList;
+};
+KSYS_CHECK_SIZE_NX150(ASParamParser, 0x58);
+
+class ASExtensions {
+public:
+    struct ParseArgs {
+        agl::utl::ResParameterList res_list;
+        agl::utl::ParameterList* list;
+        sead::Heap* heap;
+    };
+
+    ASExtensions() = default;
+    ~ASExtensions();
+    ASExtensions(const ASExtensions&) = delete;
+    auto operator=(const ASExtensions&) = delete;
+
+    const sead::Buffer<ASParamParser*>& getParsers() const { return mParsers; }
+    ASParamParser* getParser(ASParamParser::Type type) const;
+
+    bool parse(const ParseArgs& args);
+
+private:
+    ASParamParser* makeParser(const ASParamParser::ParseArgs& args) const;
+
+    agl::utl::ParameterList mList;
+    sead::Buffer<ASParamParser*> mParsers;
+};
+
+class ASFrameCtrlParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASFrameCtrlParser, ASParamParser)
+public:
+    ASFrameCtrlParser() : ASParamParser(Type::FrameCtrl) {}
+
+    const auto& getRate() const { return *mRate; }
+    const auto& getStartFrame() const { return *mStartFrame; }
+    const auto& getEndFrame() const { return *mEndFrame; }
+    const auto& getLoopStopCount() const { return *mLoopStopCount; }
+    const auto& getLoopStopCountRandom() const { return *mLoopStopCountRandom; }
+    const auto& getReversePlay() const { return *mReversePlay; }
+    const auto& getUseGlobalFrame() const { return *mUseGlobalFrame; }
+    const auto& getConnect() const { return *mConnect; }
+    const auto& getFootType() const { return *mFootType; }
+    const auto& getAnmLoop() const { return *mAnmLoop; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    agl::utl::ParameterObj mObj;
+    agl::utl::Parameter<float> mRate;
+    agl::utl::Parameter<float> mStartFrame;
+    agl::utl::Parameter<float> mEndFrame;
+    agl::utl::Parameter<float> mLoopStopCount;
+    agl::utl::Parameter<float> mLoopStopCountRandom;
+    agl::utl::Parameter<bool> mReversePlay;
+    agl::utl::Parameter<bool> mUseGlobalFrame;
+    agl::utl::Parameter<int> mConnect;
+    agl::utl::Parameter<int> mFootType;
+    agl::utl::Parameter<int> mAnmLoop;
+};
+
+class ASTriggerEventsParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASTriggerEventsParser, ASParamParser)
+public:
+    struct Event {
+        agl::utl::ParameterObj obj;
+        int type_index;
+        agl::utl::Parameter<float> frame;
+        agl::utl::Parameter<sead::SafeString> value;
+    };
+
+    ASTriggerEventsParser() : ASParamParser(Type::TriggerEvents) {}
+    ~ASTriggerEventsParser() override { mEvents.freeBuffer(); }
+    ASTriggerEventsParser(const ASTriggerEventsParser&) = delete;
+    auto operator=(const ASTriggerEventsParser&) = delete;
+
+    const sead::Buffer<Event>& getEvents() const { return mEvents; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    sead::Buffer<Event> mEvents;
+};
+
+class ASHoldEventsParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASHoldEventsParser, ASParamParser)
+public:
+    struct Event {
+        agl::utl::ParameterObj obj;
+        int type_index;
+        agl::utl::Parameter<float> start_frame;
+        agl::utl::Parameter<float> end_frame;
+        agl::utl::Parameter<sead::SafeString> value;
+    };
+
+    ASHoldEventsParser() : ASParamParser(Type::HoldEvents) {}
+    ~ASHoldEventsParser() override { mEvents.freeBuffer(); }
+    ASHoldEventsParser(const ASHoldEventsParser&) = delete;
+    auto operator=(const ASHoldEventsParser&) = delete;
+
+    const sead::Buffer<Event>& getEvents() const { return mEvents; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    sead::Buffer<Event> mEvents;
+};
+
+class ASStringArrayParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASStringArrayParser, ASParamParser)
+public:
+    struct Value {
+        agl::utl::Parameter<sead::SafeString> value;
+    };
+
+    ASStringArrayParser() : ASParamParser(Type::StringArray) {}
+    ~ASStringArrayParser() override { mValues.freeBuffer(); }
+    ASStringArrayParser(const ASStringArrayParser&) = delete;
+    auto operator=(const ASStringArrayParser&) = delete;
+
+    const sead::Buffer<Value>& getValues() const { return mValues; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    agl::utl::ParameterObj mObj;
+    sead::Buffer<Value> mValues;
+};
+
+class ASRangesParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASRangesParser, ASParamParser)
+public:
+    struct Range {
+        agl::utl::ParameterObj obj;
+        agl::utl::Parameter<float> start;
+        agl::utl::Parameter<float> end;
+    };
+
+    ASRangesParser() : ASParamParser(Type::Ranges) {}
+    ~ASRangesParser() override { mRanges.freeBuffer(); }
+    ASRangesParser(const ASRangesParser&) = delete;
+    auto operator=(const ASRangesParser&) = delete;
+
+    const sead::Buffer<Range>& getRanges() const { return mRanges; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    sead::Buffer<Range> mRanges;
+};
+
+class ASFloatArrayParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASFloatArrayParser, ASParamParser)
+public:
+    struct Value {
+        agl::utl::Parameter<float> value;
+    };
+
+    ASFloatArrayParser() : ASParamParser(Type::FloatArray) {}
+
+    ~ASFloatArrayParser() override { mValues.freeBuffer(); }
+    ASFloatArrayParser(const ASFloatArrayParser&) = delete;
+    auto operator=(const ASFloatArrayParser&) = delete;
+
+    const sead::Buffer<Value>& getValues() const { return mValues; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    agl::utl::ParameterObj mObj;
+    sead::Buffer<Value> mValues;
+};
+
+class ASIntArrayParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASIntArrayParser, ASParamParser)
+public:
+    struct Value {
+        agl::utl::Parameter<int> value;
+    };
+
+    ASIntArrayParser() : ASParamParser(Type::IntArray) {}
+
+    ~ASIntArrayParser() override { mValues.freeBuffer(); }
+    ASIntArrayParser(const ASIntArrayParser&) = delete;
+    auto operator=(const ASIntArrayParser&) = delete;
+
+    const sead::Buffer<Value>& getValues() const { return mValues; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    agl::utl::ParameterObj mObj;
+    sead::Buffer<Value> mValues;
+};
+
+class ASBitIndexParser : public ASParamParser {
+    SEAD_RTTI_OVERRIDE(ASBitIndexParser, ASParamParser)
+public:
+    ASBitIndexParser() : ASParamParser(Type::BitIndex) {}
+
+    int getBitIndex() const { return mTypeIndex; }
+
+    bool parse(const ParseArgs& args) override;
+
+private:
+    int mTypeIndex = -1;
+};
+
+}  // namespace ksys::res

src/KingSystem/Resource/resResourceASSetting.h

@@ -10,7 +10,7 @@
 #include <prim/seadRuntimeTypeInfo.h>
 #include <prim/seadSafeString.h>
 #include "KingSystem/Resource/resResource.h"
-#include "KingSystem/Resource/resResourceASResource.h"
+#include "KingSystem/Resource/resResourceASResourceExtension.h"
 
 namespace ksys::res {