ksys: Add ActorMessageTransceiver

src/KingSystem/ActorSystem/actActor.h

@@ -33,6 +33,7 @@ public:
         _18 = 0x18,
         _25 = 0x25,
         _2b = 0x2b,
+        _2e = 0x2e,
     };
 
     enum class DeleteType {

src/KingSystem/Utils/CMakeLists.txt

@@ -1,4 +1,6 @@
 target_sources(uking PRIVATE
+  Thread/ActorMessageTransceiver.cpp
+  Thread/ActorMessageTransceiver.h
   Thread/Event.cpp
   Thread/Event.h
   Thread/GameTaskThread.cpp

src/KingSystem/Utils/Thread/ActorMessageTransceiver.cpp

@@ -0,0 +1,62 @@
+#include "KingSystem/Utils/Thread/ActorMessageTransceiver.h"
+#include "KingSystem/ActorSystem/actActor.h"
+#include "KingSystem/Utils/Thread/MessageTransceiverCommon.h"
+
+namespace ksys {
+
+ActorMessageTransceiver::ActorMessageTransceiver(IHandler& handler) : mReceiver(handler) {
+    registerReceiver(mReceiver);
+}
+
+ActorMessageTransceiver::ActorMessageTransceiver(IHandler& handler, act::Actor* actor)
+    : mReceiver(handler), mActor(actor) {
+    registerReceiver(mReceiver);
+}
+
+ActorMessageTransceiver::~ActorMessageTransceiver() {
+    deregisterReceiver(mReceiver);
+}
+
+bool ActorMessageTransceiver::getDebugArg(bool ack) const {
+    return mActor && mActor->checkFlag(act::Actor::ActorFlag::_2e) && ack;
+}
+
+bool ActorMessageTransceiver::sendMessage(const MesTransceiverId& dest, const MessageType& type,
+                                          void* user_data, bool ack) {
+    return sendMessageImpl(this, dest, type, user_data, ack, getDebugArg(ack));
+}
+
+bool ActorMessageTransceiver::sendMessageOnProcessingThread(const MesTransceiverId& dest,
+                                                            const MessageType& type,
+                                                            void* user_data, bool ack) {
+    return sendMessageOnProcessingThreadImpl(this, dest, type, user_data, ack, getDebugArg(ack));
+}
+
+bool ActorMessageTransceiver::sendMessage(IMessageBroker& broker, const MessageType& type,
+                                          void* user_data, bool ack) {
+    return sendMessageImpl(this, broker, type, user_data, ack, getDebugArg(ack));
+}
+
+bool ActorMessageTransceiver::sendMessageOnProcessingThread(IMessageBroker& broker,
+                                                            const MessageType& type,
+                                                            void* user_data, bool ack) {
+    return sendMessageOnProcessingThreadImpl(this, broker, type, user_data, ack, getDebugArg(ack));
+}
+
+MessageReceiverEx* ActorMessageTransceiver::getReceiver() {
+    return &mReceiver;
+}
+
+ActorMessageTransceiver::Receiver::Receiver(IHandler& handler) : mHandler(handler) {}
+
+ActorMessageTransceiver::Receiver::~Receiver() = default;
+
+int ActorMessageTransceiver::Receiver::handleMessage(const Message& message) {
+    return mHandler.handleMessage(message);
+}
+
+void ActorMessageTransceiver::Receiver::handleAck(const MessageAck& ack) {
+    return mHandler.handleAck(ack);
+}
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/ActorMessageTransceiver.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "KingSystem/Utils/Thread/MessageTransceiverBase.h"
+#include "KingSystem/Utils/Thread/MessageTransceiverRxOnly.h"
+#include "KingSystem/Utils/Thread/MessageTransceiverTxOnly.h"
+
+namespace ksys {
+
+namespace act {
+class Actor;
+}
+
+class ActorMessageTransceiver final : public MessageTransceiverBase {
+public:
+    class IHandler : public MessageTransceiverRxOnly::IHandler,
+                     public MessageTransceiverTxOnly::IHandler {};
+    KSYS_CHECK_SIZE_NX150(IHandler, 0x10);
+
+    explicit ActorMessageTransceiver(IHandler& handler);
+    explicit ActorMessageTransceiver(IHandler& handler, act::Actor* actor);
+    ~ActorMessageTransceiver() override;
+    bool sendMessage(const MesTransceiverId& dest, const MessageType& type, void* user_data,
+                     bool ack) override;
+    bool sendMessageOnProcessingThread(const MesTransceiverId& dest, const MessageType& type,
+                                       void* user_data, bool ack) override;
+    bool sendMessage(IMessageBroker& broker, const MessageType& type, void* user_data,
+                     bool ack) override;
+    bool sendMessageOnProcessingThread(IMessageBroker& broker, const MessageType& type,
+                                       void* user_data, bool ack) override;
+    MessageReceiverEx* getReceiver() override;
+
+private:
+    class Receiver : public MessageReceiverEx {
+        SEAD_RTTI_OVERRIDE(Receiver, MessageReceiverEx)
+    public:
+        explicit Receiver(IHandler& handler);
+        ~Receiver() override;
+        int handleMessage(const Message& message) override;
+        void handleAck(const MessageAck& ack) override;
+
+    private:
+        IHandler& mHandler;
+    };
+
+    // TODO: rename if we figure out what this is used for
+    bool getDebugArg(bool ack) const;
+
+    Receiver mReceiver;
+    act::Actor* mActor{};
+};
+
+}  // namespace ksys

src/KingSystem/Utils/Thread/MessageTransceiverCommon.h

@@ -7,10 +7,10 @@ namespace ksys {
 
 template <class T>
 bool sendMessageImpl(T* transceiver, const MesTransceiverId& dest, const MessageType& type,
-                     void* user_data, bool ack) {
+                     void* user_data, bool ack, bool x = false) {
     MessageDispatcherBase* dispatcher = transceiver->getDispatcher();
     const bool ok = dispatcher->sendMessage(*transceiver->getReceiver()->MessageReceiver::getId(),
-                                            dest, type, user_data, ack, false);
+                                            dest, type, user_data, ack, x);
 
     if (ok)
         transceiver->getReceiver()->setFlag(ack);
@@ -20,10 +20,11 @@ bool sendMessageImpl(T* transceiver, const MesTransceiverId& dest, const Message
 
 template <class T>
 bool sendMessageOnProcessingThreadImpl(T* transceiver, const MesTransceiverId& dest,
-                                       const MessageType& type, void* user_data, bool ack) {
+                                       const MessageType& type, void* user_data, bool ack,
+                                       bool x = false) {
     MessageDispatcherBase* dispatcher = transceiver->getDispatcher();
     const bool ok = dispatcher->sendMessageOnProcessingThread(
-        *transceiver->getReceiver()->MessageReceiver::getId(), dest, type, user_data, ack, false);
+        *transceiver->getReceiver()->MessageReceiver::getId(), dest, type, user_data, ack, x);
 
     if (ok)
         transceiver->getReceiver()->setFlag(ack);
@@ -33,11 +34,11 @@ bool sendMessageOnProcessingThreadImpl(T* transceiver, const MesTransceiverId& d
 
 template <class T>
 bool sendMessageImpl(T* transceiver, IMessageBroker& broker, const MessageType& type,
-                     void* user_data, bool ack) {
+                     void* user_data, bool ack, bool x = false) {
     MessageDispatcherBase* dispatcher = transceiver->getDispatcher();
     const bool ok =
         dispatcher->sendMessage(*transceiver->getReceiver()->MessageReceiver::getId(),
-                                *transceiver->getRegister(broker), type, user_data, ack, false);
+                                *transceiver->getRegister(broker), type, user_data, ack, x);
 
     if (ok) {
         for (int i = 0, n = broker.countTransceivers(); i < n; ++i)
@@ -49,11 +50,12 @@ bool sendMessageImpl(T* transceiver, IMessageBroker& broker, const MessageType&
 
 template <class T>
 bool sendMessageOnProcessingThreadImpl(T* transceiver, IMessageBroker& broker,
-                                       const MessageType& type, void* user_data, bool ack) {
+                                       const MessageType& type, void* user_data, bool ack,
+                                       bool x = false) {
     MessageDispatcherBase* dispatcher = transceiver->getDispatcher();
     const bool ok = dispatcher->sendMessageOnProcessingThread(
         *transceiver->getReceiver()->MessageReceiver::getId(), *transceiver->getRegister(broker),
-        type, user_data, ack, false);
+        type, user_data, ack, x);
 
     if (ok) {
         for (int i = 0, n = broker.countTransceivers(); i < n; ++i)