Fixed multiply connections

include/Engine/Network/Packet.h

@@ -60,7 +60,9 @@ public:
     void UpdateSize();
     char* ReadData(int SizeOfData);
     void ChangePacketID(unsigned int& packetID);
-    void ChangeSequenceNumber(int sequenceNumber, int sequenceLength, int groupNumber);
+    void ChangeGroupIndex(int groupIndex);
+    void ChangeGroupSize(int groupSize);
+    void ChangeGroup(int group);
     size_t Size() { return m_Offset; };
     char* Data() { return m_Data; };
     MessageType GetMessageType();

include/Engine/Network/UDPServer.h

@@ -14,6 +14,7 @@ public:
     void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers);
     void Receive(Packet & packet, PlayerDefinition & playerDefinition);
     void Send(Packet & packet, PlayerDefinition & playerDefinition);
+    void SendToConnectedPlayers(Packet & packet, std::map<PlayerID, PlayerDefinition>& playersTosendTo);
     void Send(Packet & packet); 
     void Send(Packet & packet, boost::asio::ip::udp::endpoint endpoint);
     void Broadcast(Packet & packet, int port);

src/Engine/Network/Packet.cpp

@@ -146,11 +146,19 @@ void Packet::ChangePacketID(unsigned int & packetID)
     memcpy(m_Data + packetIDOffset, &packetID, sizeof(int));
 }
 
-void Packet::ChangeSequenceNumber(int groupIndex, int groupSize, int groupNumber)
+void Packet::ChangeGroupIndex(int groupIndex)
 {
     memcpy(m_Data + groupIndexOffset, &groupIndex, sizeof(int));
+}
+
+void Packet::ChangeGroupSize(int groupSize)
+{ 
     memcpy(m_Data + groupSizeOffset, &groupSize, sizeof(int));
-    memcpy(m_Data + groupOffset, &groupNumber, sizeof(int));
+}
+
+void Packet::ChangeGroup(int group)
+{ 
+    memcpy(m_Data + groupOffset, &group, sizeof(int));
 }
 
 MessageType Packet::GetMessageType()

src/Engine/Network/Server.cpp

@@ -164,9 +164,7 @@ void Server::reliableBroadcast(Packet& packet)
 
 void Server::unreliableBroadcast(Packet& packet)
 {
-    for (auto& kv : m_ConnectedPlayers) {
-        m_Unreliable.Send(packet, kv.second);
-    }
+    m_Unreliable.SendToConnectedPlayers(packet, m_ConnectedPlayers);
 }
 
 // Send snapshot fields

src/Engine/Network/UDPClient.cpp

@@ -1,4 +1,5 @@
 #include "Network/UDPClient.h"
+#include "boost/asio/basic_datagram_socket.hpp"
 
 using namespace boost::asio::ip;
 
@@ -15,9 +16,9 @@ bool UDPClient::Connect(std::string playerName, std::string address, int port)
     }
     m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address().from_string(address), port);
     m_Socket = boost::shared_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService));
+    m_Socket->open(boost::asio::ip::udp::v4());
     boost::asio::socket_base::receive_buffer_size option(819200);
     m_Socket->set_option(option);
-    m_Socket->open(boost::asio::ip::udp::v4());
     return true;
 }
 

src/Engine/Network/UDPServer.cpp

@@ -23,14 +23,16 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
         // Remove header from packet.
         packet.ReadData(packet.HeaderSize());
         int totalBytesSent = 0;
-        int sequenceNumber = 1;
-        int totalMessages = std::ceil((float)packet.Size() / MAXPACKETSIZE);
+        int groupIndex = 1;
+        int groupSize = std::ceil((float)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, playerDefinition.PacketGroup);
+            splitPacket.ChangeGroupIndex(groupIndex);
+            splitPacket.ChangeGroupSize(groupSize);
+            splitPacket.ChangeGroup(playerDefinition.PacketGroup);
             int amountToSend = packetDataSize - packetDataSent;
             if (amountToSend > MAXPACKETSIZE) {
                 amountToSend = MAXPACKETSIZE;
@@ -47,7 +49,7 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
             packetDataSent += bytesSent - splitPacket.HeaderSize();
             totalBytesSent += bytesSent;
             //LOG_INFO("bytesSent size %i, groupIndex: %i. Number of packets: %i", bytesSent, sequenceNumber, totalMessages);
-            ++sequenceNumber;
+            ++groupIndex;
         }
         playerDefinition.PacketGroup++;
     } catch (const boost::system::system_error& e) {
@@ -56,6 +58,60 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
         playerDefinition.Endpoint = boost::asio::ip::udp::endpoint();
     }
 }
+
+void UDPServer::SendToConnectedPlayers(Packet& packet, std::map<PlayerID, PlayerDefinition>& playersTosendTo)
+{
+    // Work in progress
+    packet.UpdateSize();
+
+    //Debug
+    int debugTheSixeOfpacket = packet.Size();
+    //Debug end
+    // Remove header from packet.
+    packet.ReadData(packet.HeaderSize());
+    int totalBytesSent = 0;
+    int groupIndex = 1;
+    int groupSize = std::ceil((float)packet.Size() / MAXPACKETSIZE);
+    int packetDataSent = 0;
+    int packetDataSize = packet.Size() - packet.HeaderSize();
+
+    while (packetDataSize > packetDataSent) {
+        Packet splitPacket(packet.GetMessageType());
+        splitPacket.ChangeGroupIndex(groupIndex);
+        splitPacket.ChangeGroupSize(groupSize);
+        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
+        int bytesSent = 0;
+        for (auto& kv : playersTosendTo) {
+            try {
+                splitPacket.ChangeGroup(kv.second.PacketGroup);
+                bytesSent = m_Socket->send_to(
+                    boost::asio::buffer(splitPacket.Data(), splitPacket.Size()),
+                    kv.second.Endpoint,
+                    0);
+            } catch (const boost::system::system_error& e) {
+                LOG_INFO(e.what());
+                // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
+                kv.second.Endpoint = boost::asio::ip::udp::endpoint();
+            }
+        }
+            packetDataSent += splitPacket.Size() - splitPacket.HeaderSize();
+            totalBytesSent += splitPacket.Size();
+
+            //LOG_INFO("bytesSent size %i, groupIndex: %i. Number of packets: %i", bytesSent, sequenceNumber, totalMessages);
+            ++groupIndex;
+    }
+    for (auto& kv : playersTosendTo) {
+        kv.second.PacketGroup++;
+    }
+}
+
 // Send back to endpoint of received packet
 void UDPServer::Send(Packet & packet)
 {