feat: infrastructure for teleport button

Code/client/Services/Generic/OverlayClient.cpp

@@ -8,6 +8,7 @@
 #include <Events/CommandEvent.h>
 
 #include <Messages/SendChatMessageRequest.h>
+#include <Messages/TeleportRequest.h>
 
 #include <World.h>
 
@@ -69,6 +70,8 @@ bool OverlayClient::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser, CefR
             uint32_t aPlayerId = eventArgs->GetInt(0);
             World::Get().GetPartyService().ChangePartyLeader(aPlayerId);
         }
+        else if (eventName == "teleportToPlayer")
+            ProcessTeleportMessage(eventArgs);
 
         return true;
     }
@@ -117,3 +120,11 @@ void OverlayClient::ProcessChatMessage(CefRefPtr<CefListValue> aEventArgs)
         }
     }
 }
+
+void OverlayClient::ProcessTeleportMessage(CefRefPtr<CefListValue> aEventArgs)
+{
+    TeleportRequest request{};
+    request.PlayerId = aEventArgs->GetInt(0);
+
+    m_transport.Send(request);
+}

Code/client/Services/Generic/OverlayService.cpp

@@ -21,6 +21,9 @@
 #include <Messages/NotifyPlayerDialogue.h>
 #include <Messages/NotifyPlayerLevel.h>
 #include <Messages/NotifyPlayerCellChanged.h>
+#include <Messages/NotifyTeleport.h>
+
+#include <Structs/GridCellCoords.h>
 
 #include <Events/ConnectedEvent.h>
 #include <Events/DisconnectedEvent.h>
@@ -108,6 +111,7 @@ OverlayService::OverlayService(World& aWorld, TransportService& transport, entt:
     m_playerRemovedConnection = m_world.on_destroy<PlayerComponent>().connect<&OverlayService::OnPlayerComponentRemoved>(this);
     m_playerLevelConnection = aDispatcher.sink<NotifyPlayerLevel>().connect<&OverlayService::OnPlayerLevel>(this);
     m_cellChangedConnection = aDispatcher.sink<NotifyPlayerCellChanged>().connect<&OverlayService::OnPlayerCellChanged>(this);
+    m_teleportConnection = aDispatcher.sink<NotifyTeleport>().connect<&OverlayService::OnNotifyTeleport>(this);
 }
 
 OverlayService::~OverlayService() noexcept
@@ -379,3 +383,30 @@ void OverlayService::OnPlayerCellChanged(const NotifyPlayerCellChanged& acMessag
     pArguments->SetString(3, cellName.c_str());
     m_pOverlay->ExecuteAsync("setCell", pArguments);
 }
+
+void OverlayService::OnNotifyTeleport(const NotifyTeleport& acMessage) noexcept
+{
+    auto& modSystem = m_world.GetModSystem();
+
+    const uint32_t cellId = modSystem.GetGameId(acMessage.CellId);
+    TESObjectCELL* pCell = Cast<TESObjectCELL>(TESForm::GetById(cellId));
+    if (!pCell)
+    {
+        const uint32_t worldSpaceId = modSystem.GetGameId(acMessage.WorldSpaceId);
+        TESWorldSpace* pWorldSpace = Cast<TESWorldSpace>(TESForm::GetById(worldSpaceId));
+        if (pWorldSpace)
+        {
+            GridCellCoords coordinates = GridCellCoords::CalculateGridCellCoords(acMessage.Position);
+            pCell = pWorldSpace->LoadCell(coordinates.X, coordinates.Y);
+        }
+
+        if (!pCell)
+        {
+            spdlog::error("Failed to fetch cell to teleport to.");
+            m_world.GetOverlayService().SendSystemMessage("Teleporting to player failed.");
+            return;
+        }
+    }
+
+    PlayerCharacter::Get()->MoveTo(pCell, acMessage.Position);
+}

Code/client/Services/OverlayClient.h

@@ -26,6 +26,7 @@ struct OverlayClient : TiltedPhoques::OverlayClient
     void ProcessConnectMessage(CefRefPtr<CefListValue> aEventArgs);
     void ProcessDisconnectMessage();
     void ProcessChatMessage(CefRefPtr<CefListValue> aEventArgs);
+    void ProcessTeleportMessage(CefRefPtr<CefListValue> aEventArgs);
 
     TransportService& m_transport;
 };

Code/client/Services/OverlayService.h

@@ -24,6 +24,7 @@ struct NotifyPlayerDialogue;
 struct ConnectionErrorEvent;
 struct NotifyPlayerLevel;
 struct NotifyPlayerCellChanged;
+struct NotifyTeleport;
 
 
 using TiltedPhoques::OverlayApp;
@@ -75,6 +76,7 @@ struct OverlayService
     void OnPlayerLeft(const NotifyPlayerLeft&) noexcept;
     void OnPlayerLevel(const NotifyPlayerLevel&) noexcept;
     void OnPlayerCellChanged(const NotifyPlayerCellChanged& acMessage) const noexcept;
