ksys: Add more message system classes

src/KingSystem/Utils/Thread/MessageDispatcherBase.cpp

@@ -1,5 +1,5 @@
 #include "KingSystem/Utils/Thread/MessageDispatcherBase.h"
-#include "KingSystem/Utils/Thread/MessageTransceiver.h"
+#include "KingSystem/Utils/Thread/MessageTransceiverBase.h"
 
 namespace ksys {
 
@@ -8,7 +8,7 @@ MessageDispatcherBase::MessageDispatcherBase() = default;
 MessageDispatcherBase::~MessageDispatcherBase() = default;
 
 void MessageDispatcherBase::setAsGlobalInstance() {
-    MessageTransceiver::setGlobalDispatcher(this);
+    MessageTransceiverBase::setGlobalDispatcher(this);
 }
 
 }  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiver.cpp

@@ -1,33 +0,0 @@
-#include "KingSystem/Utils/Thread/MessageTransceiver.h"
-
-namespace ksys {
-
-MessageTransceiver::MessageTransceiver() = default;
-
-MessageTransceiver::~MessageTransceiver() = default;
-
-bool MessageTransceiver::m2() {
-    return false;
-}
-
-bool MessageTransceiver::m3() {
-    return false;
-}
-
-bool MessageTransceiver::m4() {
-    return false;
-}
-
-bool MessageTransceiver::m5() {
-    return false;
-}
-
-MessageDispatcherBase* MessageTransceiver::getDispatcher() {
-    return mDispatcher;
-}
-
-void MessageTransceiver::setGlobalDispatcher(MessageDispatcherBase* dispatcher) {
-    sDispatcher = dispatcher;
-}
-
-}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverBase.cpp

