ksys/act: Implement more ActorParamMgr functions

src/KingSystem/ActorSystem/actActorParamMgr.cpp

@@ -1,5 +1,9 @@
 #include "KingSystem/ActorSystem/actActorParamMgr.h"
+#include <prim/seadScopedLock.h>
 #include "KingSystem/ActorSystem/actASSetting.h"
+#include "KingSystem/ActorSystem/actActorParam.h"
+#include "KingSystem/Resource/resLoadRequest.h"
+#include "KingSystem/Resource/resResourceGParamList.h"
 
 namespace ksys::act {
 
@@ -11,4 +15,75 @@ ActorParamMgr::~ActorParamMgr() {
     ASSetting::deleteInstance();
 }
 
+// NON_MATCHING: addressing mode
+ActorParam* ActorParamMgr::getParam(const char* actor_name, ActorParam** out_free_param) const {
+    auto lock = sead::makeScopedLock(mCS);
+    for (s32 i = 0; i < NumParams; ++i) {
+        auto* param = &mParams[i];
+        if (param->getActorName().isEmpty()) {
+            if (out_free_param && !*out_free_param)
+                *out_free_param = param;
+        } else if (param->getActorName() == actor_name) {
+            return param;
+        }
+    }
+    return nullptr;
+}
+
+ActorParam* ActorParamMgr::loadParam(const char* actor_name, res::Handle* handle, void* x,
+                                     u32 load_req_c) {
+    ActorParam* param;
+    bool existing = false;
+
+    {
+        auto lock = sead::makeScopedLock(mCS);
+
+        ActorParam* free_param = nullptr;
+        param = getParam(actor_name, &free_param);
+
+        if (param) {
+            existing = true;
+        } else {
+            param = free_param;
+            if (free_param)
+                free_param->mRes = {};
+            else
+                param = &mParams[NumParams - 1];
+
+            param->mActorName = actor_name;
+        }
+        param->incrementRef();
+    }
+
+    if (!existing) {
+        loadFiles(param, mTmpActorParamMgrHeap, handle, x, load_req_c);
+        param->setEventSignal();
+    } else {
+        param->waitForEvent();
+    }
+
+    return param;
+}
+
+bool ActorParamMgr::loadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
+                                  u32 load_req_c) {
+    sead::FixedSafeString<128> path;
+    res::LoadRequest req;
+
+    if (mFlags.isOn(Flag::_5))
+        return false;
+
+    path.format("Actor/Pack/%s.bactorpack", actor_name.cstr());
+    req.mRequester = actor_name;
+    req._c = load_req_c;
+    req._8 = true;
+    req._28 = false;
+    return handle->requestLoad(path, &req);
+}
+
+res::GParamList* ActorParamMgr::getDummyGParamList() const {
+    return static_cast<res::GParamList*>(
+        mResHandles[u32(ActorParam::ResourceType::GParamList)].getResourceUnchecked());
+}
+
 }  // namespace ksys::act

src/KingSystem/ActorSystem/actActorParamMgr.h

@@ -3,6 +3,8 @@
 #include <container/seadSafeArray.h>
 #include <heap/seadDisposer.h>
 #include <hostio/seadHostIONode.h>
+#include <prim/seadSafeString.h>
+#include <prim/seadTypedBitFlag.h>
 #include <thread/seadCriticalSection.h>
 #include "KingSystem/Resource/resHandle.h"
 #include "KingSystem/System/DebugMessage.h"
@@ -29,16 +31,32 @@ public:
     const char* getName() const override { return "AglXml"; }
     void syncData(const char* data) override;
 
-    void init(sead::Heap* heap, sead::Heap* debug_heap);
-
-    res::GParamList* getDummyGParamList() const;
-
     DebugMessage& getDebugMessage() { return mDebugMessage; }
     sead::Heap* getDebugHeap() const { return mDebugHeap; }
     sead::Heap* getTmpActorParamMgrHeap() const { return mTmpActorParamMgrHeap; }
 
+    void init(sead::Heap* heap, sead::Heap* debug_heap);
+
+    ActorParam* getParam(const char* actor_name, ActorParam** out_free_param) const;
+    ActorParam* loadParam(const char* actor_name, res::Handle* handle, void* x, u32 load_req_c);
+
+    res::GParamList* getDummyGParamList() const;
+
 private:
-    u8 mFlags{};
+    enum class Flag : u8 {
+        _1 = 1,
+        _2 = 2,
+        _4 = 4,
+        _5 = _1 | _4,
+    };
+
+    void loadFiles(ActorParam* param, sead::Heap* heap, res::Handle* handle, void* x,
+                   u32 load_req_c);
+    bool loadActorPack(res::Handle* handle, const sead::SafeString& actor_name, u32 load_req_c);
+
+    static constexpr s32 NumParams = 0x400;
+
+    sead::TypedBitFlag<Flag> mFlags{};
     ActorParam* mParams = nullptr;
     DebugMessage mDebugMessage{"アクタパラメータ"};
     void* _e0 = nullptr;
@@ -46,7 +64,7 @@ private:
     sead::Heap* mDebugHeap = nullptr;
     sead::Heap* mTmpActorParamMgrHeap = nullptr;
     sead::SafeArray<res::Handle, 28> mResHandles;
-    sead::CriticalSection mCS;
+    mutable sead::CriticalSection mCS;
 };
 KSYS_CHECK_SIZE_NX150(ActorParamMgr, 0xa00);