WIP

include/Engine/Network/Client.h

@@ -36,12 +36,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

@@ -54,13 +54,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

@@ -6,7 +6,7 @@ using namespace boost::asio::ip;
 Client::Client() : m_Socket(m_IOService)
 {
     // Set up network stream
-    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string("192.168.1.2"), 13);
+    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string("192.168.1.6"), 13);
     m_NextSnapshot.InputForward = "";
     m_NextSnapshot.InputRight = "";
 }
@@ -61,7 +61,8 @@ void Client::ReadFromServer()
     while (m_ThreadIsRunning) {
         if (m_Socket.available()) {
             bytesRead = Receive(readBuf, INPUTSIZE);
-            ParseMessageType(readBuf, bytesRead);
+            Package package(readBuf,bytesRead);
+            ParseMessageType(package);
         }
         std::clock_t currentTime = std::clock();
         if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
@@ -107,21 +108,17 @@ 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
-    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:
         ParsePing();
@@ -132,19 +129,19 @@ 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_PreviousPacketID = m_PacketID;
@@ -168,7 +165,7 @@ 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);
@@ -187,7 +184,7 @@ void Client::ParseEventMessage(char* data, size_t length)
 
 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,

src/Engine/Network/Package.cpp

@@ -1,24 +1,44 @@
 #include "Network/Package.h"
 
-Package::Package(MessageType type,unsigned int& packageID)
+Package::Package(MessageType type, unsigned int& packageID)
 {
-	// Create message header
+    // Create message header
-	// Add message type
+    // Add message type
-	int messageType = static_cast<int>(type);
+    int messageType = static_cast<int>(type);
     Package::AddPrimitive<int>(messageType);
     packageID = packageID % 1000; // Packet id modulos
     Package::AddPrimitive<int>(packageID);
     packageID++;
 }
 
+
+Package::Package(char* data, int sizeOfPackage)
+{
+    // Create message
+    memcpy(m_Data, data, sizeOfPackage);
+    m_Offset = sizeOfPackage;
+}
+
 Package::~Package()
 {
-	delete[] m_Data;
+    delete[] m_Data;
 }
 
 void Package::AddString(std::string str)
 {
-	// Message, add one extra byte for null terminator
+    // Message, add one extra byte for null terminator
-	memcpy(m_Data + m_Offset, str.data(), (str.size() + 1) * sizeof(char));
+    memcpy(m_Data + m_Offset, str.data(), (str.size() + 1) * sizeof(char));
-	m_Offset += (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";
+    }   
+
+    m_ReturnDataOffset += returnValue.size();
+    return returnValue;
 }

src/Engine/Network/Server.cpp

@@ -56,7 +56,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) {
@@ -111,21 +112,18 @@ 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(); // crashed when it started to spam!
 
     switch (static_cast<MessageType>(messageType)) {
     case MessageType::Connect:
-        ParseConnect(data, length);
+        ParseConnect(package);
         break;
     case MessageType::ClientPing:
         //ParseClientPing();
@@ -136,13 +134,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;
@@ -268,7 +266,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++) {
@@ -281,31 +279,32 @@ void Server::ParseEvent(char * data, size_t length)
         return;
 
     unsigned int entityId = m_PlayerDefinitions[i].EntityID;
-    if ("+Forward" == std::string(data)) {
+    std::string eventString = package.PopFrontString();
+    if ("+Forward" == eventString) {
         glm::vec3 temp = m_World->GetComponent(entityId, "Transform")["Position"];
         temp.z -= 0.1f;
         m_World->GetComponent(entityId, "Transform")["Position"] = temp;
     }
-    if ("-Forward" == std::string(data)) {
+    if ("-Forward" == eventString) {
         glm::vec3 temp = m_World->GetComponent(entityId, "Transform")["Position"];
         temp.z += 0.1f;
         m_World->GetComponent(entityId, "Transform")["Position"] = temp;
     }
 
-    if ("+Right" == std::string(data)) {
+    if ("+Right" == eventString) {
         glm::vec3 temp = m_World->GetComponent(entityId, "Transform")["Position"];
         temp.x += 0.1f;
         m_World->GetComponent(entityId, "Transform")["Position"] = temp;
     }
 
-    if ("-Right" == std::string(data)) {
+    if ("-Right" == eventString) {
         glm::vec3 temp = m_World->GetComponent(entityId, "Transform")["Position"];
         temp.x -= 0.1f;
         m_World->GetComponent(entityId, "Transform")["Position"] = temp;
     }
 }
 
-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
@@ -327,9 +326,8 @@ void Server::ParseConnect(char * data, size_t length)
             model["Color"] = glm::vec4(rand()%255 / 255.f, rand()%255 / 255.f, rand() %255 / 255.f, 1.f);
 
             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: " <<
@@ -381,7 +379,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...