WIP Reliable message

include/Engine/Network/Client.h

@@ -30,11 +30,9 @@ public:
     void Start(World* world, EventBroker* eventBroker) override;
     void Update() override;
 protected:
-    // Assio UDP logic
+    // Save for children
-    boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
+    std::string address;
-    boost::asio::io_service m_IOService;
+    int port = 0;
-    boost::asio::ip::udp::socket m_Socket;
-
     // Sending message to server logic
     int bytesRead = -1;
     char readBuf[INPUTSIZE] = { 0 };
@@ -68,9 +66,8 @@ protected:
     std::vector<Events::InputCommand> m_InputCommandBuffer;
 
     // Private member functions
-    void readFromServer();
+    virtual void send(Packet& packet) = 0;
-    int  receive(char* data);
+    virtual void readFromServer() = 0;
-    void send(Packet& packet);
     void connect();
     void disconnect();
     void parseMessageType(Packet& packet);

include/Engine/Network/HybridClient.h

@@ -9,6 +9,16 @@ class HybridClient : public Client
 public:
     HybridClient(ConfigFile* config);
     ~HybridClient();
+    void Start(World* world, EventBroker* eventBroker);
+private:
+    // Assio UDP logic
+    boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
+    boost::asio::io_service m_IOService;
+    boost::asio::ip::udp::socket m_Socket;
+
+    void readFromServer();
+    int receive(char * data);
+    void send(Packet & packet);
 };
 
 #endif

include/Engine/Network/HybridServer.h

@@ -0,0 +1,30 @@
+#ifndef HybridServer_h__
+#define HybridServer_h__
+
+#include "Server.h"
+#include <boost/asio/ip/udp.hpp>
+
+class HybridServer : public Server
+{
+public:
+    HybridServer();
+    ~HybridServer();
+private:
+    // UDP logic
+    boost::asio::io_service m_IOService;
+    std::unique_ptr<boost::asio::ip::udp::socket> m_Socket;
+
+    void readFromClients();
+    void parseClientPing();
+    void parsePing();
+    void parseDisconnect();
+    void parseConnect(Packet & packet);
+    void parseOnInputCommand(Packet & packet);
+    void parsePlayerTransform(Packet & packet);
+    void send(Packet & packet, PlayerDefinition & playerDefinition);
+    void send(Packet & packet);
+    int receive(char * data);
+    PlayerID GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
+};
+
+#endif

include/Engine/Network/PlayerDefinition.h

@@ -2,6 +2,7 @@
 #define PlayerDefinition_h__
 #include <string>
 #include "../Core/Entity.h"
