feat: chat

Code/client/Services/Generic/OverlayClient.cpp

@@ -1,10 +1,12 @@
 #include <TiltedOnlinePCH.h>
 
 #include <OverlayRenderHandler.hpp>
-#include <Services/OverlayClient.h>
 
+#include <Services/OverlayClient.h>
 #include <Services/TransportService.h>
 
+#include <Messages/SendChatMessageRequest.h>
+
 OverlayClient::OverlayClient(TransportService& aTransport, TiltedPhoques::OverlayRenderHandler* apHandler)
     : TiltedPhoques::OverlayClient(apHandler), m_transport(aTransport)
 {
@@ -36,13 +38,26 @@ bool OverlayClient::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser, CefR
         if (eventName == "connect")
         {
             std::string baseIp = eventArgs->GetString(0);
+            if (baseIp == "localhost")
+            {
+                baseIp = "127.0.0.1";
+            }
+
             uint16_t port = eventArgs->GetInt(1) ? eventArgs->GetInt(1) : 10578;
             m_transport.Connect(baseIp + ":" + std::to_string(port));
+            // iAmAToken = eventArgs->GeString(2);
         }
-        if (eventName == "disconnect")
+        else if (eventName == "disconnect")
         {
             m_transport.Close();
         }
+        else if (eventName == "sendMessage")
+        {
+            SendChatMessageRequest messageRequest;
+            messageRequest.ChatMessage = eventArgs->GetString(0).ToString();
+            spdlog::debug("Received Message from UI and will send it to server: " + messageRequest.ChatMessage);
+            m_transport.Send(messageRequest);
+        }
 
         return true;
     }

Code/client/Services/Generic/OverlayService.cpp

@@ -14,12 +14,17 @@
 #include <Services/OverlayClient.h>
 #include <Services/TransportService.h>
 
+#include <Messages/NotifyChatMessageBroadcast.h>
+
+#include <Events/CellChangeEvent.h>
+#include <Events/ConnectedEvent.h>
+#include <Events/DisconnectedEvent.h>
+
 #include <PlayerCharacter.h>
 
 using TiltedPhoques::OverlayRenderHandlerD3D11;
 using TiltedPhoques::OverlayRenderHandler;
 
-
 struct D3D11RenderProvider final : OverlayApp::RenderProvider, OverlayRenderHandlerD3D11::Renderer
 {
     explicit D3D11RenderProvider(RenderSystemD3D11* apRenderSystem) : m_pRenderSystem(apRenderSystem) {}
@@ -50,6 +55,11 @@ struct D3D11RenderProvider final : OverlayApp::RenderProvider, OverlayRenderHand
 OverlayService::OverlayService(World& aWorld, TransportService& transport, entt::dispatcher& aDispatcher)
     : m_world(aWorld), m_transport(transport)
 {
+    m_connectedConnection = aDispatcher.sink<ConnectedEvent>().connect<&OverlayService::OnConnectedEvent>(this);
+    m_disconnectedConnection = aDispatcher.sink<DisconnectedEvent>().connect<&OverlayService::OnDisconnectedEvent>(this);
+    //m_playerListConnection = aDispatcher.sink<NotifyPlayerList>().connect<&OverlayService::OnPlayerList>(this);
+    //m_cellChangeEventConnection = aDispatcher.sink<CellChangeEvent>().connect<&OverlayService::OnCellChangeEvent>(this);
+    m_chatMessageConnection = aDispatcher.sink<NotifyChatMessageBroadcast>().connect<&OverlayService::OnChatMessageReceived>(this);
 }
 
 OverlayService::~OverlayService() noexcept
@@ -148,3 +158,83 @@ void OverlayService::SetVersion(const std::string& acVersion)
     pArguments->SetString(0, acVersion);
     m_pOverlay->ExecuteAsync("versionset", pArguments);
 }
