Merge remote-tracking branch 'origin/Networking' into Networking

# Conflicts:
#	src/Engine/Network/Client.cpp
#	src/Engine/Network/Server.cpp

include/Engine/Network/Client.h

@@ -38,12 +38,12 @@ private:
     void Disconnect();
     void Ping();
 	void MoveMessageHead(char*& data, size_t& length, size_t stepSize);
-	void ParseMessageType(char* data, size_t length);
+	void ParseMessageType(Package& package);
-	void ParseEventMessage(char* data, size_t length);
+	void ParseEventMessage(Package& package);
-	void ParseConnect(char* data, size_t length);
+	void ParseConnect(Package& package);
 	void ParsePing();
 	void ParseServerPing();
-	void ParseSnapshot(char* data, size_t length);
+	void ParseSnapshot(Package& package);
 	void CreateNewPlayer(int i);
 	void IdentifyPacketLoss();
 

include/Engine/Network/Package.h

@@ -3,6 +3,7 @@
 
 #include <string>
 #include "Network/MessageType.h"
+#include "Core/Util/Logging.h"
 
 // Defines the 
 class Package
@@ -11,6 +12,8 @@ public:
     // arg1: Type of message (Connect, Disconnect...)
     // arg2: PackageID for identifying packet loss.
     Package(MessageType type, unsigned int& packageID);
+    // Used to create package from already existing data buffer.
+    Package(char* data, int sizeOfPackage);
     ~Package();
     // Add primitive types like int, float, char...
     template<typename T>
@@ -19,13 +22,29 @@ public:
         memcpy(m_Data + m_Offset, &val, sizeof(T));
         m_Offset += sizeof(T);
     }
+    // Pops the first element as if it was a primitive.
+    template<typename T>
+    T PopFrontPrimitive()
+    {
+        if (m_Offset < m_ReturnDataOffset + sizeof(T)) {
+            LOG_WARNING("Package PopFrontPrimitive(): You are trying to remove more than what exists in this package!");
+            return -1;
+        }
+        T returnValue;
+        memcpy(&returnValue, m_Data + m_ReturnDataOffset, sizeof(T));
+        m_ReturnDataOffset += sizeof(T);
+        return returnValue;
+    }
     void AddString(std::string str);
+    // Pops the first element as if it was a string.
+    std::string PopFrontString();
 
     int Size() { return m_Offset; };
     char* Data() { return m_Data; };
 
 private:
     char* m_Data = new char[128];
+    unsigned int m_ReturnDataOffset = 0;
     int m_Offset = 0;
 };
 

include/Engine/Network/Server.h

@@ -60,13 +60,13 @@ private:
     void SendPing();
     void CheckForTimeOuts();
     void Disconnect(int i);
-    void ParseMessageType(char* data, size_t length);
+    void ParseMessageType(Package& package);
-    void ParseEvent(char* data, size_t length);
+    void ParseEvent(Package& package);
-    void ParseConnect(char* data, size_t length);
+    void ParseConnect(Package& package);
     void ParseDisconnect();
     void ParseClientPing();
     void ParseServerPing();
-    void ParseSnapshot(char* data, size_t length);
+    void ParseSnapshot(Package& package);
     void IdentifyPacketLoss();
 };
 

src/Engine/Network/Client.cpp

@@ -71,7 +71,10 @@ void Client::ReadFromServer()
     while (m_ThreadIsRunning) {
         if (m_Socket.available()) {
             bytesRead = Receive(readBuf, INPUTSIZE);
-            ParseMessageType(readBuf, bytesRead);
+            if (bytesRead > 0) {
+                Package package(readBuf, bytesRead);
+                ParseMessageType(package);
+            }
         }
         std::clock_t currentTime = std::clock();
         if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
@@ -84,9 +87,6 @@ void Client::ReadFromServer()
 void Client::SendSnapshotToServer()
 {
     // Reset previouse key state in snapshot.
-    //Package message(MessageType::Event, m_SendPacketID);
-    //message.AddString(m_NextSnapshot.InputForward);
-    //Send(message);
     m_NextSnapshot.InputForward = "";
     m_NextSnapshot.InputRight = "";
     // See if any movement keys are down
@@ -128,21 +128,19 @@ void Client::SendSnapshotToServer()
     }
 }
 
