ksys/act: Finish BaseProcUnit

data/uking_functions.csv

@@ -91741,15 +91741,15 @@
 0x00000071011bb924,BaseProcHandle::x,52,
 0x00000071011bb958,BaseProcHandle::deleteActor,112,
 0x00000071011bb9c8,BaseProcHandle::dtor,56,_ZN4ksys3act14BaseProcHandleD1Ev
-0x00000071011bba00,BaseProcUnit::deleteActor,316,
+0x00000071011bba00,BaseProcUnit::deleteActor,316,_ZN4ksys3act12BaseProcUnit10deleteProcEjPNS0_14BaseProcHandleE
 0x00000071011bbb3c,BaseProcHandle::getActor,24,_ZN4ksys3act14BaseProcHandle7getProcEv
 0x00000071011bbb54,BaseProcHandle::setProcStateFlag8000,184,
 0x00000071011bbc0c,BaseProcHandle::wakeUpActorAndReleaseUnit,184,
 0x00000071011bbcc4,BaseProcHandle::getBaseProcEvent,48,
 0x00000071011bbcf4,BaseProcHandle::allocUnit,228,
-0x00000071011bbdd8,BaseProcUnit::setActor,540,_ZN4ksys3act12BaseProcUnit7setProcEPNS0_8BaseProcE!
-0x00000071011bbff4,BaseProcUnit::cleanUp,512,
-0x00000071011bc1f4,BaseProcUnit::unlinkActor,412,
+0x00000071011bbdd8,BaseProcUnit::setActor,540,_ZN4ksys3act12BaseProcUnit7setProcEPNS0_8BaseProcE
+0x00000071011bbff4,BaseProcUnit::cleanUp,512,_ZN4ksys3act12BaseProcUnit7cleanUpEPNS0_8BaseProcEb
+0x00000071011bc1f4,BaseProcUnit::unlinkActor,412,_ZN4ksys3act12BaseProcUnit10unlinkProcEPNS0_8BaseProcE
 0x00000071011bc390,BaseProcUnit::isParentHandleDefault,24,_ZNK4ksys3act12BaseProcUnit21isParentHandleDefaultEv
 0x00000071011bc3a8,sub_71011BC3A8,132,
 0x00000071011bc42c,sub_71011BC42C,56,

src/KingSystem/ActorSystem/actActorLinkConstDataAccess.h

@@ -39,6 +39,7 @@ public:
 protected:
     friend class ActorConstDataAccess;
     friend class BaseProc;
+    friend class BaseProcUnit;
 
     bool mAcquired = false;
     BaseProc* mProc = nullptr;

src/KingSystem/ActorSystem/actBaseProcUnit.cpp

