Kinda works like before

include/Engine/Network/Packet.h

@@ -58,12 +58,15 @@ public:
     void UpdateSize();
     char* ReadData(int SizeOfData);
     void ChangePacketID(unsigned int& packetID);
+    void ChangeSequenceNumber(int sequenceNumber, int sequenceLength);
     size_t Size() { return m_Offset; };
     char* Data() { return m_Data; };
     MessageType GetMessageType();
     size_t DataReadSize() { return m_ReturnDataOffset; }
     size_t MaxSize() { return m_MaxPacketSize; }
     size_t HeaderSize() { return m_HeaderSize; }
+    size_t SequenceNumber();
+    size_t SequenceLength();
 
 private:
     char* m_Data;

include/Engine/Network/UDPClient.h

@@ -1,11 +1,13 @@
 #ifndef UDPClient_h__
 #define UDPClient_h__
+#include <unordered_map>
 
 #include <boost/asio.hpp>
 #include "Network/NetworkClient.h"
 
 class UDPClient : public NetworkClient
 {
+    // TODO: add packets to map.
 public:
     UDPClient();
     ~UDPClient();
@@ -23,6 +25,7 @@ private:
     boost::shared_ptr<boost::asio::ip::udp::socket> m_Socket;
     int readBuffer();
     PacketID m_SendPacketID = 0;
+    std::unordered_map<unsigned int, boost::shared_ptr<char>> packetSegmentMap;
 };
 
 #endif

include/Engine/Network/UDPServer.h

@@ -3,6 +3,7 @@
 
 #include "NetworkServer.h"
 #include <boost/asio/ip/udp.hpp>