-void Client::ParseMessageType(char* data, size_t length)
+void Client::ParseMessageType(Package& package)
 {
-    int messageType = -1;
+    int messageType = package.PopFrontPrimitive<int>();
-    memcpy(&messageType, data, sizeof(int)); // Read what type off message was sent from server
+    if (messageType == -1)
-    MoveMessageHead(data, length, sizeof(int)); // Move the message head to know where to read from
+        return;
-
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
-    memcpy(&m_PacketID, data, sizeof(int)); //Read new packet id
+    m_PacketID = package.PopFrontPrimitive<int>(); //Read new packet id
-    MoveMessageHead(data, length, sizeof(int));
     IdentifyPacketLoss();
 
     switch (static_cast<MessageType>(messageType)) {
     case MessageType::Connect:
-        ParseConnect(data, length);
+        ParseConnect(package);
         break;
     case MessageType::ClientPing:
         ParsePing();
@@ -153,25 +151,23 @@ void Client::ParseMessageType(char* data, size_t length)
     case MessageType::Message:
         break;
     case MessageType::Snapshot:
-        ParseSnapshot(data, length);
+        ParseSnapshot(package);
         break;
     case MessageType::Disconnect:
         break;
     case MessageType::Event:
-        ParseEventMessage(data, length);
+        ParseEventMessage(package);
         break;
     default:
         break;
     }
 }
 
-void Client::ParseConnect(char* data, size_t len)
+void Client::ParseConnect(Package& package)
 {
-    memcpy(&m_PacketID, data, sizeof(int));
+    m_PacketID = package.PopFrontPrimitive<int>();
     m_PreviousPacketID = m_PacketID;
-    MoveMessageHead(data, len, sizeof(int));
+    m_PlayerID = package.PopFrontPrimitive<int>();
-    memcpy(&m_PlayerID, data, sizeof(int));
-    MoveMessageHead(data, len, sizeof(int));
     std::cout << m_PacketID << ": I am player: " << m_PlayerID << std::endl;
 }
 
@@ -189,64 +185,53 @@ void Client::ParseServerPing()
     //std::cout << "Parsing ping." << std::endl;
 }
 
-void Client::ParseEventMessage(char* data, size_t length)
+void Client::ParseEventMessage(Package& package)
 {
     int Id = -1;
-    std::string command = std::string(data);
+    std::string command = package.PopFrontString();
     if (command.find("+Player") != std::string::npos) {
-        MoveMessageHead(data, length, command.size() + 1);
+        Id = package.PopFrontPrimitive<int>();
-        memcpy(&Id, data, sizeof(int));
-        MoveMessageHead(data, length, sizeof(int));
         // Sett Player name
         m_PlayerDefinitions[Id].Name = command.erase(0, 7);
     } else {
-        std::cout << m_PacketID << ": Event message: " << std::string(data) << std::endl;
+        std::cout << m_PacketID << ": Event message: " << command << std::endl;
+    }
 }
 