+#include <boost/asio.hpp>
 
 struct PlayerDefinition {
     ::EntityID EntityID = EntityID_Invalid;
@@ -9,6 +10,8 @@ struct PlayerDefinition {
     boost::asio::ip::udp::endpoint Endpoint;
     unsigned int PacketID;
     std::clock_t StopTime;
+    // use for tcp connections
+    boost::shared_ptr<boost::asio::ip::tcp::socket> TCPSocket;
 };
 
 #endif

include/Engine/Network/Server.h

@@ -5,7 +5,6 @@
 #include <ctime>
 
 #include <glm/common.hpp>
-#include <boost/asio/ip/udp.hpp>
 
 #include "Network/MessageType.h"
 #include "Network/PlayerDefinition.h"
@@ -18,7 +17,6 @@
 #include "Core/EPlayerSpawned.h"
 #include "Core/EEntityDeleted.h"
 #include "Core/EComponentDeleted.h"
-
 class Server : public Network
 {
 public:
@@ -26,12 +24,9 @@ public:
     ~Server();
     void Start(World* m_world, EventBroker *eventBroker) override;
     void Update() override;
-private:
+protected:
-    // UDP logic
+    template<class T>
-    boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
+    T m_ReceiverEndpoint;
-    boost::asio::io_service m_IOService;
-    boost::asio::ip::udp::socket m_Socket;
-
     // Sending messages to client logic
     std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
     // HACK: Fix INPUTSIZE
@@ -41,12 +36,12 @@ private:
     std::clock_t previousePingMessage = std::clock();
     std::clock_t previousSnapshotMessage = std::clock();
     std::clock_t timOutTimer = std::clock();
+
     // How often we send messages (milliseconds)
     int pingIntervalMs;
     int snapshotInterval;
     int checkTimeOutInterval = 100;
     int m_NextPlayerID = 0;
-
     //Timers
     std::clock_t m_StartPingTime;
 
@@ -59,10 +54,7 @@ private:
     PacketID m_PreviousPacketID = 0;
 
     // Private member functions
-    int  receive(char* data);
+    //int  receive(char* data);
-    void readFromClients();
-    void send(PlayerID player, Packet& packet);
-    void send(Packet& packet);
     void broadcast(Packet& packet);
     void sendSnapshot();
     void addChildrenToPacket(Packet& packet, EntityID entityID);
@@ -70,15 +62,18 @@ private:
     void checkForTimeOuts();
     void disconnect(PlayerID playerID);
     void parseMessageType(Packet& packet);
-    void parseOnInputCommand(Packet& packet);
     void parseOnPlayerDamage(Packet& packet);
-    void parseConnect(Packet& packet);
-    void parseDisconnect();
-    void parseClientPing();
-    void parsePing();
     void identifyPacketLoss();
     void kick(PlayerID player);
-    PlayerID GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
+    // Pure virtual functions
+    virtual void parseOnInputCommand(Packet& packet) = 0;
+    virtual void readFromClients() = 0;
+    virtual void send(Packet& packet, PlayerDefinition & playerDefinition) = 0;
+    virtual void send(Packet& packet) = 0;
+    virtual void parseConnect(Packet& packet) = 0;
+    virtual void parseDisconnect() = 0;
+    virtual void parseClientPing() = 0;
+    virtual void parsePing() = 0;
     // Debug event
     EventRelay<Server, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
@@ -88,7 +83,7 @@ private:
     bool OnEntityDeleted(const Events::EntityDeleted& e);
     EventRelay<Server, Events::ComponentDeleted> m_EComponentDeleted;
     bool OnComponentDeleted(const Events::ComponentDeleted& e);
-    void parsePlayerTransform(Packet& packet);
+    virtual void parsePlayerTransform(Packet& packet) = 0;
 };
 
 #endif

include/Engine/Network/TCPClient.h

@@ -1,7 +1,23 @@
 #ifndef TCPClient_h__
 #define TCPClient_h__
 
+#include "Client.h"
 
+class TCPClient : public Client
+{
+public:
+    TCPClient(ConfigFile* config);
+    ~TCPClient();
+    void Start(World* world, EventBroker* eventBroker);
+private:
+    // Assio TCP logic
+    boost::asio::ip::tcp::endpoint m_Endpoint;
+    boost::asio::io_service m_IOService;
+    boost::shared_ptr<boost::asio::ip::tcp::socket> m_Socket;
 
+    void readFromServer();
+    int receive(char * data);
+    void send(Packet & packet);
+};
 
 #endif

include/Engine/Network/TCPServer.h

@@ -0,0 +1,37 @@
+#ifndef TCPServer_h__
+#define TCPServer_h__
+
+#include "Server.h"
+
+class TCPServer : public Server
+{
+public:
+    TCPServer();
+    ~TCPServer();
+
+private:
+    // TCP logic
+    boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
+    boost::asio::io_service m_IOService;
+    std::unique_ptr<boost::asio::ip::tcp::acceptor> acceptor;
+    boost::shared_ptr<boost::asio::ip::tcp::socket> lastReceivedSocket;
+
+    void Start(World* world, EventBroker* eventBroker);
+    void readFromClients();
+    void acceptNewConnections();
+    void handle_accept(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code & error);
+    void parseDisconnect();
+    void parseConnect(Packet & packet);
+    ///// Implement method to get which player it was
+    void parseClientPing();
+    void parsePing();
+    void parseOnInputCommand(Packet & packet);
+    void parsePlayerTransform(Packet & packet);
+    /////////////////////////
+    void send(Packet & packet, PlayerDefinition & playerDefinition);
+    void send(Packet & packet);
+    int receive(char * data, boost::asio::ip::tcp::socket& socket);
+    PlayerID GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
+};
+
+#endif

include/Game/Game.h

@@ -26,8 +26,10 @@
 // Network
 #include <boost/thread.hpp>
 #include "Network/Network.h"
-#include "Network/Server.h"
+#include "Network/HybridServer.h"
 #include "Network/HybridClient.h"
+#include "Network/TCPClient.h"
+#include "Network/TCPServer.h"
 
 // Sound
 #include "Sound/SoundSystem.h"

src/Engine/Network/Client.cpp

@@ -1,9 +1,6 @@
 #include "Network/Client.h"
 
-using namespace boost::asio::ip;
+Client::Client(ConfigFile* config)
-
-
-Client::Client(ConfigFile* config) : m_Socket(m_IOService)
 {
     Network::initialize();
 
@@ -12,13 +9,11 @@ Client::Client(ConfigFile* config) : m_Socket(m_IOService)
     // Init timer
     m_TimeSinceSentInputs = std::clock();
     // Default is local host
-    std::string address = config->Get<std::string>("Networking.Address", "127.0.0.1");
+    address = config->Get<std::string>("Networking.Address", "127.0.0.1");
-    int port = config->Get<int>("Networking.Port", 27666);
+    port = config->Get<int>("Networking.Port", 27666);
-    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
     // Set up network stream
     m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
     m_SendInputIntervalMs = config->Get<int>("Networking.SendInputIntervalMs", 33);
-
 }
 
 Client::~Client()
@@ -33,8 +28,6 @@ void Client::Start(World* world, EventBroker* eventBroker)
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Client::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Client::OnPlayerDamage);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Client::OnPlayerSpawned);
-
-    m_Socket.connect(m_ReceiverEndpoint);
     LOG_INFO("I am client. BIP BOP");
 }
 
