ksys/act: Implement remaining BaseProc functions

data/uking_functions.csv

@@ -91693,32 +91693,32 @@
 0x00000071011b9f84,ActorBase::startPreparingForPreDelete_,108,_ZN4ksys3act8BaseProc27startPreparingForPreDelete_Ev!
 0x00000071011b9ff0,ActorBase::free,96,_ZN4ksys3act8BaseProc9destruct_Ei
 0x00000071011ba050,ActorBase::requestPreDelete,324,_ZN4ksys3act8BaseProc16processPreDeleteEv
-0x00000071011ba194,ActorBase::freeLinkData,24,
+0x00000071011ba194,ActorBase::freeLinkData,24,_ZN4ksys3act8BaseProc12freeLinkDataEv
 0x00000071011ba1ac,ActorBase::isSpecialJobType,84,_ZN4ksys3act8BaseProc17isSpecialJobType_ENS0_7JobTypeE
-0x00000071011ba200,ActorBase::x,112,
+0x00000071011ba200,ActorBase::x,112,_ZN4ksys3act8BaseProc16isSpecialJobTypeENS0_7JobTypeE
 0x00000071011ba270,ActorBase::queueExtraJobPush,68,_ZN4ksys3act8BaseProc18queueExtraJobPush_ENS0_7JobTypeE
-0x00000071011ba2b4,ActorBase::shouldSkipJobPush,144,
+0x00000071011ba2b4,ActorBase::shouldSkipJobPush,144,_ZN4ksys3act8BaseProc17shouldSkipJobPushENS0_7JobTypeE
 0x00000071011ba344,ActorBase::getConnectedCalcParent,32,_ZNK4ksys3act8BaseProc22getConnectedCalcParentEv
-0x00000071011ba364,ActorBase::jobInvoked,564,
+0x00000071011ba364,ActorBase::jobInvoked,564,_ZN4ksys3act8BaseProc10jobInvokedENS0_7JobTypeE
 0x00000071011ba598,ActorBase::updateState,1076,_ZN4ksys3act8BaseProc18processStateUpdateEh!
 0x00000071011ba9cc,ActorBase::afterUpdateState,48,_ZN4ksys3act8BaseProc17afterUpdateState_Ev
 0x00000071011BA9FC,_ZN4ksys3act8BaseProc17x00000071011ba9fcEv,0xBC,_ZN4ksys3act8BaseProc17x00000071011ba9fcEv
-0x00000071011baab8,ActorBase::setProcStateFlag,124,
+0x00000071011baab8,ActorBase::setProcStateFlag,124,_ZN4ksys3act8BaseProc12setStateFlagEj
-0x00000071011bab34,ActorBase::acquire,196,
+0x00000071011bab34,ActorBase::acquire,196,_ZN4ksys3act8BaseProc7acquireERNS0_24ActorLinkConstDataAccessE
 0x00000071011babf8,ActorBase::release,36,_ZN4ksys3act8BaseProc7releaseEv
-0x00000071011bac1c,ActorBase::doDelete,244,
+0x00000071011bac1c,ActorBase::doDelete,244,_ZN4ksys3act8BaseProc12startDelete_Ev
 0x00000071011bad10,ActorBase::preDelete,164,_ZN4ksys3act8BaseProc11doPreDeleteEPb
-0x00000071011badb4,ActorBase::setJobPriority,288,
+0x00000071011badb4,ActorBase::setJobPriority,288,_ZN4ksys3act8BaseProc14setJobPriorityEhNS0_7JobTypeE
-0x00000071011baed4,ActorBase::setJobPriority2,288,
+0x00000071011baed4,ActorBase::setJobPriority2,288,_ZN4ksys3act8BaseProc15setJobPriority2EhNS0_7JobTypeE
-0x00000071011baff4,ActorBase::sleep,308,
+0x00000071011baff4,ActorBase::sleep,308,_ZN4ksys3act8BaseProc5sleepENS1_15SleepWakeReasonE
-0x00000071011bb128,ActorBase::wakeUp,484,
+0x00000071011bb128,ActorBase::wakeUp,484,_ZN4ksys3act8BaseProc6wakeUpENS1_15SleepWakeReasonE
 0x00000071011bb30c,ActorBase::getConnectedCalcChild,32,_ZNK4ksys3act8BaseProc21getConnectedCalcChildEv
 0x00000071011bb32c,ActorBase::setConnectedCalcChild,248,_ZN4ksys3act8BaseProc21setConnectedCalcChildEPS1_b
 0x00000071011bb424,ActorBase::setConnectedCalcParent,248,_ZN4ksys3act8BaseProc22setConnectedCalcParentEPS1_b
 0x00000071011bb51c,ActorBase::resetConnectedCalcChild,188,_ZN4ksys3act8BaseProc23resetConnectedCalcChildEb
 0x00000071011bb5d8,ActorBase::resetConnectedCalcParent,188,_ZN4ksys3act8BaseProc24resetConnectedCalcParentEb
