ksys/act: Start adding BaseProcCreateTask

data/uking_functions.csv

@@ -96955,17 +96955,17 @@
 0x0000007101304bdc,sub_7101304BDC,288,
 0x0000007101304cfc,sub_7101304CFC,204,
 0x0000007101304dc8,sub_7101304DC8,92,
-0x0000007101304e24,BaseProcEvent::ctor,240,
-0x0000007101304f14,BaseProcEvent::invokedCreateActor,400,
-0x00000071013050a4,sub_71013050A4,88,
-0x00000071013050fc,BaseProcEvent::initWithRequestData,688,
-0x00000071013053ac,BaseProcEvent::initWithRequest,152,
-0x0000007101305444,BaseProcEvent::rtti1,288,
-0x0000007101305564,BaseProcEvent::rtti2,92,
-0x00000071013055c0,BaseProcEvent::dtor,56,
-0x00000071013055f8,BaseProcEvent::dtorDelete,64,
-0x0000007101305638,sub_7101305638,52,
-0x000000710130566c,sub_710130566C,92,
+0x0000007101304e24,BaseProcEvent::ctor,240,_ZN4ksys3act18BaseProcCreateTaskC1EPN4sead4HeapE
+0x0000007101304f14,BaseProcEvent::invokedCreateActor,400,_ZN4ksys3act18BaseProcCreateTask21onTaskDelegateInvokedEPv
+0x00000071013050a4,sub_71013050A4,88,_ZN4ksys3act18BaseProcCreateTask24onBaseProcCreationFailedEPNS0_8BaseProcEb
+0x00000071013050fc,BaseProcEvent::initWithRequestData,688,_ZN4ksys3act18BaseProcCreateTask9doPrepareEPKNS0_22BaseProcCreateTaskDataE
+0x00000071013053ac,BaseProcEvent::initWithRequest,152,_ZN4ksys3act18BaseProcCreateTask12prepareImpl_EPNS_4util11TaskRequestE
+0x0000007101305444,BaseProcEvent::rtti1,288,_ZNK4ksys3act18BaseProcCreateTask27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
+0x0000007101305564,BaseProcEvent::rtti2,92,_ZNK4ksys3act18BaseProcCreateTask18getRuntimeTypeInfoEv
+0x00000071013055c0,BaseProcEvent::dtor,56,_ZN4ksys3act18BaseProcCreateTaskD2Ev
+0x00000071013055f8,BaseProcEvent::dtorDelete,64,_ZN4ksys3act18BaseProcCreateTaskD0Ev
+0x0000007101305638,sub_7101305638,52,_ZN4sead10Delegate1RIN4ksys3act18BaseProcCreateTaskEPvbE6invokeES4_
+0x000000710130566c,sub_710130566C,92,_ZNK4sead10Delegate1RIN4ksys3act18BaseProcCreateTaskEPvbE5cloneEPNS_4HeapE
 0x00000071013056c8,sub_71013056C8,64,
 0x0000007101305708,BaseProcInitializer::ctor,40,
 0x0000007101305730,BaseProcInitializer::dtor,260,

src/KingSystem/ActorSystem/CMakeLists.txt