@@ -54,17 +47,6 @@ void Client::Update()
     Network::Update();
 }
 
-void Client::readFromServer()
-{
-    while (m_Socket.available()) {
-        bytesRead = receive(readBuf);
-        if (bytesRead > 0) {
-            Packet packet(readBuf, bytesRead);
-            parseMessageType(packet);
-        }
-    }
-}
-
 void Client::parseMessageType(Packet& packet)
 {
     int messageType = packet.ReadPrimitive<int>();
@@ -258,40 +240,6 @@ void Client::parseSnapshot(Packet& packet)
     }
 }
 
-int Client::receive(char* data)
-{
-    boost::system::error_code error;
-
-    int bytesReceived = m_Socket.receive_from(boost
-        ::asio::buffer((void*)data, INPUTSIZE),
-        m_ReceiverEndpoint,
-        0, error);
-    // Network Debug data
-    if (isReadingData) {
-        m_NetworkData.TotalDataReceived += bytesReceived;
-        m_NetworkData.DataReceivedThisInterval += bytesReceived;
-        m_NetworkData.AmountOfMessagesReceived++;
-    }
-    if (error) {
-        //LOG_ERROR("receive: %s", error.message().c_str());
-    }
-    return bytesReceived;
-}
-
-void Client::send(Packet& packet)
-{
-    m_Socket.send_to(boost::asio::buffer(
-        packet.Data(),
-        packet.Size()),
-        m_ReceiverEndpoint, 0);
-    // Network Debug data
-    if (isReadingData) {
-        m_NetworkData.TotalDataSent += packet.Size();
-        m_NetworkData.DataSentThisInterval += packet.Size();
-        m_NetworkData.AmountOfMessagesSent++;
-    }
-}
-
 void Client::connect()
 {
     Packet packet(MessageType::Connect, m_SendPacketID);
@@ -457,7 +405,6 @@ void Client::insertIntoServerClientMaps(EntityID serverEntityID, EntityID client
 {
     m_ServerIDToClientID.insert(std::make_pair(serverEntityID, clientEntityID));
     m_ClientIDToServerID.insert(std::make_pair(clientEntityID, serverEntityID));
-
 }
 
 void Client::deleteFromServerClientMaps(EntityID serverEntityID, EntityID clientEntityID)

src/Engine/Network/HybridClient.cpp

@@ -1,12 +1,64 @@
 #include "Network/HybridClient.h"
 
+using namespace boost::asio::ip;
 
-HybridClient::HybridClient(ConfigFile * config) : Client(config)
+HybridClient::HybridClient(ConfigFile * config) : Client(config), m_Socket(m_IOService)
 { 
-
+    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
 }
 
 HybridClient::~HybridClient()
 { 
 
 }
+
+void HybridClient::Start(World* world, EventBroker* eventBroker)
+{ 
+    Client::Start(world, eventBroker);
+    m_Socket.connect(m_ReceiverEndpoint);
+}
+
+void HybridClient::readFromServer()
+{
+    while (m_Socket.available()) {
+        bytesRead = receive(readBuf);
+        if (bytesRead > 0) {
+            Packet packet(readBuf, bytesRead);
+            parseMessageType(packet);
+        }
+    }
+}
+
+int HybridClient::receive(char* data)
+{
+    boost::system::error_code error;
+
+    int bytesReceived = m_Socket.receive_from(boost
+        ::asio::buffer((void*)data, INPUTSIZE),
+        m_ReceiverEndpoint,
+        0, error);
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataReceived += bytesReceived;
+        m_NetworkData.DataReceivedThisInterval += bytesReceived;
+        m_NetworkData.AmountOfMessagesReceived++;
+    }
+    if (error) {
+        //LOG_ERROR("receive: %s", error.message().c_str());
+    }
+    return bytesReceived;
+}
+
+void HybridClient::send(Packet& packet)
+{
+    m_Socket.send_to(boost::asio::buffer(
+        packet.Data(),
+        packet.Size()),
+        m_ReceiverEndpoint, 0);
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+        m_NetworkData.AmountOfMessagesSent++;
+    }
+}