-    MoveMessageHead(data, length, std::string(data).size() + 1);
+void Client::ParseSnapshot(Package& package)
-}
-
-void Client::ParseSnapshot(char* data, size_t length)
 {
-    std::cout << m_PacketID << ": Parsing incoming snapshot." << std::endl;
+    //std::cout << m_PacketID << ": Parsing incoming snapshot." << std::endl;
     std::string tempName;
     for (size_t i = 0; i < MAXCONNECTIONS; i++) {
         // We're checking for empty name for now. This might not be the best way,
         // but it is to avoid sending redundant data.
+        tempName = package.PopFrontString();
         
-        // Read position data
-        glm::vec3 playerPos;
-        memcpy(&playerPos.x, data, sizeof(float));
-        MoveMessageHead(data, length, sizeof(float));
-        memcpy(&playerPos.y, data, sizeof(float));
-        MoveMessageHead(data, length, sizeof(float));
-        memcpy(&playerPos.z, data, sizeof(float));
-        MoveMessageHead(data, length, sizeof(float));
 
-        tempName = std::string(data);
-
-        // +1 for null terminator
-        MoveMessageHead(data, length, tempName.size() + 1);
         // Apply the position data read to the player entity
         // New player connected on the server side 
         if (m_PlayerDefinitions[i].Name == "" && tempName != "") {
-            //CreateNewPlayer(i);
             m_PlayerDefinitions[i].Name = tempName;
             m_PlayersToCreate.push_back(i);
         } else if (m_PlayerDefinitions[i].Name != "" && tempName == "") {
             // Someone disconnected
             // TODO: Insert code here
+            break;
         } else if (m_PlayerDefinitions[i].Name == "" && tempName == "") {
             // Not a connected player
             break;
         }
+        // Read position data
+        glm::vec3 playerPos;
+        playerPos.x = package.PopFrontPrimitive<float>();
+        playerPos.y = package.PopFrontPrimitive<float>();
+        playerPos.z = package.PopFrontPrimitive<float>();
+        // Move player to server position
         if (m_PlayerDefinitions[i].EntityID != -1) {
-            if (m_World->HasComponent(m_PlayerDefinitions[i].EntityID, "Player")) {
             m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform")["Position"] = playerPos;
         }
     }
 }
-}
 
 int Client::Receive(char* data, size_t length)
 {

src/Engine/Network/Package.cpp

@@ -11,6 +11,14 @@ Package::Package(MessageType type,unsigned int& packageID)
     packageID++;
 }
 
+
+Package::Package(char* data, int sizeOfPackage)
+{
+    // Create message
+    memcpy(m_Data, data, sizeOfPackage);
+    m_Offset = sizeOfPackage;
+}
+
 Package::~Package()
 {
     delete[] m_Data;
@@ -22,3 +30,15 @@ void Package::AddString(std::string str)
     memcpy(m_Data + m_Offset, str.data(), (str.size() + 1) * sizeof(char));
     m_Offset += (str.size() + 1) * sizeof(char);
 }
+
+std::string Package::PopFrontString()
+{
+    std::string returnValue(m_Data + m_ReturnDataOffset);
+    if (m_Offset < m_ReturnDataOffset + returnValue.size()){
+        LOG_WARNING("Package PopFrontString(): Oh no! You are trying to remove things outside my memory kingdom");
+        return "PopFrontString Failed";
+    }   
+    // +1 for null terminator.
+    m_ReturnDataOffset += returnValue.size() + 1;
+    return returnValue;
+}

src/Engine/Network/Server.cpp

@@ -73,7 +73,8 @@ void Server::ReadFromClients()
         if (m_ThreadIsRunning && m_Socket.available()) {
             try {
                 bytesRead = Receive(readBuf, INPUTSIZE);
-                ParseMessageType(readBuf, bytesRead);
+                Package package(readBuf, bytesRead);
+                ParseMessageType(package);
             } catch (const std::exception& err) {
                 // To not spam "socket closed messages"
                 //if (std::string(err.what()).find("forcefully closed") != std::string::npos) {
@@ -129,20 +130,17 @@ void Server::InputLoop()
     }
 }
 
-void Server::ParseMessageType(char * data, size_t length)
+void Server::ParseMessageType(Package& package)
 {
-    int messageType = -1;
+    int messageType = package.PopFrontPrimitive<int>(); // Read what type off message was sent from server
-    memcpy(&messageType, data, sizeof(int)); // Read what type off message was sent from server
-    MoveMessageHead(data, length, sizeof(int)); // Move the message head to know where to read from
 
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
-    memcpy(&m_PacketID, data, sizeof(int)); //Read new packet id
+    m_PacketID = package.PopFrontPrimitive<int>(); //Read new packet id
-    MoveMessageHead(data, length, sizeof(int));
     //IdentifyPacketLoss(); 
     switch (static_cast<MessageType>(messageType)) {
     case MessageType::Connect:
-        ParseConnect(data, length);
+        ParseConnect(package);
         break;
     case MessageType::ClientPing:
         //ParseClientPing();
@@ -153,13 +151,13 @@ void Server::ParseMessageType(char * data, size_t length)
     case MessageType::Message:
         break;
     case MessageType::Snapshot:
-        ParseSnapshot(data, length);
+        ParseSnapshot(package);
         break;
     case MessageType::Disconnect:
         ParseDisconnect();
         break;
     case MessageType::Event:
-        ParseEvent(data, length);
+        ParseEvent(package);
         break;
     default:
         break;
@@ -223,6 +221,10 @@ void Server::SendSnapshot()
 {
     Package package(MessageType::Snapshot, m_SendPacketID);
     for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+        
+        // Send an empty name if there is no player connected on this position.
+        package.AddString(m_PlayerDefinitions[i].Name);
+
         if (m_PlayerDefinitions[i].EntityID == -1) {
             continue;
         }
@@ -234,8 +236,6 @@ void Server::SendSnapshot()
         package.AddPrimitive<float>(playerPos.x);
         package.AddPrimitive<float>(playerPos.y);
         package.AddPrimitive<float>(playerPos.z);
-
-        package.AddString(m_PlayerDefinitions[i].Name);
     }
     Broadcast(package);
 }
@@ -287,7 +287,7 @@ void Server::Disconnect(int i)
     m_PlayerDefinitions[i].Name = "";
 }
 