-0x00000071011bb694,sub_71011BB694,12,
+0x00000071011bb694,sub_71011BB694,12,_ZN4ksys3act8BaseProc23setCreatePriorityState1Ev
-0x00000071011bb6a0,ActorBase::setCreatePriorityState2,12,
+0x00000071011bb6a0,ActorBase::setCreatePriorityState2,12,_ZN4ksys3act8BaseProc23setCreatePriorityState2Ev
 0x00000071011bb6ac,ActorBase::rtti1,112,_ZNK4ksys3act8BaseProc27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
 0x00000071011bb71c,ActorBase::rtti2,92,_ZNK4ksys3act8BaseProc18getRuntimeTypeInfoEv
 0x00000071011bb778,_ZN4ksys3act8BaseProc20prepareForPreDelete_Ev,8,_ZN4ksys3act8BaseProc20prepareForPreDelete_Ev

lib/sead

@@ -1 +1 @@
-Subproject commit ac3d8764bba7dedeea62ce0d6841b0f801111321
+Subproject commit f85c9358c5f043bd5e6febecd5c31f55e7f5018e

src/KingSystem/ActorSystem/actActorLimiter.cpp

@@ -46,7 +46,7 @@ bool ActorLimiter::List::addActor(BaseProc* proc, bool allow_evicting_old_actors
                     acquireActor(&target_node->proc_link, &acc);
             }
 
-            acc.deleteEx(BaseProc::DeleteReason::_15);
+            acc.deleteEx(BaseProc::DeleteReason::_f);
         }
 
         if (target_node == nullptr)

src/KingSystem/ActorSystem/actActorLinkConstDataAccess.h

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

src/KingSystem/ActorSystem/actBaseProc.cpp

@@ -1,4 +1,7 @@
 #include "KingSystem/ActorSystem/actBaseProc.h"
+#include <thread/seadThread.h>
+#include <time/seadTickSpan.h>
+#include "KingSystem/ActorSystem/actActorLinkConstDataAccess.h"
 #include "KingSystem/ActorSystem/actBaseProcJobHandler.h"
 #include "KingSystem/ActorSystem/actBaseProcLink.h"
 #include "KingSystem/ActorSystem/actBaseProcMgr.h"
@@ -47,6 +50,50 @@ bool BaseProc::init(sead::Heap* heap, bool sleep_after_init) {
     return context.result == InitResult::Ok && mStateFlags.isOff(StateFlags::RequestDelete);
 }
 
