Cleaned up code and fixed crash when closing client before server when using udp.

include/Engine/Network/Client.h

@@ -103,9 +103,9 @@ protected:
     bool OnPlayerSpawned(const Events::PlayerSpawned& e);
 
 private:
-    //UDPClient m_UDPClient;
+    UDPClient m_UDPClient;
     //TCPClient m_TCPClient;
-    TCPClient m_UDPClient;
+    //TCPClient m_UDPClient;
 };
 
 #endif

include/Engine/Network/NetworkServer.h

@@ -16,17 +16,6 @@ public:
     virtual void Send(Packet & packet) = 0;
 protected:
     char m_ReadBuffer[BUFFERSIZE] = { 0 };
-    //void handle_accept(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code & error);
-    //void parseConnect(Packet & packet);
-    //void readFromClients();
-
-    //public:
-    //    virtual void Connect(std::string playerName, std::string address, int port) = 0;
-    //    virtual void Disconnect() = 0;
-    //    virtual Packet Receive() = 0;
-    //    virtual void Send(Packet & packet) = 0;
-    //protected:
-    //    char m_ReadBuffer[BUFFERSIZE] = { 0 };
 };
 
 #endif

include/Engine/Network/Server.h

@@ -92,8 +92,8 @@ protected:
     EventRelay<Server, Events::ComponentDeleted> m_EComponentDeleted;
     bool OnComponentDeleted(const Events::ComponentDeleted& e);
 private:
-    TCPServer m_TCPServer;
+    //TCPServer m_TCPServer;
-    //UDPServer m_UDPServer;
+    UDPServer m_UDPServer;
 };
 
 #endif

include/Engine/Network/TCPClient.h

@@ -16,10 +16,6 @@ public:
     void Send(Packet & packet);
     bool IsSocketAvailable();
 private:
-    // Assio UDP logic
-    //boost::asio::io_service m_IOService;
-    //boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
-    //boost::shared_ptr<boost::asio::ip::udp::socket> m_Socket;
     // Assio TCP logic
     boost::asio::ip::tcp::endpoint m_Endpoint;
     boost::asio::io_service m_IOService;

include/Engine/Network/UDPClient.h

@@ -3,10 +3,6 @@
 
 #include <boost/asio.hpp>
 #include "Network/NetworkClient.h"
