#1 - quicr module

modules/mock_client/src/main.cpp

@@ -1,24 +1,43 @@
 #include "Address.hpp"
 #include "Login.pb.h"
 #include "PlayerMove.pb.h"
-#include "TcpStream.hpp"
+#include "ProtobufMessages.hpp"
 #include "WorldState.pb.h"
-#include "messenger/MessageHandler.hpp"
-#include "messenger/Messenger.hpp"
+#include "message_protocol/MessageEndpoint.hpp"
 #include "runtime/LockStep.hpp"
 
 #include <chrono>
 #include <cstdlib>
+#include <memory>
 #include <semaphore>
 #include <thread>
+#include <vector>
 #include <glm/glm.hpp>
 
-tw::net::MessageHandler create_messenger(tw::net::Address& address) {
-    return tw::net::MessageHandler(address);
+static std::unique_ptr<tw::msg::MessageEndpoint> create_endpoint() {
+    auto endpoint_r = tw::msg::MessageEndpoint::create();
+    if(!endpoint_r) {
+        throw std::runtime_error("Failed to create the endpoint: " + endpoint_r.error().message());
+    }
+
+    return std::move(endpoint_r.value());
+}
+
+static tw::msg::MessageConnection* connect_to_server(tw::msg::MessageEndpoint* endpoint,
+                                                     tw::net::Address          address) {
+    auto server_r = endpoint->connect(address.ip_string(), address.port());
+    if(!server_r) {
+        throw std::runtime_error("Failed to connect to server: " + server_r.error().message());
+    }
+
+    return server_r.value();
 }
 
 class MockClient {
-    tw::net::MessageHandler m_handler;
+    std::unique_ptr<tw::msg::MessageEndpoint> m_endpoint;
+    tw::msg::MessageConnection*               m_server;
+    tw::ProtobufMessages                      m_messages;
+
     tw::LockStep m_lock_step;
 
     uint32_t m_frame_idx;
@@ -33,28 +52,30 @@ class MockClient {
 
 public:
     MockClient(tw::net::Address address, const std::string& name) :
-        m_handler(create_messenger(address)),
+        m_endpoint(create_endpoint()),
+        m_server(connect_to_server(m_endpoint.get(), address)),
+        m_messages(m_endpoint.get()),
         m_lock_step(20),
         m_is_running(true),
         m_is_connected(false),
         m_connected_semaphore(0)
     {
-        m_handler.set_handler<mmo::WorldStateMessage>(
-            [&](mmo::WorldStateMessage* mesg) { });
+        m_messages.set_handler<mmo::WorldStateMessage>(
+            [this](tw::msg::PeerId, const mmo::WorldStateMessage& mesg) { });
 
-        m_handler.set_handler<mmo::LoginResponse>(
-            [&](mmo::LoginResponse* mesg) {
+        m_messages.set_handler<mmo::LoginResponse>(
+            [this](tw::msg::PeerId, const mmo::LoginResponse& mesg) {
                 if(!m_is_connected) {
                     m_is_connected = true;
-                    m_entity_id = mesg->entity_id();
+                    m_entity_id = mesg.entity_id();
                     m_connected_semaphore.release();
                 }
             });
     }
 
     void run() {
-        while(!m_handler.is_connected()) {
-            m_handler.update();
+        while(!m_server->is_established()) {
+            m_endpoint->update();
             std::this_thread::sleep_for(std::chrono::milliseconds(10));
         }
 
@@ -67,7 +88,7 @@ public:
                 continue;
             }
 
-            m_handler.update();
+            m_endpoint->update();
             value += (float)std::rand() / RAND_MAX;
 
             m_velocity.x = glm::sin(value);
@@ -81,7 +102,7 @@ public:
             player_input->set_y(0);
             player_input->set_z(m_velocity.z);
             player_move_mesg.set_allocated_input(player_input);
-            auto r = m_handler.send(player_move_mesg);
+            auto r = m_messages.send(m_server, player_move_mesg, false);
         }
     }
 };