+void BaseProc::sleep(BaseProc::SleepWakeReason reason) {
+    if (isDeletedOrDeleting())
+        return;
+
+    const auto lock = sead::makeScopedLock(BaseProcMgr::instance()->getProcUpdateStateListCS());
+
+    const bool reason_changed = mFlags.getStorage().setBitOn(int(reason) + 10);
+    const auto state = mState;
+
+    bool requested = mStateFlags.reset(StateFlags::RequestWakeUp);
+    if (state != State::Sleep)
+        requested = BaseProcMgr::instance()->setProcFlag(*this, StateFlags::RequestSleep);
+
+    if (reason_changed || requested)
+        onSleepRequested_(reason);
+}
+
+void BaseProc::wakeUp(BaseProc::SleepWakeReason reason) {
+    if (isDeletedOrDeleting())
+        return;
+
+    const auto lock = sead::makeScopedLock(BaseProcMgr::instance()->getProcUpdateStateListCS());
+
+    const bool reason_changed = mFlags.getStorage().setBitOff(int(reason) + 10);
+    if (mFlags.isOn(Flags::SleepWakeReasonAny)) {
+        if (reason_changed)
+            onWakeUpRequested_(reason);
+    } else if (isInit() || isSleep()) {
+        mStateFlags.reset(StateFlags::RequestSleep);
+        bool requested = BaseProcMgr::instance()->setProcFlag(*this, StateFlags::RequestWakeUp);
+        if (reason_changed || requested)
+            onWakeUpRequested_(reason);
+    } else {
+        bool cancelled_sleep = mStateFlags.reset(StateFlags::RequestSleep);
+        if (reason_changed || cancelled_sleep)
+            onWakeUpRequested_(reason);
+    }
+
+    if (mProcUnit && !mProcUnit->isParentHandleDefault()) {
+        sead::FixedSafeString<0x100> message;
+        message.format("BaseProcUnit:%p BaseProc(%s:%p)", mProcUnit, mName.cstr(), this);
+    }
+}
+
 bool BaseProc::deleteLater(DeleteReason reason) {
     if (isDeletedOrDeleting())
         return false;
@@ -66,7 +113,7 @@ bool BaseProc::deleteLater(DeleteReason reason) {
         }
     }
 
-    if (!BaseProcMgr::instance()->addToUpdateStateList(*this, StateFlags::RequestDelete))
+    if (BaseProcMgr::instance()->setProcFlag(*this, StateFlags::RequestDelete))
         onDeleteRequested_(reason);
 
     if (!is_high_prio)
@@ -161,6 +208,23 @@ BaseProc::IsSpecialJobTypeResult BaseProc::isSpecialJobType_(JobType type) {
     return IsSpecialJobTypeResult::No;
 }
 
+bool BaseProc::isSpecialJobType(JobType type) {
+    if (isSpecialJobType_(type) != IsSpecialJobTypeResult::No)
+        return true;
+
+    const auto check = [&](auto self, BaseProc* proc) {
+        if (!proc)
+            return false;
+        const auto result = proc->isSpecialJobType_(type);
+        if (result == IsSpecialJobTypeResult::Yes)
+            return true;
+        if (result == IsSpecialJobTypeResult::_2)
+            return false;
+        return self(self, proc->mConnectedCalcParent);
+    };
+    return check(check, mConnectedCalcParent);
+}
+
 bool BaseProc::canWakeUp_() {
     return true;
 }
@@ -170,6 +234,56 @@ void BaseProc::queueExtraJobPush_(JobType type) {
         BaseProcMgr::instance()->queueExtraJobPush(&mJobHandlers[int(type)]->getLink());
 }
 
+bool BaseProc::shouldSkipJobPush(JobType type) {
+    bool skip = mSkippedJobTypesMask.isOnBit(int(type)) || shouldSkipJobPush_(type);
+
+    BaseProc* proc = this;
+    while ((proc = proc->mConnectedCalcParent)) {
+        if (proc->getState() == State::Delete)
+            break;
+        skip = proc->mSkippedJobTypesMask.isOnBit(int(type)) || proc->shouldSkipJobPush_(type);
+    }
+    return skip;
+}
+
+inline void BaseProc::setJobPriorityDuringCalc_(BaseProcJobHandler*& handler, JobType type) {
+    BaseProcMgr* mgr = BaseProcMgr::instance();
+    if (mgr->isPushingJobs() || mgr->getJobType() == type) {
+        mgr->setProcFlag(*this, StateFlags::RequestChangeCalcJobPriority);
+    } else {
+        BaseProcMgr::instance()->eraseJob(*this, type);
+        handler->getLink().loadNewPriority();
+        handler->getLink().loadNewPriority2();
+        BaseProcMgr::instance()->pushJob(*this, type);
+    }
+}
+
+void BaseProc::setJobPriority(u8 actorparam_priority, JobType type) {
+    if (isDeletedOrDeleting())
+        return;
+
+    auto& handler = mJobHandlers[int(type)];
+    handler->getLink().setNewPriority(actorparam_priority);
+    if (isCalc()) {
+        setJobPriorityDuringCalc_(handler, type);
+    } else {
+        handler->getLink().loadNewPriority();
+    }
+}
+
+void BaseProc::setJobPriority2(u8 actorparam_priority, JobType type) {
+    if (isDeletedOrDeleting())
+        return;
+
+    auto& handler = mJobHandlers[int(type)];
+    handler->getLink().setNewPriority2(actorparam_priority);
+    if (isCalc()) {
+        setJobPriorityDuringCalc_(handler, type);
+    } else {
+        handler->getLink().loadNewPriority2();
+    }
+}
+
 bool BaseProc::hasJobType_(JobType type) {
     return mJobHandlers[int(type)] != nullptr;
 }