-void Server::ParseEvent(char * data, size_t length)
+void Server::ParseEvent(Package& package)
 {
     size_t i;
     for (i = 0; i < MAXCONNECTIONS; i++) {
@@ -300,31 +300,30 @@ void Server::ParseEvent(char * data, size_t length)
         return;
 
     unsigned int entityId = m_PlayerDefinitions[i].EntityID;
-    std::string templalala = std::string(data);
+    std::string eventString = package.PopFrontString();
-
+    if ("+Forward" == eventString) {
-    if ("+Forward" == std::string(data)) {
         m_World->GetComponent(entityId, "Player")["Forward"] = true;
         m_World->GetComponent(entityId, "Player")["Back"] = false;
-    } else if ("-Forward" == std::string(data)) {
+    } else if ("-Forward" == eventString) {
         m_World->GetComponent(entityId, "Player")["Forward"] = false;
         m_World->GetComponent(entityId, "Player")["Back"] = true;
-    } else if ("0Forward" == std::string(data)) {
+    } else if ("0Forward" == eventString) {
         m_World->GetComponent(entityId, "Player")["Forward"] = false;
         m_World->GetComponent(entityId, "Player")["Back"] = false;
     }
-    if ("+Right" == std::string(data)) {
+    if ("+Right" == eventString) {
         m_World->GetComponent(entityId, "Player")["Left"] = false;
         m_World->GetComponent(entityId, "Player")["Right"] = true;
-    } else if ("-Right" == std::string(data)) {
+    } else if ("-Right" == eventString) {
         m_World->GetComponent(entityId, "Player")["Right"] = false;
         m_World->GetComponent(entityId, "Player")["Left"] = true;
-    } else if ("0Right" == std::string(data)) {
+    } else if ("0Right" == eventString) {
         m_World->GetComponent(entityId, "Player")["Right"] = false;
         m_World->GetComponent(entityId, "Player")["Left"] = false;
     }
 }
 
-void Server::ParseConnect(char * data, size_t length)
+void Server::ParseConnect(Package& package)
 {
     std::cout << "Parsing connection." << std::endl;
     // Check if player is already connected
@@ -347,9 +346,8 @@ void Server::ParseConnect(char * data, size_t length)
             m_PlayersToCreate.push_back(i);
 
             m_PlayerDefinitions[i].Endpoint = m_ReceiverEndpoint;
-            m_PlayerDefinitions[i].Name = std::string(data);
+            m_PlayerDefinitions[i].Name = package.PopFrontString();
-            // +1 is the null terminator
+
-            MoveMessageHead(data, length, m_PlayerDefinitions[i].Name.size() + 1);
             m_StopTimes[i] = std::clock();
 
             std::cout << m_PacketID << ": Player \"" << m_PlayerDefinitions[i].Name << "\" connected on IP: " <<
@@ -401,7 +399,7 @@ void Server::ParseServerPing()
 }
 
 // NOT USED
-void Server::ParseSnapshot(char * data, size_t length)
+void Server::ParseSnapshot(Package& package)
 {
     // Does no logic. Returns snapshot if client request one
     // The snapshot is not a real snapshot tho...