+#define MAXPACKETSIZE 32000
 
 class UDPServer : public NetworkServer
 {

src/Engine/Network/Packet.cpp

@@ -35,11 +35,13 @@ void Packet::Init(MessageType type, unsigned int & packetID,
     m_ReturnDataOffset = 0;
     m_Offset = 0;
     // Create message header
+    // If you add things before here be sure to change in GetMessageType()
+    // SequenceNumber(), SequenceLength(), ChangePacketID()
     // allocate memory for size of packet, sequenceNumber and totalPacketesInSequence
     WritePrimitive<int>(0);
+    // SequenceNumber and totalAmountOfPackets position in array is hard coded
     WritePrimitive(sequenceNumber);
     WritePrimitive(totalAmountOfPackets);
-    // If you add things before here be sure to change in GetMessageType()
     // Add message type
     int messageType = static_cast<int>(type);
     WritePrimitive<int>(messageType);
@@ -127,7 +129,13 @@ void Packet::ChangePacketID(unsigned int & packetID)
 {
     packetID = packetID + 1;
     // Overwrite old PacketID
-    memcpy(m_Data + 2*sizeof(int), &packetID, sizeof(int));
+    memcpy(m_Data + 4 * sizeof(int), &packetID, sizeof(int));
+}
+
+void Packet::ChangeSequenceNumber(int sequenceNumber, int sequenceLength)
+{
+    memcpy(&sequenceNumber, m_Data + sizeof(int), sizeof(int));
+    memcpy(&sequenceLength, m_Data + 2 * sizeof(int), sizeof(int));
 }
 
 MessageType Packet::GetMessageType()
@@ -137,6 +145,23 @@ MessageType Packet::GetMessageType()
     return messagType;
 }
 
+//WritePrimitive(sequenceNumber);
+//WritePrimitive(totalAmountOfPackets);
+
+size_t Packet::SequenceNumber()
+{
+    size_t sequenceNumber;
+    memcpy(&sequenceNumber, m_Data + sizeof(int), sizeof(int));
+    return sequenceNumber;
+}
+
+size_t Packet::SequenceLength()
+{
+    size_t sequenceLength;
+    memcpy(&sequenceLength, m_Data + 2 * sizeof(int), sizeof(int));
+    return sequenceLength;
+}
+
 void Packet::resizeData()
 {
     resizeData(m_MaxPacketSize * 2);

src/Engine/Network/TCPServer.cpp

@@ -48,6 +48,7 @@ void TCPServer::Send(Packet & packet, PlayerDefinition & playerDefinition)
 {
     packet.UpdateSize();
     try {
+        // Crashed once TCPSocket was NULL
         int bytesSent = playerDefinition.TCPSocket->send(
             boost::asio::buffer(packet.Data(), packet.Size()),
             0);

src/Engine/Network/UDPClient.cpp

@@ -39,7 +39,7 @@ int UDPClient::readBuffer()
         return 0;
     }
     boost::system::error_code error;
-    // Read size of packet
+    // Peek size of packet
      m_Socket->receive(boost
         ::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
          boost::asio::ip::udp::socket::message_peek, error);
@@ -47,7 +47,7 @@ int UDPClient::readBuffer()
     memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
     if (sizeOfPacket > m_Socket->available()) {
         LOG_WARNING("UDPClient::readBuffer(): We haven't got the whole packet yet.");
-        //return 0;
+        // return;
     }
     // if the buffer is to small increase the size of it
     if (sizeOfPacket > m_BufferSize) {
@@ -55,9 +55,7 @@ int UDPClient::readBuffer()
         m_ReadBuffer = new char[sizeOfPacket];
         m_BufferSize = sizeOfPacket;
     }
-
+    // Read the message
-    size_t availableData = m_Socket->available();
-    // Read the rest of the message
     size_t bytesReceived = m_Socket->receive_from(boost
         ::asio::buffer((void*)(m_ReadBuffer),
             sizeOfPacket),
@@ -65,8 +63,6 @@ int UDPClient::readBuffer()
     if (error) {
         //LOG_ERROR("receive: %s", error.message().c_str());
     }
-    if (sizeOfPacket > 1000000)
-        LOG_WARNING("The packets received are bigger than 1MB");
 
     return bytesReceived;
 }

src/Engine/Network/UDPServer.cpp

@@ -17,11 +17,34 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
 {
     packet.UpdateSize();
     try {
-        int bytesSent = m_Socket->send_to(
+        // Remove header from packet.
-            boost::asio::buffer(packet.Data(), packet.Size()),
+        packet.ReadData(packet.HeaderSize());
-            playerDefinition.Endpoint,
+        int bytesSent = 0;
-            0);
+        int sequenceNumber = 1;
-        LOG_INFO("Size of packet is %i", bytesSent);
+        int totalMessages = std::ceil(packet.Size() / MAXPACKETSIZE);
+        int packetDataSent = 0;
+        int packetDataSize = packet.Size() - packet.HeaderSize();
+        while (packetDataSize > packetDataSent) {
+           
+            Packet splitPacket(packet.GetMessageType(), playerDefinition.PacketID);
+            splitPacket.ChangeSequenceNumber(sequenceNumber, totalMessages);
+            int amountToSend = packetDataSize - packetDataSent;
+            if (amountToSend > MAXPACKETSIZE) {
+                amountToSend = MAXPACKETSIZE;
+            }
+            splitPacket.WriteData(packet.ReadData(amountToSend), amountToSend);
+            splitPacket.UpdateSize();
+            // Remove header size from bytes sent soo that we only
+            // count data in the packet
+
+            bytesSent += m_Socket->send_to(
+                boost::asio::buffer(splitPacket.Data() + bytesSent, splitPacket.Size()),
+                playerDefinition.Endpoint,
+                0);
+            packetDataSent = bytesSent - splitPacket.HeaderSize();
+            ++sequenceNumber;
+            int sizeasdasd = splitPacket.ReadPrimitive<int>();
+        }
     } catch (const boost::system::system_error& e) {
         LOG_INFO(e.what());
         // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
@@ -33,13 +56,13 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
 void UDPServer::Send(Packet & packet)
 {
     packet.UpdateSize();
-     size_t bytesSent = m_Socket->send_to(
+    size_t bytesSent = m_Socket->send_to(
         boost::asio::buffer(
             packet.Data(),
             packet.Size()),
         m_ReceiverEndpoint,
         0);
-     LOG_INFO("Size of packet is %i", bytesSent);
+    LOG_INFO("Size of packet is %i", bytesSent);
 }
 
 // Broadcasting respond specific logic
@@ -64,7 +87,7 @@ void UDPServer::Broadcast(Packet & packet, int port)
         boost::asio::buffer(
             packet.Data(),
             packet.Size()),
-        boost::asio::ip::udp::endpoint(boost::asio::ip::address_v4().broadcast(),port),
+        boost::asio::ip::udp::endpoint(boost::asio::ip::address_v4().broadcast(), port),
         0);
     m_Socket->set_option(boost::asio::socket_base::broadcast(false));
 }
@@ -91,7 +114,7 @@ int UDPServer::readBuffer()
     int addasdasd = m_Socket->available();
     boost::system::error_code error;
     // Read size of packet
-     m_Socket->receive_from(boost
+    m_Socket->receive_from(boost
         ::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
         m_ReceiverEndpoint, boost::asio::ip::udp::socket::message_peek, error);
     unsigned int sizeOfPacket = 0;
@@ -114,13 +137,13 @@ int UDPServer::readBuffer()
         ::asio::buffer((void*)(m_ReadBuffer),
             sizeOfPacket),
         m_ReceiverEndpoint, 0, error);
-        if (error) {
+    if (error) {
-            //LOG_ERROR("receive: %s", error.message().c_str());
+        //LOG_ERROR("receive: %s", error.message().c_str());
-        }
+    }
-        if (sizeOfPacket > 1000000)
+    if (sizeOfPacket > 1000000)
-            LOG_WARNING("The packets received are bigger than 1MB");
+        LOG_WARNING("The packets received are bigger than 1MB");
 
-        return bytesReceived;
+    return bytesReceived;
 }
 
 void UDPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)