@@ -187,6 +301,51 @@ void BaseProc::onJobPush1_(JobType) {}
 
 void BaseProc::onJobPush2_(JobType) {}
 
+void BaseProc::jobInvoked(JobType type) {
+    for (auto* proc = mConnectedCalcParent; proc; proc = proc->mConnectedCalcParent) {
+        if (proc->hasJobType_(type))
+            return;
+    }
+
+    IsSpecialJobTypeResult special;
+
+    if (mStateFlags.isOn(StateFlags::RequestDelete)) {
+        if (type == JobType::Calc4)
+            mJobHandlers[4]->invoke();
+        special = IsSpecialJobTypeResult::Yes;
+    } else {
+        special = isSpecialJobType_(type);
+        auto* handler = mJobHandlers[int(type)];
+        if (special != IsSpecialJobTypeResult::No)
+            handler->invokeSpecial();
+        else
+            handler->invoke();
+    }
+
+    for (auto* child = mConnectedCalcChild; child; child = child->mConnectedCalcChild) {
+        if (!child->hasJobType_(type) || !child->isCalc())
+            continue;
+
+        const auto child_special = child->isSpecialJobType_(type);
+        if (child->mStateFlags.isOn(StateFlags::RequestDelete)) {
+            if (type == JobType::Calc4)
+                child->mJobHandlers[4]->invoke();
+            special = IsSpecialJobTypeResult::Yes;
+        } else {
+            auto* handler = child->mJobHandlers[int(type)];
+            if (special == IsSpecialJobTypeResult::Yes ||
+                child_special != IsSpecialJobTypeResult::No) {
+                handler->invokeSpecial();
+                special = child_special != IsSpecialJobTypeResult::No ? child_special :
+                                                                        IsSpecialJobTypeResult::Yes;
+            } else {
+                handler->invoke();
+                special = IsSpecialJobTypeResult::No;
+            }
+        }
+    }
+}
+
 // NON_MATCHING: branching
 bool BaseProc::processStateUpdate(u8 counter) {
     const bool delete_requested = mStateFlags.isOn(StateFlags::RequestDelete);
@@ -312,6 +471,10 @@ void BaseProc::processPreDelete() {
     }
 }
 
