NetworkServer.hpp

#pragma once
 
#include "Core/ArraySegment.hpp"
#include "Core/NetworkConnectionToClient.hpp"
#include "Core/NetworkMessage.hpp"
#include "KapMirror/Experimental/Core/Action.hpp"
#include "Messages.hpp"
#include "KapEngine.hpp"
#include "Platform.hpp"
#include "Dictionary.hpp"
#include "Debug.hpp"
#include <memory>
#include <functional>
 
namespace KapMirror {
    class NetworkManager;
 
    class NetworkServer {
      private:
        NetworkManager& manager;
        KapEngine::KEngine& engine;
 
        bool initialized;
        bool active;
 
        int maxConnections = 10;
 
        KapEngine::Dictionary<unsigned int, std::shared_ptr<NetworkConnectionToClient>> connections;
        KapEngine::Dictionary<ushort, std::shared_ptr<std::function<void(std::shared_ptr<NetworkConnectionToClient>, NetworkReader&)>>>
            handlers;
        KapEngine::Dictionary<unsigned int, std::shared_ptr<KapEngine::GameObject>> networkObjects;
 
      public:
        explicit NetworkServer(NetworkManager& _manager, KapEngine::KEngine& _engine);
        ~NetworkServer() = default;
 
        bool isActivated() const { return active; }
 
        void listen(int maxConnections, int port);
 
        void shutdown();
 
        void networkEarlyUpdate() const;
 
        template <typename T, typename = std::enable_if<std::is_base_of<NetworkMessage, T>::value>>
        void sendToAll(T& message) {
            if (!active) {
                KapEngine::Debug::warning("NetworkServer: Cannot send data, server not active");
                return;
            }
 
            for (auto const& [id, conn] : connections) {
                conn->send(message);
            }
        }
 
        template <typename T, typename = std::enable_if<std::is_base_of<NetworkMessage, T>::value>>
        void sendToClient(T& message, unsigned int networkId) {
            if (!active) {
                KapEngine::Debug::warning("NetworkServer: Cannot send data, server not active");
                return;
            }
 
            std::shared_ptr<NetworkConnectionToClient> connection;
            if (connections.tryGetValue(networkId, connection)) {
                connection->send(message);
            } else {
                KapEngine::Debug::warning("NetworkServer: Cannot send data, client not found");
            }
        }
 
        void disconnectAll() {
            for (auto const& [id, conn] : connections) {
                conn->disconnect();
                onTransportDisconnect(conn->getConnectionId());
            }
 
            // cleanup
            connections.clear();
        }
 
        template <typename T, typename = std::enable_if<std::is_base_of<NetworkMessage, T>::value>>
        void registerHandler(std::function<void(const std::shared_ptr<NetworkConnectionToClient>&, T&)> handler) {
            ushort msgType = MessagePacking::getId<T>();
            if (handlers.containsKey(msgType)) {
                KapEngine::Debug::warning("NetworkServer.registerHandler replacing handler for {" + std::string(typeid(T).name()) +
                                          "}, id={" + std::to_string(msgType) +
                                          "}. If replacement is intentional, use replaceHandler instead to avoid this warning.");
            }
 
            auto messageHandler = [handler](std::shared_ptr<NetworkConnectionToClient> connection, NetworkReader& reader) {
                T message;
                message.deserialize(reader);
                handler(connection, message);
            };
            handlers[msgType] =
                std::make_shared<std::function<void(std::shared_ptr<NetworkConnectionToClient>, NetworkReader&)>>(messageHandler);
        }
 
        template <typename T, typename = std::enable_if<std::is_base_of<NetworkMessage, T>::value>>
        void unregisterHandler(T& message) {
            ushort id = MessagePacking::getId<T>();
            handlers.remove(id);
        }
 
#pragma region KapEngine
 
        void spawnObject(const std::string& prefabName, KapEngine::SceneManagement::Scene& scene, const KapEngine::Tools::Vector3& position,
                         const std::function<void(const std::shared_ptr<KapEngine::GameObject>&)>& playload,
                         std::shared_ptr<KapEngine::GameObject>& gameObject);
 
        void spawnObject(const std::string& prefabName, std::size_t sceneId, const KapEngine::Tools::Vector3& position,
                         const std::function<void(const std::shared_ptr<KapEngine::GameObject>&)>& playload,
                         std::shared_ptr<KapEngine::GameObject>& gameObject) {
            auto& scene = engine.getSceneManager()->getScene(sceneId);
            spawnObject(prefabName, scene, position, playload, gameObject);
        }
 
        void spawnObject(const std::string& prefabName, const KapEngine::Tools::Vector3& position,
                         const std::function<void(const std::shared_ptr<KapEngine::GameObject>&)>& playload,
                         std::shared_ptr<KapEngine::GameObject>& gameObject) {
            auto& scene = engine.getSceneManager()->getCurrentScene();
            spawnObject(prefabName, scene, position, playload, gameObject);
        }
 
        void spawnObject(const std::string& prefabName, const KapEngine::Tools::Vector3& position,
                         std::shared_ptr<KapEngine::GameObject>& gameObject) {
            auto& scene = engine.getSceneManager()->getCurrentScene();
            spawnObject(prefabName, scene, position, nullptr, gameObject);
        }
 
        void unSpawn(const std::shared_ptr<KapEngine::GameObject>& gameObject);
 
        void destroyObject(unsigned int networkId);
 
        void destroyObject(const std::shared_ptr<KapEngine::GameObject>& gameObject) { unSpawn(gameObject); }
 
        void updateObject(unsigned int id);
 
        bool getExistingObject(unsigned int id, std::shared_ptr<KapEngine::GameObject>& gameObject) {
            return networkObjects.tryGetValue(id, gameObject);
        }
 
#pragma endregion
 
      private:
        void initialize();
 
        void addTransportHandlers();
        void removeTransportHandlers();
        void registerSystemHandlers();
 
        void onTransportConnect(int connectionId);
        void onTransportDisconnect(int connectionId);
        void onTransportData(int connectionId, const std::shared_ptr<ArraySegment<byte>>& data);
 
        bool addConnection(const std::shared_ptr<NetworkConnectionToClient>& connection);
        bool removeConnection(int connectionId);
 
        bool unpackAndInvoke(const std::shared_ptr<NetworkConnectionToClient>& connection, const std::shared_ptr<ArraySegment<byte>>& data);
 
        void sendObject(const std::shared_ptr<KapEngine::GameObject>& gameObject,
                        const std::shared_ptr<NetworkConnectionToClient>& connection);
 
        // KapEngine
        void onObjectSpawn(ObjectSpawnMessage& message);
        void onObjectTransformUpdate(ObjectTransformMessage& message);
 
      public:
        Experimental::Action<void(std::shared_ptr<NetworkConnection>)> onConnectedEvent;
        Experimental::Action<void(std::shared_ptr<NetworkConnection>)> onDisconnectedEvent;
    };
} // namespace KapMirror