-//virtual void Connect(std::string address, int port) = 0;
-//virtual int Receive(char * data) = 0;
-//virtual void Send(Packet & packet) = 0;
-//virtual void Disconnect() = 0;
 
 class UDPClient : public NetworkClient
 {

include/Engine/Network/UDPServer.h

@@ -3,11 +3,6 @@
 
 #include "NetworkServer.h"
 #include <boost/asio/ip/udp.hpp>
-//
-//virtual void AcceptNewConnections() = 0;
-//virtual void Receive(Packet & packet, PlayerDefinition & playerDefinition) = 0;
-//virtual void Send(Packet & packet, PlayerDefinition & playerDefinition) = 0;
-//virtual  void Send(Packet & packet) = 0;
 
 class UDPServer : public NetworkServer
 {
@@ -16,7 +11,6 @@ public:
     ~UDPServer();
     void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers);
     void Receive(Packet & packet, PlayerDefinition & playerDefinition);
-    //void parseConnect(Packet & packet, PlayerDefinition & playerDefinition);
     void Send(Packet & packet, PlayerDefinition & playerDefinition);
     void Send(Packet & packet);
     bool IsSocketAvailable();

src/Engine/Network/Server.cpp

@@ -23,36 +23,37 @@ void Server::Start(World* world, EventBroker* eventBroker)
 
 void Server::Update()
 {
-    m_TCPServer.AcceptNewConnections(m_NextPlayerID, m_ConnectedPlayers);
     PlayerDefinition pd;
-    for (auto& kv : m_ConnectedPlayers) {
+    
-        while (kv.second.TCPSocket->available()) {
+    //m_TCPServer.AcceptNewConnections(m_NextPlayerID, m_ConnectedPlayers);
-            // Packet will get real data in receive
+    //for (auto& kv : m_ConnectedPlayers) {
-            Packet packet(MessageType::Invalid);
+    //    while (kv.second.TCPSocket->available()) {
-            m_TCPServer.Receive(packet, kv.second);
+    //        // Packet will get real data in receive
-            m_Address = kv.second.TCPSocket->remote_endpoint().address();
+    //        Packet packet(MessageType::Invalid);
-            m_Port = kv.second.TCPSocket->remote_endpoint().port();
+    //        m_TCPServer.Receive(packet, kv.second);
-            if (packet.GetMessageType() == MessageType::Connect) {
+    //        m_Address = kv.second.TCPSocket->remote_endpoint().address();
-                parseTCPConnect(packet);
+    //        m_Port = kv.second.TCPSocket->remote_endpoint().port();
-            } else {
+    //        if (packet.GetMessageType() == MessageType::Connect) {
-                parseMessageType(packet);
+    //            parseTCPConnect(packet);
-            }
+    //        } else {
-        }
+    //            parseMessageType(packet);
-    }
+    //        }
-
-    //while (m_UDPServer.IsSocketAvailable()) {
-    //    // Packet will get real data in receive
-    //    Packet packet(MessageType::Invalid);
-    //    m_UDPServer.Receive(packet, pd);
-    //    m_Address = pd.Endpoint.address();
-    //    m_Port = pd.Endpoint.port();
-    //    if (packet.GetMessageType() == MessageType::Connect) {
-    //        parseConnect(packet, pd);
-    //    } else {
-    //        parseMessageType(packet);
     //    }
     //}
 
+    while (m_UDPServer.IsSocketAvailable()) {
+        // Packet will get real data in receive
+        Packet packet(MessageType::Invalid);
+        m_UDPServer.Receive(packet, pd);
+        m_Address = pd.Endpoint.address();
+        m_Port = pd.Endpoint.port();
+        if (packet.GetMessageType() == MessageType::Connect) {
+            parseConnect(packet, pd);
+        } else {
+            parseMessageType(packet);
+        }
+    }
+
     std::clock_t currentTime = std::clock();
     // Send snapshot
     if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
@@ -118,7 +119,7 @@ void Server::broadcast(Packet& packet)
 {
     for (auto& kv : m_ConnectedPlayers) {
         packet.ChangePacketID(kv.second.PacketID);
-        m_TCPServer.Send(packet, kv.second);
+        m_UDPServer.Send(packet, kv.second);
     }
 }
 
@@ -213,54 +214,54 @@ void Server::checkForTimeOuts()
 }
 
 void Server::parseConnect(Packet & packet, PlayerDefinition & pd)
-{
-    //LOG_INFO("Parsing connections");
-    //// Check if player is already connected
-    //if (GetPlayerIDFromEndpoint() != -1) {
-    //    return;
-    //}
-    //// Create a new player
-    //pd.EntityID = 0; // Overlook this
-    //pd.Address = pd.Endpoint.address();
-    //pd.Port = pd.Endpoint.port();
-    //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);
-    //m_UDPServer.Send(connnectPacket);
-
-    //// Send notification that a player has connected
-    //Packet notificationPacket(MessageType::PlayerConnected);
-    //broadcast(notificationPacket);
-}
-
-void Server::parseTCPConnect(Packet & packet)
 {
     LOG_INFO("Parsing connections");
     // Check if player is already connected
-    PlayerID playerID = GetPlayerIDFromEndpoint();
+    if (GetPlayerIDFromEndpoint() != -1) {
-    if (playerID = -1) {
         return;
     }
     // Create a new player
-    m_ConnectedPlayers.at(playerID).EntityID = 0; // Overlook this
+    pd.EntityID = 0; // Overlook this
-    m_ConnectedPlayers.at(playerID).Name = packet.ReadString();
+    pd.Address = pd.Endpoint.address();
-    m_ConnectedPlayers.at(playerID).PacketID = 0;
+    pd.Port = pd.Endpoint.port();
-    m_ConnectedPlayers.at(playerID).StopTime = std::clock();
+    pd.Name = packet.ReadString();
-    LOG_INFO("Spectator \"%s\" connected on IP: %s", m_ConnectedPlayers.at(playerID).Name.c_str(), m_ConnectedPlayers.at(playerID).Endpoint.address().to_string().c_str());
+    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, m_ConnectedPlayers.at(playerID).PacketID);
+    Packet connnectPacket(MessageType::Connect, pd.PacketID);
-    m_TCPServer.Send(connnectPacket);
+    m_UDPServer.Send(connnectPacket);
 
     // Send notification that a player has connected
     Packet notificationPacket(MessageType::PlayerConnected);
-    //broadcast(notificationPacket);
+    broadcast(notificationPacket);
 }
+//
+//void Server::parseTCPConnect(Packet & packet)
+//{
+//    LOG_INFO("Parsing connections");
+//    // Check if player is already connected
+//    PlayerID playerID = GetPlayerIDFromEndpoint();
+//    if (playerID = -1) {
+//        return;
+//    }
+//    // Create a new player
+//    m_ConnectedPlayers.at(playerID).EntityID = 0; // Overlook this
+//    m_ConnectedPlayers.at(playerID).Name = packet.ReadString();
+//    m_ConnectedPlayers.at(playerID).PacketID = 0;
+//    m_ConnectedPlayers.at(playerID).StopTime = std::clock();
+//    LOG_INFO("Spectator \"%s\" connected on IP: %s", m_ConnectedPlayers.at(playerID).Name.c_str(), m_ConnectedPlayers.at(playerID).Endpoint.address().to_string().c_str());
+//
+//    // Send a message to the player that connected
+//    Packet connnectPacket(MessageType::Connect, m_ConnectedPlayers.at(playerID).PacketID);
+//    m_TCPServer.Send(connnectPacket);
+//
+//    // Send notification that a player has connected
+//    Packet notificationPacket(MessageType::PlayerConnected);
+//    //broadcast(notificationPacket);
+//}
 
 void Server::parseDisconnect()
 {
@@ -310,7 +311,7 @@ void Server::kick(PlayerID player)
 {
     disconnect(player);
     Packet packet = Packet(MessageType::Kick);
-    m_TCPServer.Send(packet);
+    m_UDPServer.Send(packet);
 }
 
 bool Server::OnInputCommand(const Events::InputCommand & e)
@@ -339,7 +340,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);
-    m_TCPServer.Send(packet, m_ConnectedPlayers[e.PlayerID]);
+    m_UDPServer.Send(packet, m_ConnectedPlayers[e.PlayerID]);
     return false;
 }
 