@@ -0,0 +1,44 @@
+#include "KingSystem/Utils/Thread/MessageTransceiverBase.h"
+#include "KingSystem/Utils/Thread/MessageTransceiverIdGenEx.h"
+
+namespace ksys {
+
+MessageDispatcherBase* MessageTransceiverBase::sDispatcher{};
+
+MessageTransceiverBase::MessageTransceiverBase() = default;
+
+MessageTransceiverBase::~MessageTransceiverBase() = default;
+
+bool MessageTransceiverBase::checkGeneratorFlag() const {
+    return getGenerator()->checkFlag();
+}
+
+bool MessageTransceiverBase::checkGeneratorCounter() const {
+    return getGenerator()->checkCounter();
+}
+
+bool MessageTransceiverBase::m2() {
+    return false;
+}
+
+bool MessageTransceiverBase::m3() {
+    return false;
+}
+
+bool MessageTransceiverBase::m4() {
+    return false;
+}
+
+bool MessageTransceiverBase::m5() {
+    return false;
+}
+
+MessageDispatcherBase* MessageTransceiverBase::getDispatcher() {
+    return mDispatcher;
+}
+
+void MessageTransceiverBase::setGlobalDispatcher(MessageDispatcherBase* dispatcher) {
+    sDispatcher = dispatcher;
+}
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverBase.h

@@ -6,18 +6,19 @@ namespace ksys {
 
 class MessageDispatcherBase;
 struct MesTransceiverId;
+class MesTransceiverIdGenEx;
 
-class MessageTransceiver {
+class MessageTransceiverBase {
 public:
-    MessageTransceiver();
-    virtual ~MessageTransceiver();
-    bool checkX();
-    bool checkY();
+    MessageTransceiverBase();
+    virtual ~MessageTransceiverBase();
+    bool checkGeneratorFlag() const;
+    bool checkGeneratorCounter() const;
     virtual bool m2();
     virtual bool m3();
     virtual bool m4();
     virtual bool m5();
-    virtual void* getSomePtr() = 0;
+    virtual MesTransceiverIdGenEx* getGenerator() const = 0;
     MessageDispatcherBase* getDispatcher();
 
     static void setGlobalDispatcher(MessageDispatcherBase* dispatcher);

src/KingSystem/Utils/Thread/MessageTransceiverId.h

@@ -6,29 +6,34 @@
 
 namespace ksys {
 
+class MesTransceiverIdGen;
+
 struct MesTransceiverId {
     MesTransceiverId() { reset(); }
+    MesTransceiverId(u32& id, MesTransceiverIdGen* generator)
+        : _0(0xffffffff), id(++id), generator(generator) {}
+
     ~MesTransceiverId() { reset(); }
 
     void reset() {
-        _0 = -1;
-        _4 = -1;
-        _8 = nullptr;
-        _10 = nullptr;
+        _0 = 0xffffffff;
+        id = 0xffffffff;
+        generator = nullptr;
+        next = nullptr;
     }
 
     MesTransceiverId& operator=(const MesTransceiverId& other) {
         _0 = other._0;
-        _4 = other._4;
-        _8 = other._8;
-        _10 = other._10;
+        id = other.id;
+        generator = other.generator;
+        next = other.next;
         return *this;
     }
 
-    s32 _0{};
-    s32 _4{};
-    void* _8{};
-    void* _10{};
+    u32 _0{};
+    u32 id{};
+    MesTransceiverIdGen* generator{};
+    MesTransceiverId** next{};
 };
 KSYS_CHECK_SIZE_NX150(MesTransceiverId, 0x18);
 

src/KingSystem/Utils/Thread/MessageTransceiverIdGen.cpp

@@ -0,0 +1,21 @@
+#include "KingSystem/Utils/Thread/MessageTransceiverIdGen.h"
+
+namespace ksys {
+
+u32 MesTransceiverIdGen::sId{};
+
+MesTransceiverIdGen::MesTransceiverIdGen() : mTransceiverId(sId, this) {}
+
+MesTransceiverIdGen::~MesTransceiverIdGen() = default;
+
+MesTransceiverId* MesTransceiverIdGen::getId() {
+    return &mTransceiverId;
+}
+
+bool MesTransceiverIdGen::m1(void*) {
+    return true;
+}
+
+void MesTransceiverIdGen::m2(void* x) {}
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverIdGen.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+#include "KingSystem/Utils/Thread/MessageTransceiverId.h"
+
+namespace ksys {
+
+class MesTransceiverIdGen {
+public:
+    MesTransceiverIdGen();
+    virtual ~MesTransceiverIdGen();
+    virtual MesTransceiverId* getId();
+    virtual bool m1(void*);
+    virtual void m2(void* x);
+    virtual void setField0(const u32& value) { mTransceiverId._0 = value; }
+
+protected:
+    MesTransceiverId mTransceiverId;
+
+private:
+    static u32 sId;
+};
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverIdGenEx.cpp

@@ -0,0 +1,53 @@
+#include "KingSystem/Utils/Thread/MessageTransceiverIdGenEx.h"
+
+namespace ksys {
+
+MesTransceiverIdGenEx::MesTransceiverIdGenEx() = default;
+
+MesTransceiverIdGenEx::~MesTransceiverIdGenEx() = default;
+
+bool MesTransceiverIdGenEx::m1(void* x) {
+    return m6(x);
+}
+
+void MesTransceiverIdGenEx::m2(void* x) {
+    m7(x);
+    --mCounter;
+    static_cast<void>(mCounter.load());
+}
+
+bool MesTransceiverIdGenEx::checkFlag() const {
+    return mFlag && *mFlag == 1;
+}
+
+bool MesTransceiverIdGenEx::checkCounter() const {
+    return mCounter > 0;
+}
+
+void MesTransceiverIdGenEx::setFlag(bool update_counter) {
+    if (mFlag) {
+        if (update_counter)
+            mCounter.increment();
+        *mFlag = 1;
+    }
+}
+
+bool MesTransceiverIdGenEx::m6(void* x) {
+    return true;
+}
+
+void MesTransceiverIdGenEx::m7(void* x) {}
+
+void MesTransceiverIdGenEx::setFlagPointer(u8* ptr) {
+    if (ptr) {
+        mFlag = ptr;
+        *mFlag = 0;
+    }
+}
+
+void MesTransceiverIdGenEx::clearFlagPointer() {
+    *mFlag = 0;
+    mFlag = nullptr;
+}
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverIdGenEx.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <prim/seadRuntimeTypeInfo.h>
+#include <thread/seadAtomic.h>
+#include "KingSystem/Utils/Thread/MessageTransceiverIdGen.h"
+
+namespace ksys {
+
+class MesTransceiverIdGenEx : public MesTransceiverIdGen {
+public:
+    MesTransceiverIdGenEx();
+    ~MesTransceiverIdGenEx() override;
+    bool m1(void*) override;
+    void m2(void* x) override;
+
+    bool checkFlag() const;
+    bool checkCounter() const;
+    void setFlag(bool update_counter);
+
+    void setFlagPointer(u8* ptr);
+    void clearFlagPointer();
+
+    SEAD_RTTI_BASE(MesTransceiverIdGenEx)
+
+protected:
+    virtual bool m6(void* x);
+    virtual void m7(void* x);
+
+private:
+    u8* mFlag{};
+    sead::Atomic<s32> mCounter;
+};
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverIdGenExAdapter.cpp

@@ -0,0 +1,18 @@
+#include "KingSystem/Utils/Thread/MessageTransceiverIdGenExAdapter.h"
+
+namespace ksys {
+
+MesTransceiverIdGenExAdapter::MesTransceiverIdGenExAdapter(MesTransceiverIdGen* wrapped)
+    : mGenerator(wrapped) {}
+
+MesTransceiverIdGenExAdapter::~MesTransceiverIdGenExAdapter() = default;
+
+bool MesTransceiverIdGenExAdapter::m6(void* x) {
+    return mGenerator->m1(x);
+}
+
+void MesTransceiverIdGenExAdapter::m7(void* x) {
+    return mGenerator->m2(x);
+}
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverIdGenExAdapter.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/Utils/Thread/MessageTransceiverIdGenEx.h"
+
+namespace ksys {
+
+class MesTransceiverIdGenExAdapter : public MesTransceiverIdGenEx {
+    SEAD_RTTI_OVERRIDE(MesTransceiverIdGenExAdapter, MesTransceiverIdGenEx)
+public:
+    explicit MesTransceiverIdGenExAdapter(MesTransceiverIdGen* wrapped);
+    ~MesTransceiverIdGenExAdapter() override;
+
+protected:
+    bool m6(void* x) override;
+    void m7(void* x) override;
+
+private:
+    MesTransceiverIdGen* mGenerator;
+};
+
+}  // namespace ksys