src/Engine/Network/HybridServer.cpp

@@ -0,0 +1,203 @@
+#include "Network/HybridServer.h"
+
+HybridServer::HybridServer()
+{ 
+    m_Socket = std::unique_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 27666)));
+   
+}
+
+HybridServer::~HybridServer()
+{ }
+
+
+void HybridServer::readFromClients()
+{
+    while (m_Socket->available()) {
+        try {
+            bytesRead = receive(readBuffer);
+            Packet packet(readBuffer, bytesRead);
+            parseMessageType(packet);
+        } catch (const std::exception& err) {
+            //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
+        }
+    }
+    std::clock_t currentTime = std::clock();
+    // Send snapshot
+    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
+        sendSnapshot();
+        previousSnapshotMessage = currentTime;
+    }
+
+    // Send pings each 
+    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
+        sendPing();
+        previousePingMessage = currentTime;
+    }
+
+    // Time out logic
+    if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
+        checkForTimeOuts();
+        timOutTimer = currentTime;
+    }
+}
+
+void HybridServer::parseClientPing()
+{
+    LOG_INFO("%i: Parsing ping", m_PacketID);
+    PlayerID player = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
+    if (player == -1) {
+        return;
+    }
+    // Return ping
+    Packet packet(MessageType::Ping, m_ConnectedPlayers[player].PacketID);
+    packet.WriteString("Ping received");
+    send(packet);
+}
+
+void HybridServer::parsePing()
+{
+    for (int i = 0; i < m_ConnectedPlayers.size(); i++) {
+        if (m_ConnectedPlayers[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
+            m_ConnectedPlayers[i].StopTime = std::clock();
+            break;
+        }
+    }
+}
+
+void HybridServer::parseDisconnect()
+{
+    LOG_INFO("%i: Parsing disconnect", m_PacketID);
+
+    for (auto& kv : m_ConnectedPlayers) {
+        if (kv.second.Endpoint.address() == m_ReceiverEndpoint.address() &&
+            kv.second.Endpoint.port() == m_ReceiverEndpoint.port()) {
+            disconnect(kv.first);
+            break;
+        }
+    }
+}
+
+void HybridServer::parseConnect(Packet& packet)
+{
+    LOG_INFO("Parsing connections");
+    // Check if player is already connected
+    if (GetPlayerIDFromEndpoint(m_ReceiverEndpoint) != -1) {
+        return;
+    }
+    // Create a new player
+    PlayerDefinition pd;
+    pd.EntityID = 0; // Overlook this
+    pd.Endpoint = m_ReceiverEndpoint;
+    pd.Name = packet.ReadString();
+    pd.PacketID = 0;
+    pd.StopTime = std::clock();
+    m_ConnectedPlayers[m_NextPlayerID++] = pd;
+    LOG_INFO("Spectator \"%s\" connected on IP: %s", pd.Name.c_str(), pd.Endpoint.address().to_string().c_str());
+
+    // Send a message to the player that connected
+    Packet connnectPacket(MessageType::Connect, pd.PacketID);
+    send(connnectPacket);
+
+    // Send notification that a player has connected
+    Packet notificationPacket(MessageType::PlayerConnected);
+    broadcast(notificationPacket);
+}
+
+void HybridServer::parseOnInputCommand(Packet& packet)
+{
+    PlayerID player = -1;
+    // Check which player it was who sent the message
+    player = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
+    if (player != -1) {
+        while (packet.DataReadSize() < packet.Size()) {
+            Events::InputCommand e;
+            e.Command = packet.ReadString();
+            e.PlayerID = player; // Set correct player id
+            e.Player = EntityWrapper(m_World, m_ConnectedPlayers.at(player).EntityID);
+            e.Value = packet.ReadPrimitive<float>();
+            m_EventBroker->Publish(e);
+            LOG_INFO("Server::parseOnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
+        }
+    }
+}
+
+void HybridServer::parsePlayerTransform(Packet& packet)
+{
+    glm::vec3 position;
+    glm::vec3 orientation;
+    position.x = packet.ReadPrimitive<float>();
+    position.y = packet.ReadPrimitive<float>();
+    position.z = packet.ReadPrimitive<float>();
+    orientation.x = packet.ReadPrimitive<float>();
+    orientation.y = packet.ReadPrimitive<float>();
+    orientation.z = packet.ReadPrimitive<float>();
+
+    PlayerID playerID = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
+    EntityWrapper player(m_World, m_ConnectedPlayers.at(playerID).EntityID);
+
+    if (player.Valid()) {
+        player["Transform"]["Position"] = position;
+        player["Transform"]["Orientation"] = orientation;
+    }
+}
+
+void HybridServer::send(Packet& packet, PlayerDefinition & playerDefinition)
+{
+    try {
+        int bytesSent = m_Socket->send_to(
+            boost::asio::buffer(packet.Data(), packet.Size()),
+            playerDefinition.Endpoint,
+            0);
+        // Network Debug data
+        if (isReadingData) {
+            m_NetworkData.TotalDataSent += packet.Size();
+            m_NetworkData.DataSentThisInterval += packet.Size();
+            m_NetworkData.AmountOfMessagesSent++;
+        }
+    } catch (const boost::system::system_error& e) {
+        // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
+        playerDefinition.Endpoint = boost::asio::ip::udp::endpoint();
+    }
+}
+// Send back to endpoint of received packet
+void HybridServer::send(Packet & packet)
+{
+    m_Socket->send_to(
+        boost::asio::buffer(
+            packet.Data(),
+            packet.Size()),
+        m_ReceiverEndpoint,
+        0);
+    if (isReadingData) {
+        // Network Debug data
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+    }
+}
+
+
+int HybridServer::receive(char * data)
+{
+    unsigned int length = m_Socket->receive_from(
+        boost::asio::buffer((void*)data
+            , INPUTSIZE)
+        , m_ReceiverEndpoint, 0);
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataReceived += length;
+        m_NetworkData.DataReceivedThisInterval += length;
+        m_NetworkData.AmountOfMessagesReceived++;
+    }
+    return length;
+}
+
+PlayerID HybridServer::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
+{
+    for (auto& kv : m_ConnectedPlayers) {
+        if (kv.second.Endpoint.address() == endpoint.address() &&
+            kv.second.Endpoint.port() == endpoint.port()) {
+            return kv.first;
+        }
+    }
+    return -1;
+}

src/Engine/Network/Server.cpp

@@ -1,19 +1,16 @@
 #include "Network/Server.h"
 
-Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 27666))
+Server::Server()
 {
     Network::initialize();
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
     snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05);
     pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
