NetworkClient.hpp

#pragma once
 
#include "Core/ArraySegment.hpp"
#include "Core/NetworkConnectionToServer.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 {
    enum ConnectState {
        None,
        // connecting between Connect() and OnTransportConnected()
        Connecting,
        Connected,
        // disconnecting between Disconnect() and OnTransportDisconnected()
        Disconnecting,
        Disconnected
    };
 
    class NetworkManager;
 
    class NetworkClient {
      private:
        NetworkManager& manager;
        KapEngine::KEngine& engine;
 
        ConnectState connectState;
        std::shared_ptr<NetworkConnectionToServer> connection;
 
        KapEngine::Dictionary<ushort, std::shared_ptr<std::function<void(std::shared_ptr<NetworkConnectionToServer>, NetworkReader&)>>>
            handlers;
        KapEngine::Dictionary<unsigned int, std::shared_ptr<KapEngine::GameObject>> networkObjects;
 
      public:
        explicit NetworkClient(NetworkManager& _manager, KapEngine::KEngine& _engine);
        ~NetworkClient() = default;
 
        void connect(const std::string& ip, int port);
 
        void disconnect();
 
        void networkEarlyUpdate();
 
        bool isActive() const { return connectState == ConnectState::Connecting || connectState == ConnectState::Connected; }
 
        bool isConnecting() const { return connectState == ConnectState::Connecting; }
 
        bool isConnected() const { return connectState == ConnectState::Connected; }
 
        template <typename T, typename = std::enable_if<std::is_base_of<NetworkMessage, T>::value>>
        void send(T& message) {
            if (connection != nullptr) {
                if (connectState == ConnectState::Connected) {
                    connection->send(message);
                } else {
                    KapEngine::Debug::error("NetworkClient: Send when not connected to a server");
                }
            } else {
                KapEngine::Debug::error("NetworkClient: Send with no connection");
            }
        }
 
        template <typename T, typename = std::enable_if<std::is_base_of<NetworkMessage, T>::value>>
        void registerHandler(std::function<void(const std::shared_ptr<NetworkConnectionToServer>&, T&)> handler) {
            ushort msgType = MessagePacking::getId<T>();
            if (handlers.containsKey(msgType)) {
                KapEngine::Debug::warning("NetworkClient.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<NetworkConnectionToServer> conn, NetworkReader& reader) {
                T message;
                message.deserialize(reader);
                handler(conn, message);
            };
            handlers[msgType] =
                std::make_shared<std::function<void(std::shared_ptr<NetworkConnectionToServer>, NetworkReader&)>>(messageHandler);
        }
 
        template <typename T, typename = std::enable_if<std::is_base_of<NetworkMessage, T>::value>>
        void unregisterHandler(T& message) {
            ushort msgType = MessagePacking::getId<T>();
            handlers.remove(msgType);
        }
 
#pragma region KapEngine
 
        void updateObject(unsigned int id);
 
        bool getExistingObject(unsigned int networkId, std::shared_ptr<KapEngine::GameObject>& gameObject) {
            return networkObjects.tryGetValue(networkId, gameObject);
        }
 
#pragma endregion
 
      private:
        void addTransportHandlers();
        void removeTransportHandlers();
        void registerSystemHandlers();
 
        void onTransportConnect();
        void onTransportDisconnect();
        void onTransportData(const std::shared_ptr<ArraySegment<byte>>& data);
 
        bool unpackAndInvoke(const std::shared_ptr<ArraySegment<byte>>& data);
 
        // KapEngine
        void onObjectSpawn(ObjectSpawnMessage& message);
        void onObjectDestroy(ObjectDestroyMessage& message);
        void onObjectTransformUpdate(ObjectTransformMessage& message);
 
      public:
        Experimental::Action<void(std::shared_ptr<NetworkConnection>)> onConnectedEvent;
        Experimental::Action<void(std::shared_ptr<NetworkConnection>)> onDisconnectedEvent;
    };
} // namespace KapMirror