+
+void OverlayService::SendSystemMessage(const std::string& acMessage)
+{
+    if (!m_pOverlay)
+        return;
+
+    auto pArguments = CefListValue::Create();
+    pArguments->SetString(0, acMessage);
+    m_pOverlay->ExecuteAsync("systemmessage", pArguments);
+}
+
+void OverlayService::OnChatMessageReceived(const NotifyChatMessageBroadcast& acMessage) noexcept
+{
+    if (!m_pOverlay)
+        return;
+
+    auto pArguments = CefListValue::Create();
+    pArguments->SetString(0, acMessage.PlayerName.c_str());
+    pArguments->SetString(1, acMessage.ChatMessage.c_str());
+    spdlog::debug("Received Message from Server and gonna send it to UI: " + acMessage.ChatMessage);
+    m_pOverlay->ExecuteAsync("message", pArguments);
+}
+
+void OverlayService::OnConnectedEvent(const ConnectedEvent&) noexcept
+{
+    m_connected = true;
+    m_pOverlay->ExecuteAsync("connect");
+    SendSystemMessage("Successfully connected to server");
+}
+
+void OverlayService::OnDisconnectedEvent(const DisconnectedEvent&) noexcept
+{
+    m_connected = false;
+    m_pOverlay->ExecuteAsync("disconnect");
+    SendSystemMessage("Disconnected from server");
+}
+
+#if 0
+void OverlayService::OnPlayerList(const NotifyPlayerList& acPlayerList) noexcept
+{
+    for (auto& player : acPlayerList.Players)
+    {
+        spdlog::info("[CLIENT] ID: {} - Name: {}", player.first, player.second);
+
+        auto pArguments = CefListValue::Create();
+        pArguments->SetInt(0, player.first);
+        pArguments->SetString(1, player.second.c_str());
+        pArguments->SetInt(2, 7);
+        pArguments->SetString(3, "House");
+        m_pOverlay->ExecuteAsync("playerconnected", pArguments);
+    }
+}
+
+void OverlayService::OnPlayerLeave(const PlayerLeaveEvent& acEvent) noexcept
+{
+    auto pArguments = CefListValue::Create();
+    pArguments->SetInt(0, SERVERID);
+    pArguments->SetString(1, USERNAME);
+    m_pOverlay->ExecuteAsync("playerdisconnected");
+}
+
+void OverlayService::OnCellChangeEvent(const CellChangeEvent& aCellChangeEvent) noexcept
+{
+    spdlog::warn("OnCellChangeEvent ! %s", aCellChangeEvent.Name);
+    // Hacky as fuck... Idk why the first cellchangeevent broke UI. It's not a big deal because when player connected we
+    // force cell changed event But change event come before connected event.
+    static bool firstCellChangeEvent = false;
+    if (!m_pOverlay || !firstCellChangeEvent)
+    {
+        firstCellChangeEvent = true;
+        return;
+    }
+    SendSystemMessage("On Cell change event");
+    auto pArguments = CefListValue::Create();
+    pArguments->SetInt(0, 1);
+    pArguments->SetString(1, aCellChangeEvent.Name);
+    m_pOverlay->ExecuteAsync("setcell", pArguments);
+    spdlog::warn("OnCellChangeEvent end !");
+}
+#endif

Code/encoding/Messages/ClientMessageFactory.h

@@ -43,6 +43,7 @@
 #include <Messages/RequestRespawn.h>
 #include <Messages/SyncExperienceRequest.h>
 #include <Messages/RequestEquipmentChanges.h>
+#include <Messages/SendChatMessageRequest.h>
 
 using TiltedPhoques::UniquePtr;
 
@@ -62,7 +63,7 @@ struct ClientMessageFactory
                                  AssignObjectsRequest, RequestDeathStateChange, ShiftGridCellRequest, RequestOwnershipTransfer,
                                  RequestOwnershipClaim, RequestObjectInventoryChanges, SpellCastRequest, ProjectileLaunchRequest, InterruptCastRequest,
                                  AddTargetRequest, ScriptAnimationRequest, DrawWeaponRequest, MountRequest, NewPackageRequest,
-                                 RequestRespawn, SyncExperienceRequest, RequestEquipmentChanges>;
+                                 RequestRespawn, SyncExperienceRequest, RequestEquipmentChanges, SendChatMessageRequest>;
 
         return s_visitor(std::forward<T>(func));
     }

Code/encoding/Messages/NotifyChatMessageBroadcast.cpp

@@ -0,0 +1,15 @@
+#include <Messages/NotifyChatMessageBroadcast.h>
+
+void NotifyChatMessageBroadcast::SerializeRaw(TiltedPhoques::Buffer::Writer& aWriter) const noexcept
+{
+    Serialization::WriteString(aWriter, PlayerName);
+    Serialization::WriteString(aWriter, ChatMessage);
+}
+
+void NotifyChatMessageBroadcast::DeserializeRaw(TiltedPhoques::Buffer::Reader& aReader) noexcept
+{
+    ServerMessage::DeserializeRaw(aReader);
+
+    PlayerName = Serialization::ReadString(aReader);
+    ChatMessage = Serialization::ReadString(aReader);
+}