-
 }
-
 Server::~Server()
 {
 
 }
-
 void Server::Start(World* world, EventBroker* eventBroker)
 {
     m_World = world;
@@ -36,41 +33,9 @@ void Server::Update()
 
 }
 
-void Server::readFromClients()
-{
-    while (m_Socket.available()) {
-        try {
-            bytesRead = receive(readBuffer);
-            Packet packet(readBuffer, bytesRead);
-            parseMessageType(packet);
-        } catch (const std::exception& err) {
-            //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
-        }
-    }
-    std::clock_t currentTime = std::clock();
-    // Send snapshot
-    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
-        sendSnapshot();
-        previousSnapshotMessage = currentTime;
-    }
-
-    // Send pings each 
-    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
-        sendPing();
-        previousePingMessage = currentTime;
-    }
-
-    // Time out logic
-    if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
-        checkForTimeOuts();
-        timOutTimer = currentTime;
-    }
-}
-
 void Server::parseMessageType(Packet& packet)
 {
     int messageType = packet.ReadPrimitive<int>(); // Read what type off message was sent from server
-
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
     m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
@@ -103,60 +68,11 @@ void Server::parseMessageType(Packet& packet)
     }
 }
 
-int Server::receive(char * data)
-{
-    unsigned int length = m_Socket.receive_from(
-        boost::asio::buffer((void*)data
-            , INPUTSIZE)
-        , m_ReceiverEndpoint, 0);
-    // Network Debug data
-    if (isReadingData) {
-        m_NetworkData.TotalDataReceived += length;
-        m_NetworkData.DataReceivedThisInterval += length;
-        m_NetworkData.AmountOfMessagesReceived++;
-    }
-    return length;
-}
-
-void Server::send(PlayerID player, Packet& packet)
-{
-    try {
-        int bytesSent = m_Socket.send_to(
-            boost::asio::buffer(packet.Data(), packet.Size()),
-            m_ConnectedPlayers[player].Endpoint,
-            0);
-        // Network Debug data
-        if (isReadingData) {
-            m_NetworkData.TotalDataSent += packet.Size();
-            m_NetworkData.DataSentThisInterval += packet.Size();
-            m_NetworkData.AmountOfMessagesSent++;
-        }
-    } catch (const boost::system::system_error& e) {
-        // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
-        m_ConnectedPlayers[player].Endpoint = boost::asio::ip::udp::endpoint();
-    }
-}
-
-void Server::send(Packet & packet)
-{
-    m_Socket.send_to(
-        boost::asio::buffer(
-            packet.Data(),
-            packet.Size()),
-        m_ReceiverEndpoint,
-        0);
-    if (isReadingData) {
-        // Network Debug data
-        m_NetworkData.TotalDataSent += packet.Size();
-        m_NetworkData.DataSentThisInterval += packet.Size();
-    }
-}
-
 void Server::broadcast(Packet& packet)
 {
     for (auto& kv : m_ConnectedPlayers) {
         packet.ChangePacketID(kv.second.PacketID);
-        send(kv.first, packet);
+        send(packet, kv.second);
     }
 }
 