@@ -8,48 +8,118 @@
 
 namespace ksys::act {
 
-// NON_MATCHING: Equivalent but branches are off.
+bool BaseProcUnit::deleteProc(u32, BaseProcHandle* handle) {
+    ActorLinkConstDataAccess accessor;
+
+    {
+        const auto lock = sead::makeScopedLock(mCS);
+        BaseProcHandle* current_handle = mHandle;
+        if (current_handle == handle) {
+            if (mProc)
+                accessor.acquire(mProc);
+
+            if (mStatus == Status::_1 || mProc) {
+                mHandle.compareExchange(handle, &BaseProcHandle::sDummyHandle);
+            } else {
+                mStatus = Status::Unused;
+                mHandle = nullptr;
+            }
+        } else {
+            sead::FixedSafeString<256> message;
+            message.format("BaseProcUnit:(%p, %p), 呼び出し(%p)", this, current_handle, handle);
+            util::PrintDebug(message);
+        }
+    }
+
+    if (accessor.hasProc())
+        accessor.mProc->deleteLater(BaseProc::DeleteReason::_2);
+
+    return true;
+}
+
 bool BaseProcUnit::setProc(BaseProc* proc) {
-    bool ret;
     static constexpr const char* sStateNames[] = {"Init", "Calc", "Sleep", "Delete"};
 
     auto lock = sead::makeScopedLock(mCS);
+
     if (mProc)
         mProc = nullptr;
 
-    if (mHandle == &BaseProcHandle::sDummyHandle)
+    if (isParentHandleDefault())
         return false;
 
-    if (mHandle) {
-        if (mFlags != 1) {
+    const auto print_info = [&] {
         sead::FixedSafeString<64> message;
-
-            if (proc)
-                message.format("%s, %d, %d, %s, ( %p:%p )", proc->getName().cstr(), mFlags,
+        if (proc) {
+            message.format("%s, %d, %d, %s, ( %p:%p )", proc->getName().cstr(), u32(mStatus.load()),
                            proc->isInitialized(), sStateNames[u8(proc->getState())], this,
                            mHandle.load());
-            else
-                message.format("なし, %d, ?, ?, ( %p:%p )", mFlags, this, mHandle.load());
-
-            util::PrintDebug(message);
-        }
-        mProc = proc;
-        mFlags = 2;
-        ret = true;
         } else {
-        sead::FixedSafeString<64> message;
-
-        if (proc)
-            message.format("%s, %d, %d, %s, ( %p:%p )", proc->getName().cstr(), mFlags,
-                           proc->isInitialized(), sStateNames[u8(proc->getState())], this,
-                           mHandle.load());
-        else
-            message.format("なし, %d, ?, ?, ( %p:%p )", mFlags, this, mHandle.load());
-
-        util::PrintDebug(message);
-        ret = false;
+            message.format("なし, %d, ?, ?, ( %p:%p )", u32(mStatus.load()), this, mHandle.load());
         }
-    return ret;
+        util::PrintDebug(message);
+    };
+
+    if (!mHandle) {
+        print_info();
+        return false;
+    }
+
+    if (mStatus != Status::_1)
+        print_info();
+
+    mProc = proc;
+    mStatus = Status::Ready;
+    return true;
+}
+
+void BaseProcUnit::reset() {
+    auto* handle = getHandle();
+    if (handle != &BaseProcHandle::sDummyHandle) {
+        sead::FixedSafeString<256> message;
+        message.format("BaseProcUnit:%p, %p", this, handle);
+        util::PrintDebug(message);
+    }
+    mProc = nullptr;
+    mStatus = Status::Unused;
+    mHandle = nullptr;
+}
+
+void BaseProcUnit::cleanUp(BaseProc* proc, bool set_status_5) {
+    const auto lock = sead::makeScopedLock(mCS);
+
+    mProc = nullptr;
+
+    const auto print_info = [&] {
+        sead::FixedSafeString<64> message;
+        message.format("%d, ( %p:%p )", u32(mStatus.load()), this, mHandle.load());
+        util::PrintDebug(message);
+    };
+
+    if (isParentHandleDefault()) {
+        reset();
+    } else if (!mHandle) {
+        print_info();
+    } else {
+        const auto status = mStatus.load();
+        if (status == Status::Unused || (status > Status::_3 && status != Status::_5))
+            print_info();
+        mStatus = set_status_5 ? Status::_5 : Status::_3;
+    }
+}
+
+void BaseProcUnit::unlinkProc(BaseProc* proc) {
+    const auto lock = sead::makeScopedLock(mCS);
+
+    if (mProc != proc && mProc != nullptr) {
+        sead::FixedSafeString<256> message;
+        message.format("BaseProcUnit:(%p:%p), BaseProc:(%s:%p), 残りBaseProc(%s:%p)", this,
+                       mHandle.load(), proc->getName().cstr(), proc, mProc->getName().cstr(),
+                       mProc);
+        util::PrintDebug(message);
+    }
+
+    reset();
 }
 
 bool BaseProcUnit::isParentHandleDefault() const {

src/KingSystem/ActorSystem/actBaseProcUnit.h

@@ -3,6 +3,7 @@
 #include <basis/seadTypes.h>
 #include <thread/seadAtomic.h>
 #include <thread/seadCriticalSection.h>
+#include "KingSystem/ActorSystem/actBaseProcCreateTask.h"
 
 namespace ksys::act {
 
@@ -14,19 +15,32 @@ public:
     bool deleteProc(u32, BaseProcHandle* handle);
     bool setProc(BaseProc* proc);
     void unlinkProc(BaseProc* proc);
-    void cleanUp(BaseProc* proc, bool set_flag_5);
+    void cleanUp(BaseProc* proc, bool set_status_5);
     bool isParentHandleDefault() const;
 
     BaseProc* getProc() const { return mProc; }
-    bool isReady() const { return mFlags == 2; }
+    bool isReady() const { return mStatus == Status::Ready; }
 
 private:
-    u32 mFlags;
-    sead::Atomic<BaseProcHandle*> mHandle;
-    BaseProc* mProc;
-    // FIXME:
-    // BaseProcRequest mRequest;
+    enum class Status : u32 {
+        Unused = 0,
+        _1 = 1,
+        Ready = 2,
+        _3 = 3,
+        _4 = 4,
+        _5 = 5,
+    };
+
+    void reset();
+
+    BaseProcHandle* getHandle() const { return mHandle.load(); }
+
+    sead::Atomic<Status> mStatus = Status::Unused;
+    sead::Atomic<BaseProcHandle*> mHandle{};
+    BaseProc* mProc{};
+    BaseProcCreateTask mCreateTask;
     sead::CriticalSection mCS;
 };
+KSYS_CHECK_SIZE_NX150(BaseProcUnit, 0x2f0);
 
 }  // namespace ksys::act