+void BaseProc::freeLinkData() {
+    BaseProcLinkDataMgr::instance()->releaseLink(this);
+}
+
 void BaseProc::doPreDelete(bool* do_not_destruct_immediately) {
     preDelete1_();
     preDelete2_(do_not_destruct_immediately);
@@ -425,11 +588,81 @@ bool BaseProc::x00000071011ba9fc() {
     return true;
 }
 
+bool BaseProc::setStateFlag(u32 flag_bit) {
+    return BaseProcMgr::instance()->setProcFlag(*this, flag_bit);
+}
+
+bool BaseProc::acquire(ActorLinkConstDataAccess& accessor) {
+    if (mState == State::Delete)
+        return false;
+
+    if (!BaseProcMgr::instance()->isHighPriorityThread()) {
+        int ref_count = std::max(0, mRefCount.load());
+        int current_ref_count;
+        while (!mRefCount.compareExchange(ref_count, ref_count + 1, &current_ref_count)) {
+            if (current_ref_count == -1)
+                return false;
+
+            sead::TickSpan span;
+            span.setNanoSeconds(1);
+            sead::Thread::sleep(span);
+            ref_count = current_ref_count;
+        }
+        accessor.mAcquired = true;
+    }
+
+    accessor.mProc = this;
+    return true;
+}
+
 void BaseProc::release() {
     if (mRefCount >= 1)
         mRefCount--;
 }
 
+void BaseProc::startDelete_() {
+    BaseProcMgr::instance()->incrementPendingDeletions();
+
+    mState = State::Delete;
+
+    if (mConnectedCalcChildNew) {
+        if (mFlags.isOn(Flags::DeleteChildOnDelete))
+            mConnectedCalcChildNew->deleteLater(DeleteReason::_18);
+        mConnectedCalcChildNew = nullptr;
+    }
+
+    if (mConnectedCalcParentNew) {
+        if (mFlags.isOn(Flags::DeleteParentOnDelete))
+            mConnectedCalcParentNew->deleteLater(DeleteReason::_19);
+        mConnectedCalcParentNew = nullptr;
+    }
+
+    if (mConnectedCalcChild) {
+        if (mFlags.isOn(Flags::DeleteChildOnDelete))
+            mConnectedCalcChild->deleteLater(DeleteReason::_16);
+        if (mConnectedCalcChild) {
+            mConnectedCalcChild->mConnectedCalcParent = nullptr;
+            mConnectedCalcChild = nullptr;
+        }
+    }
+
+    if (mConnectedCalcParent) {
+        if (mFlags.isOn(Flags::DeleteParentOnDelete))
+            mConnectedCalcParent->deleteLater(DeleteReason::_17);
+        if (auto& child = mConnectedCalcParent->mConnectedCalcChild) {
+            child->mConnectedCalcParent = nullptr;
+            child = nullptr;
+        }
+    }
+
+    if (mProcUnit) {
+        mProcUnit->cleanUp(this, false);
+        mProcUnit = nullptr;
+    }
+
+    onEnterDelete_();
+}
+
 BaseProc* BaseProc::getConnectedCalcParent() const {
     if (mConnectedCalcParent == nullptr || mConnectedCalcParent->mState == State::Delete)
         return nullptr;
@@ -444,7 +677,7 @@ bool BaseProc::setConnectedCalcParent(BaseProc* parent, bool delete_parent_on_de
     if (isDeletedOrDeleting() || parent->isDeletedOrDeleting())
         return false;
 
-    if (BaseProcMgr::instance()->addToUpdateStateList(*this, StateFlags::RequestSetParent))
+    if (!BaseProcMgr::instance()->setProcFlag(*this, StateFlags::RequestSetParent))
         return false;
 
     mConnectedCalcParentNew = parent;
@@ -464,7 +697,7 @@ void BaseProc::resetConnectedCalcParent(bool clear_existing_set_request) {
     }
 
     if (mConnectedCalcParent)
-        BaseProcMgr::instance()->addToUpdateStateList(*this, StateFlags::RequestResetParent);
+        BaseProcMgr::instance()->setProcFlag(*this, StateFlags::RequestResetParent);
 }
 
 BaseProc* BaseProc::getConnectedCalcChild() const {
@@ -481,7 +714,7 @@ bool BaseProc::setConnectedCalcChild(BaseProc* child, bool delete_child_on_delet
     if (isDeletedOrDeleting() || child->isDeletedOrDeleting())
         return false;
 
-    if (BaseProcMgr::instance()->addToUpdateStateList(*this, StateFlags::RequestSetChild))
+    if (!BaseProcMgr::instance()->setProcFlag(*this, StateFlags::RequestSetChild))
         return false;
 
     mConnectedCalcChildNew = child;
@@ -501,7 +734,15 @@ void BaseProc::resetConnectedCalcChild(bool clear_existing_set_request) {
     }
 
     if (mConnectedCalcChild)
-        BaseProcMgr::instance()->addToUpdateStateList(*this, StateFlags::RequestResetChild);
+        BaseProcMgr::instance()->setProcFlag(*this, StateFlags::RequestResetChild);
+}
+
+void BaseProc::setCreatePriorityState1() {
+    mCreatePriorityState = 1;
+}
+
+void BaseProc::setCreatePriorityState2() {
+    mCreatePriorityState = 2;
 }
 
 }  // namespace ksys::act

src/KingSystem/ActorSystem/actBaseProc.h

@@ -15,9 +15,7 @@
 #include "KingSystem/Utils/StrTreeMap.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys {
+namespace ksys::act {
-
-namespace act {
 
 class ActorLinkConstDataAccess;
 class BaseProc;
@@ -44,7 +42,12 @@ public:
         _0 = 0,
         _1 = 1,
         _2 = 2,
-        _15 = 15,
+        _f = 0xf,
+        _15 = 0x15,
+        _16 = 0x16,
+        _17 = 0x17,
+        _18 = 0x18,
+        _19 = 0x19,
     };
 
     enum class SleepWakeReason : u32 {
@@ -115,8 +118,9 @@ public:
     void setJobPriority(u8 actorparam_priority, JobType type);
     void setJobPriority2(u8 actorparam_priority, JobType type);
 
+    void setCreatePriorityState1();
     void setCreatePriorityState2();
-    bool setStateFlag(u8 idx);
+    bool setStateFlag(u32 flag_bit);
 
 protected:
     friend class BaseProcLinkDataMgr;
@@ -134,6 +138,11 @@ protected:
         _100 = 0x100,
         PreDeleting = 0x200,
         SleepWakeReason0 = 0x400,
+        SleepWakeReason1 = 0x800,
+        SleepWakeReason2 = 0x1000,
+        SleepWakeReason3 = 0x2000,
+        SleepWakeReasonAny =
+            SleepWakeReason0 | SleepWakeReason1 | SleepWakeReason2 | SleepWakeReason3,
     };
 
     enum class StateFlags : u32 {
@@ -291,12 +300,12 @@ private:
     void handleWakeUpRequest_();
     void handleJobPriorityChangeRequest_();
 
+    void setJobPriorityDuringCalc_(BaseProcJobHandler*& handler, JobType type);
+
     bool canWakeUpOrFlagsSet_() {
         return mFlags.isOn(Flags::_80) ? mFlags.isOn(Flags::_100) : canWakeUp_();
     }
 };
 KSYS_CHECK_SIZE_NX150(BaseProc, 0x180);
 
-}  // namespace act
+}  // namespace ksys::act
-
-}  // namespace ksys