@@ -259,24 +175,6 @@ void Server::disconnect(PlayerID playerID)
     m_ConnectedPlayers.erase(playerID);
 }
 
-void Server::parseOnInputCommand(Packet& packet)
-{
-    PlayerID player = -1;
-    // Check which player it was who sent the message
-    player = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
-    if (player != -1) {
-        while (packet.DataReadSize() < packet.Size()) {
-            Events::InputCommand e;
-            e.Command = packet.ReadString();
-            e.PlayerID = player; // Set correct player id
-            e.Player = EntityWrapper(m_World, m_ConnectedPlayers.at(player).EntityID);
-            e.Value = packet.ReadPrimitive<float>();
-            m_EventBroker->Publish(e);
-            LOG_INFO("Server::parseOnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
-        }
-    }
-}
-
 void Server::parseOnPlayerDamage(Packet & packet)
 {
     Events::PlayerDamage e;
@@ -286,75 +184,6 @@ void Server::parseOnPlayerDamage(Packet & packet)
     //LOG_DEBUG("Server::parseOnPlayerDamage: Command is %s. Value is %f. PlayerID is %i.", e.DamageAmount, e.PlayerDamagedID, e.TypeOfDamage.c_str());
 }
 
-void Server::parseConnect(Packet& packet)
-{
-    LOG_INFO("Parsing connections");
-    // Check if player is already connected
-    if (GetPlayerIDFromEndpoint(m_ReceiverEndpoint) != -1) {
-        return;
-    }
-    for (auto& kv : m_ConnectedPlayers) {
-        if (kv.second.Endpoint.address() == m_ReceiverEndpoint.address() &&
-            kv.second.Endpoint.port() == m_ReceiverEndpoint.port()) {
-            // Already connected 
-            return;
-        }
-    }
-    // Create a new player
-    PlayerDefinition pd;
-    pd.EntityID = 0; // Overlook this
-    pd.Endpoint = m_ReceiverEndpoint;
-    pd.Name = packet.ReadString();
-    pd.PacketID = 0;
-    pd.StopTime = std::clock();
-    m_ConnectedPlayers[m_NextPlayerID++] = pd;
-    LOG_INFO("Spectator \"%s\" connected on IP: %s", pd.Name.c_str(), pd.Endpoint.address().to_string().c_str());
-
-    // Send a message to the player that connected
-    Packet connnectPacket(MessageType::Connect, pd.PacketID);
-    send(connnectPacket);
-
-    // Send notification that a player has connected
-    Packet notificationPacket(MessageType::PlayerConnected);
-    broadcast(notificationPacket);
-}
-
-void Server::parseDisconnect()
-{
-    LOG_INFO("%i: Parsing disconnect", m_PacketID);
-
-    for (auto& kv : m_ConnectedPlayers) {
-        if (kv.second.Endpoint.address() == m_ReceiverEndpoint.address() &&
-            kv.second.Endpoint.port() == m_ReceiverEndpoint.port()) {
-            disconnect(kv.first);
-            break;
-        }
-    }
-}
-
-void Server::parseClientPing()
-{
-    LOG_INFO("%i: Parsing ping", m_PacketID);
-    PlayerID player = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
-    if (player == -1) {
-        return;
-    }
-    // Return ping
-    Packet packet(MessageType::Ping, m_ConnectedPlayers[player].PacketID);
-    packet.WriteString("Ping received");
-    send(packet);
-}
-
-void Server::parsePing()
-{
-    for (int i = 0; i < m_ConnectedPlayers.size(); i++) {
-        if (m_ConnectedPlayers[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
-            m_ConnectedPlayers[i].StopTime = std::clock();
-            break;
-        }
-    }
-}
-
 void Server::identifyPacketLoss()
 {
     // if no packets lost, difference should be equal to 1
@@ -371,17 +200,6 @@ void Server::kick(PlayerID player)
     send(packet);
 }
 
-PlayerID Server::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
-{
-    for (auto& kv : m_ConnectedPlayers) {
-        if (kv.second.Endpoint.address() == endpoint.address() &&
-            kv.second.Endpoint.port() == endpoint.port()) {
-            return kv.first;
-        }
-    }
-    return -1;
-}
-
 bool Server::OnInputCommand(const Events::InputCommand & e)
 {
     //LOG_DEBUG("Server::OnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
@@ -408,7 +226,7 @@ bool Server::OnPlayerSpawned(const Events::PlayerSpawned & e)
     packet.WritePrimitive<EntityID>(e.Spawner.ID);
     // We don't send PlayerID here because it will always be set to -1
     packet.WriteString(m_ConnectedPlayers[e.PlayerID].Name);
-    send(e.PlayerID, packet);
+    send(packet, m_ConnectedPlayers[e.PlayerID]);
     return false;
 }
 
@@ -432,23 +250,3 @@ bool Server::OnComponentDeleted(const Events::ComponentDeleted & e)
     }
     return false;
 }