Code/encoding/Messages/NotifyChatMessageBroadcast.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "Message.h"
+
+using TiltedPhoques::String;
+
+struct NotifyChatMessageBroadcast final : ServerMessage
+{
+    static constexpr ServerOpcode Opcode = kNotifyChatMessageBroadcast;
+
+    NotifyChatMessageBroadcast() : ServerMessage(Opcode)
+    {
+    }
+
+    virtual ~NotifyChatMessageBroadcast() = default;
+
+    void SerializeRaw(TiltedPhoques::Buffer::Writer& aWriter) const noexcept override;
+    void DeserializeRaw(TiltedPhoques::Buffer::Reader& aReader) noexcept override;
+
+    bool operator==(const NotifyChatMessageBroadcast& acRhs) const noexcept
+    {
+        return GetOpcode() == acRhs.GetOpcode() &&
+               PlayerName == acRhs.PlayerName && 
+               ChatMessage == acRhs.ChatMessage;
+    }
+
+    TiltedPhoques::String PlayerName;
+    TiltedPhoques::String ChatMessage;
+};

Code/encoding/Messages/SendChatMessageRequest.cpp

@@ -0,0 +1,13 @@
+#include <Messages/SendChatMessageRequest.h>
+
+void SendChatMessageRequest::SerializeRaw(TiltedPhoques::Buffer::Writer& aWriter) const noexcept
+{
+    Serialization::WriteString(aWriter, ChatMessage);
+}
+
+void SendChatMessageRequest::DeserializeRaw(TiltedPhoques::Buffer::Reader& aReader) noexcept
+{
+    ClientMessage::DeserializeRaw(aReader);
+
+    ChatMessage = Serialization::ReadString(aReader);
+}

Code/encoding/Messages/SendChatMessageRequest.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Message.h"
+
+using TiltedPhoques::Map;
+using TiltedPhoques::String;
+
+struct SendChatMessageRequest final : ClientMessage
+{
+    static constexpr ClientOpcode Opcode = kSendChatMessageRequest;
+
+    SendChatMessageRequest() : ClientMessage(Opcode)
+    {
+    }
+
+    virtual ~SendChatMessageRequest() = default;
+
+    void SerializeRaw(TiltedPhoques::Buffer::Writer& aWriter) const noexcept override;
+    void DeserializeRaw(TiltedPhoques::Buffer::Reader& aReader) noexcept override;
+
+    bool operator==(const SendChatMessageRequest& acRhs) const noexcept
+    {
+        return GetOpcode() == acRhs.GetOpcode() &&
+               ChatMessage == acRhs.ChatMessage;
+    }
+
+    TiltedPhoques::String ChatMessage;
+};

Code/encoding/Messages/ServerMessageFactory.h

@@ -40,6 +40,7 @@
 #include <Messages/NotifyRespawn.h>
 #include <Messages/NotifySyncExperience.h>
 #include <Messages/NotifyEquipmentChanges.h>
+#include <Messages/NotifyChatMessageBroadcast.h>
 
 using TiltedPhoques::UniquePtr;
 
@@ -58,7 +59,7 @@ struct ServerMessageFactory
                                  NotifyLockChange, AssignObjectsResponse, NotifyDeathStateChange, NotifyOwnershipTransfer,
                                  NotifyObjectInventoryChanges, NotifySpellCast, NotifyProjectileLaunch, NotifyInterruptCast,
                                  NotifyAddTarget, NotifyScriptAnimation, NotifyDrawWeapon, NotifyMount, NotifyNewPackage,
-                                 NotifyRespawn, NotifySyncExperience, NotifyEquipmentChanges>;
+                                 NotifyRespawn, NotifySyncExperience, NotifyEquipmentChanges, NotifyChatMessageBroadcast>;
 
         return s_visitor(std::forward<T>(func));
     }

Code/encoding/Opcodes.h

@@ -41,6 +41,7 @@ enum ClientOpcode : unsigned char
     kRequestRespawn,
     kSyncExperienceRequest,
     kRequestEquipmentChanges,