src/KingSystem/ActorSystem/actBaseProcJobHandler.h

@@ -7,7 +7,7 @@ namespace ksys::act {
 
 class BaseProcJobHandler {
 public:
-    BaseProcJobHandler(BaseProc* proc);
+    explicit BaseProcJobHandler(BaseProc* proc);
     virtual ~BaseProcJobHandler() = default;
     virtual void invoke() = 0;
     virtual void invokeSpecial() {}

src/KingSystem/ActorSystem/actBaseProcMgr.h

@@ -70,7 +70,10 @@ public:
     void unregisterProc(BaseProc& proc);
 
     void addToPreDeleteList(BaseProc& proc);
-    bool addToUpdateStateList(BaseProc& proc, BaseProc::StateFlags flags);
+    /// @return whether the flag was not set prior to this call and is now set.
+    bool setProcFlag(BaseProc& proc, BaseProc::StateFlags flag);
+    /// @return whether the flag was not set prior to this call and is now set.
+    bool setProcFlag(BaseProc& proc, u32 flag_bit);
     void eraseFromPreDeleteList(BaseProc& proc);
     void eraseFromUpdateStateList(BaseProc& proc);
     void processPreDeleteList();
@@ -161,7 +164,9 @@ public:
     void decrementPendingDeletions() { mNumPendingDeletions.decrement(); }
 
     Status getStatus() const { return mStatus; }
+    JobType getJobType() const { return mJobType; }
     u32 getNumJobTypes() const { return mNumJobTypes; }
+    bool isPushingJobs() const { return mIsPushingJobs; }
 
     bool checkGetActorOk(BaseProc* proc, void* a2);
 
@@ -213,10 +218,16 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(BaseProcMgr, 0x21a0);
 
-inline bool BaseProcMgr::addToUpdateStateList(BaseProc& proc, BaseProc::StateFlags flag) {
+inline bool BaseProcMgr::setProcFlag(BaseProc& proc, BaseProc::StateFlags flag) {
     auto lock = sead::makeScopedLock(mProcUpdateStateListCS);
     doAddToUpdateStateList_(proc);
-    return (proc.mStateFlags.set(flag) & u32(flag)) != 0;
+    return proc.mStateFlags.set(flag);
+}
+
+inline bool BaseProcMgr::setProcFlag(BaseProc& proc, u32 flag_bit) {
+    auto lock = sead::makeScopedLock(mProcUpdateStateListCS);
+    doAddToUpdateStateList_(proc);
+    return proc.mStateFlags.getStorage().setBitOn(flag_bit);
 }
 
 }  // namespace ksys::act