-
-void Server::parsePlayerTransform(Packet& packet)
-{
-    glm::vec3 position;
-    glm::vec3 orientation;
-    position.x = packet.ReadPrimitive<float>();
-    position.y = packet.ReadPrimitive<float>();
-    position.z = packet.ReadPrimitive<float>();
-    orientation.x = packet.ReadPrimitive<float>();
-    orientation.y = packet.ReadPrimitive<float>();
-    orientation.z = packet.ReadPrimitive<float>();
-
-    PlayerID playerID = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
-    EntityWrapper player(m_World, m_ConnectedPlayers.at(playerID).EntityID);
-
-    if (player.Valid()) {
-        player["Transform"]["Position"] = position;
-        player["Transform"]["Orientation"] = orientation;
-    }
-}

src/Engine/Network/TCPClient.cpp

@@ -0,0 +1,48 @@
+#include "Network/TCPClient.h"
+
+using namespace boost::asio::ip;
+
+TCPClient::TCPClient(ConfigFile * config) : Client(config)
+{ 
+    m_Endpoint = tcp::endpoint(boost::asio::ip::address::from_string(address), port);
+    m_Socket = boost::shared_ptr<tcp::socket>(new tcp::socket(m_IOService));
+}
+
+TCPClient::~TCPClient()
+{ 
+
+}
+
+void TCPClient::Start(World * world, EventBroker * eventBroker)
+{ 
+    Client::Start(world, eventBroker);
+    boost::system::error_code error = boost::asio::error::host_not_found;
+    while (error) {
+        m_Socket->close();
+        m_Socket->connect(m_Endpoint,error);
+        LOG_INFO(error.message().c_str());
+    }
+}
+
+void TCPClient::readFromServer()
+{ 
+
+}
+
+int TCPClient::receive(char * data)
+{
+    return 0;
+}
+
+void TCPClient::send(Packet & packet)
+{ 
+    m_Socket->send(boost::asio::buffer(
+        packet.Data(),
+        packet.Size()));
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+        m_NetworkData.AmountOfMessagesSent++;
+    }
+}

src/Engine/Network/TCPServer.cpp