+    kSendChatMessageRequest,
     kClientOpcodeMax
 };
 
@@ -82,5 +83,6 @@ enum ServerOpcode : unsigned char
     kNotifyRespawn,
     kNotifySyncExperience,
     kNotifyEquipmentChanges,
+    kNotifyChatMessageBroadcast,
     kServerOpcodeMax
 };

Code/server/Services/OverlayService.cpp

@@ -0,0 +1,72 @@
+#include <Components.h>
+#include <GameServer.h>
+
+#include <Scripts/Player.h>
+#include <Services/OverlayService.h>
+
+#include <Messages/NotifyChatMessageBroadcast.h>
+#include <Messages/SendChatMessageRequest.h>
+
+#include <Events/PlayerEnterWorldEvent.h>
+
+#include <regex>
+
+OverlayService::OverlayService(World& aWorld, entt::dispatcher& aDispatcher)
+    : m_world(aWorld),
+      m_chatMessageConnection(
+          aDispatcher.sink<PacketEvent<SendChatMessageRequest>>().connect<&OverlayService::HandleChatMessage>(this))
+{
+}
+
+#if 0
+void OverlayService::SendChatMessage(Script::Player aPlayer, const std::string aMessage)
+{
+    spdlog::debug(aMessage);
+    NotifyChatMessageBroadcast notifyMessage;
+    notifyMessage.PlayerName = "";
+    notifyMessage.ChatMessage = aMessage;
+
+    // TODO: ehh?
+    Player* pPlayer = m_world.GetPlayerManager().GetById(aPlayer.GetId());
+    pPlayer->Send(notifyMessage);
+}
+#endif
+
+void OverlayService::BroadcastMessage(const std::string aMessage)
+{
+    NotifyChatMessageBroadcast notifyMessage;
+    notifyMessage.PlayerName = "";
+    notifyMessage.ChatMessage = aMessage;
+
+    GameServer::Get()->SendToPlayers(notifyMessage);
+}
+
+void OverlayService::HandleChatMessage(const PacketEvent<SendChatMessageRequest>& acMessage) const noexcept
+{
+    NotifyChatMessageBroadcast notifyMessage;
+    notifyMessage.PlayerName = acMessage.pPlayer->GetUsername();
+
+    // TODO: std regex is slow
+    std::regex escapeHtml{"<[^>]+>\s+(?=<)|<[^>]+>"};
+    notifyMessage.ChatMessage = std::regex_replace(acMessage.Packet.ChatMessage, escapeHtml, "");
+
+    GameServer::Get()->SendToPlayers(notifyMessage);
+}
+
+#if 0
+void OverlayService::HandlePlayerJoin(const PlayerEnterWorldEvent& acEvent) const noexcept
+{
+    const Script::Player cPlayer(acEvent.Entity, m_world);
+
+    auto& playerComponent = m_world.get<PlayerComponent>(cPlayer.GetEntityHandle());
+
+    spdlog::info("[SERVER] PlayerId: {} - ConnectionId: {}", cPlayer.GetId(), playerComponent.ConnectionId);
+    if (playerComponent.Character)
+    {
+        spdlog::info("[SERVER] CharacterId: {}", playerComponent.Character.value());
+    }
+
+    //TODO 
+    //Send netid, username and default level to all client except to the one that just joined
+}
+#endif

Code/server/Services/OverlayService.h

@@ -0,0 +1,28 @@
+#pragma once
+#include <Scripts/Player.h>
+
+#include <Messages/SendChatMessageRequest.h>
+
+#include <Events/PacketEvent.h>
+#include <Events/PlayerEnterWorldEvent.h>
+
+struct World;
+
+class OverlayService
+{
+  public:
+    OverlayService(World& aWorld, entt::dispatcher& aDispatcher);
+
+    void SendChatMessage(Script::Player aPlayer, const std::string aMessage);
+    void BroadcastMessage(const std::string aMessage);
+
+  protected:
+    void HandleChatMessage(const PacketEvent<SendChatMessageRequest>& acMessage) const noexcept;
+    void HandlePlayerJoin(const PlayerEnterWorldEvent& acEvent) const noexcept;
+
+  private:
+    World& m_world;
+
+    entt::scoped_connection m_chatMessageConnection;
+    entt::scoped_connection m_playerEnterWorldConnection;
+};