+    void OnNotifyTeleport(const NotifyTeleport& acMessage) noexcept;
 
   private:
     CefRefPtr<OverlayApp> m_pOverlay{nullptr};
@@ -99,4 +101,5 @@ struct OverlayService
     entt::scoped_connection m_playerRemovedConnection;
     entt::scoped_connection m_playerLevelConnection;
     entt::scoped_connection m_cellChangedConnection;
+    entt::scoped_connection m_teleportConnection;
 };

Code/encoding/Messages/ClientMessageFactory.h

@@ -49,6 +49,7 @@
 #include <Messages/SubtitleRequest.h>
 #include <Messages/PlayerDialogueRequest.h>
 #include <Messages/PlayerLevelRequest.h>
+#include <Messages/TeleportRequest.h>
 
 using TiltedPhoques::UniquePtr;
 
@@ -70,7 +71,7 @@ struct ClientMessageFactory
                                  AddTargetRequest, ScriptAnimationRequest, DrawWeaponRequest, MountRequest, NewPackageRequest,
                                  RequestRespawn, SyncExperienceRequest, RequestEquipmentChanges, SendChatMessageRequest,
                                  TeleportCommandRequest, PlayerRespawnRequest, DialogueRequest, SubtitleRequest, PlayerDialogueRequest,
-                                 PlayerLevelRequest>;
+                                 PlayerLevelRequest, TeleportRequest>;
 
         return s_visitor(std::forward<T>(func));
     }

Code/encoding/Messages/NotifyTeleport.cpp

@@ -0,0 +1,18 @@
+#include <Messages/NotifyTeleport.h>
+#include <TiltedCore/Serialization.hpp>
+
+void NotifyTeleport::SerializeRaw(TiltedPhoques::Buffer::Writer& aWriter) const noexcept
+{
+    CellId.Serialize(aWriter);
+    Position.Serialize(aWriter);
+    WorldSpaceId.Serialize(aWriter);
+}
+
+void NotifyTeleport::DeserializeRaw(TiltedPhoques::Buffer::Reader& aReader) noexcept
+{
+    ServerMessage::DeserializeRaw(aReader);
+
+    CellId.Deserialize(aReader);
+    Position.Deserialize(aReader);
+    WorldSpaceId.Deserialize(aReader);
+}

Code/encoding/Messages/NotifyTeleport.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Message.h"
+#include <Structs/Vector3_NetQuantize.h>
+#include <Structs/GameId.h>
+
+struct NotifyTeleport final : ServerMessage
+{
+    static constexpr ServerOpcode Opcode = kNotifyTeleport;
+
+    NotifyTeleport() : 
+        ServerMessage(Opcode)
+    {
+    }
+
+    virtual ~NotifyTeleport() = default;
+
+    void SerializeRaw(TiltedPhoques::Buffer::Writer& aWriter) const noexcept override;
+    void DeserializeRaw(TiltedPhoques::Buffer::Reader& aReader) noexcept override;
+
+    bool operator==(const NotifyTeleport& acRhs) const noexcept
+    {
+        return GetOpcode() == acRhs.GetOpcode() &&
+               CellId == acRhs.CellId &&
+               Position == acRhs.Position &&
+               WorldSpaceId == acRhs.WorldSpaceId;
+    }
+
+    GameId CellId{};
+    Vector3_NetQuantize Position{};
+    GameId WorldSpaceId{};
+};

Code/encoding/Messages/ServerMessageFactory.h

@@ -50,6 +50,7 @@
 #include <Messages/NotifyPlayerJoined.h>
 #include <Messages/NotifyPlayerLevel.h>
 #include <Messages/NotifyPlayerCellChanged.h>
+#include <Messages/NotifyTeleport.h>
 
 using TiltedPhoques::UniquePtr;
 
@@ -70,7 +71,8 @@ struct ServerMessageFactory
                                  NotifyAddTarget, NotifyScriptAnimation, NotifyDrawWeapon, NotifyMount, NotifyNewPackage,
                                  NotifyRespawn, NotifySyncExperience, NotifyEquipmentChanges, NotifyChatMessageBroadcast,
                                  TeleportCommandResponse, NotifyPlayerRespawn, NotifyPlayerLeft, NotifyPlayerJoined, 
-                                 NotifyDialogue, NotifySubtitle, NotifyPlayerDialogue, NotifyPlayerLevel, NotifyPlayerCellChanged>;
+                                 NotifyDialogue, NotifySubtitle, NotifyPlayerDialogue, NotifyPlayerLevel, NotifyPlayerCellChanged,
+                                 NotifyTeleport>;
 
         return s_visitor(std::forward<T>(func));
     }

Code/encoding/Messages/TeleportRequest.cpp

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