@@ -0,0 +1,148 @@
+#include "Network/TCPServer.h"
+using namespace boost::asio::ip;
+
+TCPServer::TCPServer()
+{
+    acceptor = std::unique_ptr<tcp::acceptor>(new tcp::acceptor(m_IOService, tcp::endpoint(tcp::v4(), 27666)));
+}
+
+TCPServer::~TCPServer()
+{
+
+}
+
+void TCPServer::Start(World* world, EventBroker* eventBroker)
+{
+    Server::Start(world, eventBroker);
+}
+
+void TCPServer::readFromClients()
+{
+    acceptNewConnections();
+    for (auto& kv : m_ConnectedPlayers) {
+        while (kv.second.TCPSocket->available()) {
+            try {
+                bytesRead = receive(readBuffer, *kv.second.TCPSocket);
+                lastReceivedSocket = kv.second.TCPSocket;
+                Packet packet(readBuffer, bytesRead);
+                parseMessageType(packet);
+            } catch (const std::exception& err) {
+                //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
+            }
+        }
+    }
+
+    std::clock_t currentTime = std::clock();
+    // Send snapshot
+    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
+        sendSnapshot();
+        previousSnapshotMessage = currentTime;
+    }
+
+    // Send pings each 
+    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
+        sendPing();
+        previousePingMessage = currentTime;
+    }
+
+    // Time out logic
+    if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
+        checkForTimeOuts();
+        timOutTimer = currentTime;
+    }
+}
+
+void TCPServer::acceptNewConnections()
+{
+    boost::shared_ptr<tcp::socket> newSocket = boost::shared_ptr<tcp::socket>(new tcp::socket(m_IOService));
+    m_IOService.poll();
+    acceptor->async_accept(*newSocket,
+        boost::bind(&TCPServer::handle_accept, this, newSocket,
+            boost::asio::placeholders::error));
+}
+
+void TCPServer::handle_accept(boost::shared_ptr<tcp::socket> socket, const boost::system::error_code& error)
+{
+    if (!error) {
+        // Add tcp socket to connections
+        PlayerDefinition pd;
+        pd.StopTime = std::clock();
+        pd.TCPSocket = socket;
+        m_ConnectedPlayers[m_NextPlayerID++] = pd;
+    }
+}
+void TCPServer::parseClientPing()
+{
+
+}
+void TCPServer::parsePing()
+{
+
+}
+void TCPServer::parseDisconnect()
+{
+
+}
+void TCPServer::parseConnect(Packet & packet)
+{
+
+}
+void TCPServer::parseOnInputCommand(Packet & packet)
+{
+
+}
+void TCPServer::parsePlayerTransform(Packet & packet)
+{
+
+}
+void TCPServer::send(Packet & packet, PlayerDefinition & playerDefinition)
+{
+    try {
+        int bytesSent = playerDefinition.TCPSocket->send(
+            boost::asio::buffer(packet.Data(), packet.Size()),
+            0);
+        // Network Debug data
+        if (isReadingData) {
+            m_NetworkData.TotalDataSent += packet.Size();
+            m_NetworkData.DataSentThisInterval += packet.Size();
+            m_NetworkData.AmountOfMessagesSent++;
+        }
+    } catch (const boost::system::system_error& e) {
+        // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
+        playerDefinition.Endpoint = boost::asio::ip::udp::endpoint();
+    }
+}
+
+void TCPServer::send(Packet & packet)
+{
+    lastReceivedSocket->send(
+        boost::asio::buffer(
+            packet.Data(),
+            packet.Size()),
+        0);
+    if (isReadingData) {
+        // Network Debug data
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+    }
+}
+
+//boost::shared_ptr<boost::asio::ip::tcp::socket> socket
+int TCPServer::receive(char * data,boost::asio::ip::tcp::socket& socket)
+{
+    unsigned int length = socket.read_some(
+        boost::asio::buffer((void*)data, INPUTSIZE));
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataReceived += length;
+        m_NetworkData.DataReceivedThisInterval += length;
+        m_NetworkData.AmountOfMessagesReceived++;
+    }
+    return length;
+
+}
+
+PlayerID TCPServer::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
+{
+    return PlayerID();
+}

src/Game/Game.cpp

@@ -181,11 +181,11 @@ void Game::networkFunction()
     bool isServer = m_Config->Get<bool>("Networking.IsServer", false);
     if (!isServer) {
         m_IsClientOrServer = true;
-        m_ClientOrServer = new HybridClient(m_Config);
+        m_ClientOrServer = new TCPClient(m_Config);
     }
     if (isServer) {
         m_IsClientOrServer = true;
-        m_ClientOrServer = new Server();
+        m_ClientOrServer = new TCPServer();
     }
     m_ClientOrServer->Start(m_World, m_EventBroker);