@@ -375,7 +376,7 @@ void Server::parseClientPing()
     // Return ping
     Packet packet(MessageType::Ping, m_ConnectedPlayers[player].PacketID);
     packet.WriteString("Ping received");
-    m_TCPServer.Send(packet);
+    m_UDPServer.Send(packet);
 }
 
 void Server::parsePing()

src/Engine/Network/TCPClient.cpp

@@ -83,7 +83,6 @@ void TCPClient::Send(Packet & packet)
     m_Socket->send(boost::asio::buffer(
         packet.Data(),
         packet.Size()), 0, error);
-    //Network::logSentData(packet.Size());
 }
 
 bool TCPClient::IsSocketAvailable()

src/Engine/Network/TCPServer.cpp

@@ -12,8 +12,6 @@ TCPServer::~TCPServer()
 
 void TCPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
 {
-    //PlayerDefinition pd;
-    //connectedPlayers[nextPlayerID++] = pd;
     boost::shared_ptr<tcp::socket> newSocket = boost::shared_ptr<tcp::socket>(new tcp::socket(m_IOService));
     m_IOService.poll();
     acceptor->async_accept(*newSocket,

src/Engine/Network/UDPServer.cpp

@@ -6,8 +6,7 @@ UDPServer::UDPServer()
 }
 
 UDPServer::~UDPServer()
-{
+{ }
-}
 
 void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
 {
@@ -49,13 +48,16 @@ bool UDPServer::IsSocketAvailable()
 
 int UDPServer::readBuffer(char* data)
 {
+    boost::system::error_code error = boost::asio::error::host_not_found;
     unsigned int length = m_Socket->receive_from(
         boost::asio::buffer((void*)data
             , BUFFERSIZE)
-        , m_ReceiverEndpoint, 0);
+        , m_ReceiverEndpoint, 0, error);
+    if (error) {
+        LOG_WARNING(error.message().c_str());
+    }
     return length;
 }
 
 void UDPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
-{
+{ }
-}