Code/encoding/Messages/TeleportRequest.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Message.h"
+#include <Structs/GameId.h>
+
+struct TeleportRequest final : ClientMessage
+{
+    static constexpr ClientOpcode Opcode = kTeleportRequest;
+
+    TeleportRequest() : ClientMessage(Opcode)
+    {
+    }
+
+    void SerializeRaw(TiltedPhoques::Buffer::Writer& aWriter) const noexcept override;
+    void DeserializeRaw(TiltedPhoques::Buffer::Reader& aReader) noexcept override;
+
+    bool operator==(const TeleportRequest& acRhs) const noexcept
+    {
+        return GetOpcode() == acRhs.GetOpcode() &&
+               PlayerId == acRhs.PlayerId;
+    }
+
+    uint16_t PlayerId{};
+};

Code/encoding/Opcodes.h

@@ -47,6 +47,7 @@ enum ClientOpcode : unsigned char
     kSubtitleRequest,
     kPlayerDialogueRequest,
     kPlayerLevelRequest,
+    kTeleportRequest,
     kClientOpcodeMax
 };
 
@@ -98,5 +99,6 @@ enum ServerOpcode : unsigned char
     kNotifyPlayerJoined,
     kNotifyPlayerLevel,
     kNotifyPlayerCellChanged,
+    kNotifyTeleport,
     kServerOpcodeMax
 };

Code/server/Services/OverlayService.cpp

@@ -6,6 +6,8 @@
 #include <Messages/SendChatMessageRequest.h>
 #include <Messages/PlayerDialogueRequest.h>
 #include <Messages/NotifyPlayerDialogue.h>
+#include <Messages/TeleportRequest.h>
+#include <Messages/NotifyTeleport.h>
 
 #include <regex>
 
@@ -14,11 +16,12 @@ OverlayService::OverlayService(World& aWorld, entt::dispatcher& aDispatcher)
 {
     m_chatMessageConnection = aDispatcher.sink<PacketEvent<SendChatMessageRequest>>().connect<&OverlayService::HandleChatMessage>(this);
     m_playerDialogueConnection = aDispatcher.sink<PacketEvent<PlayerDialogueRequest>>().connect<&OverlayService::OnPlayerDialogue>(this);
+    m_teleportConnection = aDispatcher.sink<PacketEvent<TeleportRequest>>().connect<&OverlayService::OnTeleport>(this);
 }
 
 void OverlayService::HandleChatMessage(const PacketEvent<SendChatMessageRequest>& acMessage) const noexcept
 {
-    NotifyChatMessageBroadcast notifyMessage;
+    NotifyChatMessageBroadcast notifyMessage{};
     notifyMessage.PlayerName = acMessage.pPlayer->GetUsername();
 
     // TODO: std regex is slow
@@ -32,15 +35,38 @@ void OverlayService::OnPlayerDialogue(const PacketEvent<PlayerDialogueRequest>&
 {
     auto& message = acMessage.Packet;
 
-    NotifyPlayerDialogue notify;
+    NotifyPlayerDialogue notify{};
     notify.Text = acMessage.pPlayer->GetUsername() + ": " + message.Text;
 
     auto& party = acMessage.pPlayer->GetParty();
 
-    // TODO(cosideci): exclude player?
     GameServer::Get()->SendToParty(notify, party);
 }
 
+void OverlayService::OnTeleport(const PacketEvent<TeleportRequest>& acMessage) const noexcept
+{
+    Player* pTargetPlayer = m_world.GetPlayerManager().GetById(acMessage.Packet.PlayerId);
+    if (!pTargetPlayer)
+        return;
+
+    NotifyTeleport response{};
+
+    auto character = pTargetPlayer->GetCharacter();
+    if (character)
+    {
+        const auto* pMovementComponent = m_world.try_get<MovementComponent>(*character);
+        if (pMovementComponent)
+        {
+            const auto& cellComponent = pTargetPlayer->GetCellComponent();
+            response.CellId = cellComponent.Cell;
+            response.Position = pMovementComponent->Position;
+            response.WorldSpaceId = cellComponent.WorldSpaceId;
+        }
+    }
+
+    acMessage.pPlayer->Send(response);
+}
+
 #if 0
 #include <Components.h>
 #include <Events/PlayerEnterWorldEvent.h>

Code/server/Services/OverlayService.h

@@ -8,6 +8,7 @@
 struct World;
 
 struct PlayerDialogueRequest;
+struct TeleportRequest;
 
 /**
 * @brief Dispatches UI events that modify the UI view of other cients.
@@ -24,11 +25,13 @@ class OverlayService
     void HandleChatMessage(const PacketEvent<SendChatMessageRequest>& acMessage) const noexcept;
     void HandlePlayerJoin(const PlayerEnterWorldEvent& acEvent) const noexcept;
     void OnPlayerDialogue(const PacketEvent<PlayerDialogueRequest>& acMessage) const noexcept;
+    void OnTeleport(const PacketEvent<TeleportRequest>& acMessage) const noexcept;
 
   private:
     World& m_world;
 
     entt::scoped_connection m_chatMessageConnection;
     entt::scoped_connection m_playerEnterWorldConnection;
     entt::scoped_connection m_playerDialogueConnection;
+    entt::scoped_connection m_teleportConnection;
 };