@@ -52,6 +52,8 @@ target_sources(uking PRIVATE
   actAttention.h
   actBaseProc.cpp
   actBaseProc.h
+  actBaseProcCreateTask.cpp
+  actBaseProcCreateTask.h
   actBaseProcDeleter.cpp
   actBaseProcDeleter.h
   actBaseProcHandle.cpp

src/KingSystem/ActorSystem/actBaseProc.h

@@ -134,6 +134,10 @@ public:
     /// Actually pre-delete the actor. Called from BaseProcDeleter.
     void doPreDelete(const PreDeleteArg& arg);
 
+    /// Set the BaseProcUnit. Only for use by BaseProcCreateTask.
+    void setUnitForBaseProcCreateTask(BaseProcUnit* unit) { mProcUnit = unit; }
+    void setInitializedFlag() { mFlags.set(Flags::Initialized); }
+
 protected:
     friend class BaseProcLinkDataMgr;
     friend class BaseProcMgr;

src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp

@@ -0,0 +1,83 @@
+#include "KingSystem/ActorSystem/actBaseProcCreateTask.h"
+#include "KingSystem/ActorSystem/actBaseProcHandle.h"
+#include "KingSystem/ActorSystem/actBaseProcUnit.h"
+#include "KingSystem/Map/mapObject.h"
+
+namespace ksys::act {
+
+BaseProcCreateTask::BaseProcCreateTask(sead::Heap* heap) : ManagedTask(heap) {}
+
+bool BaseProcCreateTask::onTaskDelegateInvoked(void*) {
+    BaseProcCreateArg arg;
+    arg.heap = mHeap;
+    arg.heap2 = arg.heap;
+    arg.proc_class = mClass;
+    arg.proc_name = mName;
+    mDistanceToLoadSphere = -1.0;
+    arg.params = mParams.getNumParams() != 0 ? &mParams : nullptr;
+    arg.mubin_iter = mMubinIter.isValid() ? &mMubinIter : nullptr;
+    arg.map_object = mMapObject;
+    arg.proc_link = mLink;
+    mLink.reset();
+    static_cast<void>(arg.heap2->getMaxAllocatableSize(sizeof(void*)));
+
+    BaseProc* proc = mCreateDelegate->invoke(arg);
+    if (proc) {
+        proc->setUnitForBaseProcCreateTask(mUnit);
+
+        if (proc->isDeletedOrDeleting() || !proc->init(arg.heap2, false))
+            onBaseProcCreationFailed(proc, false);
+
+        proc->setInitializedFlag();
+    } else {
+        onBaseProcCreationFailed(proc, false);
+    }
+
+    return true;
+}
+
+void BaseProcCreateTask::onBaseProcCreationFailed(BaseProc* proc, bool set_flag_5) {
+    if (mMapObject)
+        mMapObject->onBaseProcCreated(proc);
+
+    if (!proc && mUnit) {
+        mUnit->cleanUp(proc, set_flag_5);
+        mUnit = nullptr;
+    }
+}
+
+void BaseProcCreateTask::doPrepare(const BaseProcCreateTaskData* arg) {
+    auto data = sead::DynamicCast<const BaseProcCreateTaskData>(arg);
+    [&] {
+        mHeap = data->mHeap;
+        mClass = data->mProcClass;
+        mName = data->mProcName;
+
+        if (data->mMubinIter)
+            mMubinIter = *data->mMubinIter;
+        else
+            mMubinIter = {};
+
+        mMapObject = data->mMapObject;
+
+        if (data->mParams && data->mParams->getNumParams() != 0)
+            mParams = *data->mParams;
+        else
+            mParams.clearFast();
+
+        mCreateDelegate = data->mCreateDelegate;
+        mUnit = data->mProcHandle ? data->mProcHandle->getUnit() : nullptr;
+
+        if (data->mOtherProc)
+            mLink.acquire(data->mOtherProc, false);
+        else
+            mLink.reset();
+    }();
+}
+
+void BaseProcCreateTask::prepareImpl_(util::TaskRequest* req) {
+    doPrepare(sead::DynamicCast<BaseProcCreateTaskRequest>(req)->mData);
+    setDelegateInternal_(&mTaskDelegate);
+}
+
+}  // namespace ksys::act

src/KingSystem/ActorSystem/actBaseProcCreateTask.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+#include <prim/seadDelegate.h>
+#include <prim/seadSafeString.h>
+#include "KingSystem/ActorSystem/actBaseProcLink.h"
+#include "KingSystem/ActorSystem/actInstParamPack.h"
+#include "KingSystem/Map/mapMubinIter.h"
+#include "KingSystem/Utils/Thread/ManagedTask.h"
+#include "KingSystem/Utils/Thread/Task.h"
+#include "KingSystem/Utils/Thread/TaskData.h"
+#include "KingSystem/Utils/Types.h"
+
+namespace ksys::map {
+class Object;
+}
+
+namespace ksys::act {
+
+class BaseProc;
+class BaseProcHandle;
+class BaseProcUnit;
+
+struct BaseProcCreateArg {
+    sead::Heap* heap;
+    sead::Heap* heap2;
+    sead::SafeString proc_class;
+    sead::SafeString proc_name;
+    map::MubinIter* mubin_iter;
+    map::Object* map_object;
+    InstParamPack::Buffer* params;
+    BaseProcLink proc_link;
+};
+KSYS_CHECK_SIZE_NX150(BaseProcCreateArg, 0x58);
+
+class BaseProcCreateTaskData : public util::TaskData {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskData, util::TaskData)
+
+public:
+    BaseProcCreateTaskData() = default;
+    virtual ~BaseProcCreateTaskData() = default;
+
+    sead::Heap* mHeap{};
+    sead::SafeString mProcClass{};
+    sead::SafeString mProcName{};
+    sead::IDelegate1R<BaseProcCreateArg&, BaseProc*>* mCreateDelegate{};
+    BaseProcHandle* mProcHandle{};
+    map::MubinIter* mMubinIter{};
+    map::Object* mMapObject{};
+    InstParamPack::Buffer* mParams{};
+    BaseProc* mOtherProc{};
+    bool _60{};
+};
+KSYS_CHECK_SIZE_NX150(BaseProcCreateTaskData, 0x68);
+
+class BaseProcCreateTaskRequest : public util::TaskRequest {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskRequest, util::TaskRequest)
+
+public:
+    BaseProcCreateTaskRequest() = default;
+
+    BaseProcCreateTaskData* mData{};
+};
+
+class BaseProcCreateTask : public util::ManagedTask {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTask, util::ManagedTask)
+
+public:
+    explicit BaseProcCreateTask(sead::Heap* heap);
+
+    void onBaseProcCreationFailed(BaseProc* proc, bool set_flag_5);
+
+protected:
+    void prepareImpl_(util::TaskRequest* req) override;
+
+private:
+    bool onTaskDelegateInvoked(void* arg);
+    void doPrepare(const BaseProcCreateTaskData* data);
+
+    sead::Heap* mHeap;
+    sead::FixedSafeString<64> mClass;
+    sead::FixedSafeString<64> mName;
+    map::MubinIter mMubinIter;
+    sead::IDelegate1R<BaseProcCreateArg&, BaseProc*>* mCreateDelegate{};
+    BaseProcUnit* mUnit{};
+    map::Object* mMapObject{};
+    util::TaskDelegateT<BaseProcCreateTask> mTaskDelegate{
+        this, &BaseProcCreateTask::onTaskDelegateInvoked};
+    BaseProcLink mLink;
+    f32 mDistanceToLoadSphere = -1.0;
+    InstParamPack::Buffer mParams;
+};
+KSYS_CHECK_SIZE_NX150(BaseProcCreateTask, 0x298);
+
+}  // namespace ksys::act

src/KingSystem/ActorSystem/actBaseProcHandle.h

@@ -16,6 +16,7 @@ public:
     bool procReady();
 
     BaseProc* getProc();
+    BaseProcUnit* getUnit() const { return mUnit; }
 
     static BaseProcHandle sDummyHandle;
 

src/KingSystem/ActorSystem/actInstParamPack.h

@@ -62,6 +62,9 @@ public:
         Buffer() { clear(); }
         Buffer& operator=(const Buffer& other);
 
+        auto getNumParams() const { return mNumItems; }
+        void clearFast() { mNumItems = 0; }
+
         void clear();
         void add(const void* data, const sead::SafeString& name, s32 byte_size, EntryType type);
         void add(ActorCallback* callback, const sead::SafeString& name);

src/KingSystem/Map/mapObject.h

@@ -76,6 +76,8 @@ public:
 
     void free();
 
+    void onBaseProcCreated(act::BaseProc* proc);
+
     bool getActorWithAccessor(act::ActorLinkConstDataAccess& accessor) const;
     act::Actor* getActor() const;
     void registerBaseProc(act::BaseProc* proc);