BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

We can now send more data with UDP than previously, the splitting seems to work fine but receiving has some problems.

Browse Source
This commit is contained in:
Jocke
2016-03-09 18:26:33 +01:00
parent 3828616b60
commit 3209e36176
9 changed files with 161 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Network/Packet.h
+2 -1
View File
@@ -59,10 +59,11 @@ public:
void UpdateSize();
char* ReadData(int SizeOfData);
void ChangePacketID(unsigned int& packetID);
void ChangeSequenceNumber(int sequenceNumber, int sequenceLength);
void ChangeSequenceNumber(int sequenceNumber, int sequenceLength, int groupNumber);
size_t Size() { return m_Offset; };
char* Data() { return m_Data; };
MessageType GetMessageType();
size_t Group();
size_t DataReadSize() { return m_ReturnDataOffset; }
size_t MaxSize() { return m_MaxPacketSize; }
size_t HeaderSize() { return m_HeaderSize; }
include/Engine/Network/PlayerDefinition.h
+1
View File
@@ -14,6 +14,7 @@ struct PlayerDefinition {
unsigned short TCPPort;
// use for tcp connections
boost::shared_ptr<boost::asio::ip::tcp::socket> TCPSocket;
int PacketGroup = 1;
};
#endif
include/Engine/Network/UDPClient.h
+8 -2
View File
@@ -1,6 +1,7 @@
#ifndef UDPClient_h__
#define UDPClient_h__
#include <map>
#include <algorithm>
#include <boost/asio.hpp>
#include "Network/NetworkClient.h"
@@ -15,18 +16,23 @@ public:
void Connect(std::string playerName, std::string address, int port);
void Disconnect();
void Receive(Packet& packet);
void Send(Packet & packet);
void ReceivePackets();
void Send(Packet& packet);
void Broadcast(Packet& packet, int port);
bool IsSocketAvailable();
// Returns false if no packets are available
bool GetNextPacket(Packet& packet);
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;
int lastReceivedSnapshotGroup = 0;
int readBuffer();
PacketID m_SendPacketID = 0;
//map:(packetGroup, vector:(pair:(groupIndex, packetData)))
std::map<unsigned int, std::vector<std::pair<unsigned int, boost::shared_ptr<char>>>> packetSegmentMap;
std::map<unsigned int, std::vector<std::pair<int, boost::shared_ptr<char>>>> m_PacketSegmentMap;
bool hasReceivedPacket(int packetGroup, int groupIndex);
};
#endif
include/Engine/Network/UDPServer.h
+1 -1
View File
@@ -3,7 +3,7 @@
#include "NetworkServer.h"
#include <boost/asio/ip/udp.hpp>
#define MAXPACKETSIZE 32000
#define MAXPACKETSIZE 64000
class UDPServer : public NetworkServer
{
src/Engine/Network/Client.cpp
+8 -6
View File
@@ -50,13 +50,15 @@ void Client::Update()
{
m_EventBroker->Process<Client>();
while (m_Unreliable.IsSocketAvailable()) {
// Packet will get real data in receive
Packet packet(MessageType::Invalid);
m_Unreliable.Receive(packet);
if (packet.GetMessageType() == MessageType::Connect) {
parseUDPConnect(packet);
m_Unreliable.ReceivePackets();
}
// Packet will get real data in GetNextPacket()
Packet parsedPacket(MessageType::Invalid);
while (m_Unreliable.GetNextPacket(parsedPacket)) {
if (parsedPacket.GetMessageType() == MessageType::Connect) {
parseUDPConnect(parsedPacket);
} else {
parseMessageType(packet);
parseMessageType(parsedPacket);
}
}
src/Engine/Network/Packet.cpp
+19 -5
View File
@@ -3,16 +3,22 @@
Packet::Packet(MessageType type, unsigned int& packetID)
{
m_Data = new char[m_MaxPacketSize];
Init(type, packetID, 1, 1 , -1);
Init(type, packetID, 1, 1, -1);
}
// Create message
Packet::Packet(char* data, const size_t sizeOfPacket)
{
// Create message header
// allocate memory for size of packet, sequenceNumber and totalPacketesInSequence
m_ReturnDataOffset = 0;
m_Offset = 0;
// Resize message
m_MaxPacketSize = sizeOfPacket;
// Copy data newly allocated memory
m_Data = new char[sizeOfPacket];
unsigned int dummy = 0;
Init(MessageType::Invalid, dummy, 0, 0, 0);
memcpy(m_Data, data, sizeOfPacket);
m_Offset = sizeOfPacket;
}
@@ -119,7 +125,7 @@ void Packet::ReconstructFromData(char * data, size_t sizeOfData)
void Packet::UpdateSize()
{
int whatisoffset = m_Offset;
memcpy(m_Data, &m_Offset, sizeof(int));
memcpy(m_Data + packetSizeOffset, &m_Offset, sizeof(int));
}
char * Packet::ReadData(int sizeOfData)
@@ -140,10 +146,11 @@ void Packet::ChangePacketID(unsigned int & packetID)
memcpy(m_Data + packetIDOffset, &packetID, sizeof(int));
}
void Packet::ChangeSequenceNumber(int groupIndex, int groupSize)
void Packet::ChangeSequenceNumber(int groupIndex, int groupSize, int groupNumber)
{
memcpy(&groupIndex, m_Data + groupIndexOffset, sizeof(int));
memcpy(&groupSize, m_Data + groupSizeOffset, sizeof(int));
memcpy(m_Data + groupIndexOffset, &groupIndex, sizeof(int));
memcpy(m_Data + groupSizeOffset, &groupSize, sizeof(int));
memcpy(m_Data + groupOffset, &groupNumber, sizeof(int));
}
MessageType Packet::GetMessageType()
@@ -153,6 +160,13 @@ MessageType Packet::GetMessageType()
return messagType;
}
size_t Packet::Group()
{
size_t groupNumber;
memcpy(&groupNumber, m_Data + groupOffset, sizeof(int));
return groupNumber;
}
size_t Packet::GroupIndex()
{
size_t groupIndex;
src/Engine/Network/Server.cpp
+1
View File
@@ -171,6 +171,7 @@ void Server::sendSnapshot()
Packet packet(MessageType::Snapshot);
addInputCommandsToPacket(packet);
addPlayersToPacket(packet, EntityID_Invalid);
//addChildrenToPacket(packet, EntityID_Invalid);
unreliableBroadcast(packet);
}
src/Engine/Network/UDPClient.cpp
+106 -23
View File
@@ -3,12 +3,10 @@
using namespace boost::asio::ip;
UDPClient::UDPClient()
{
}
{ }
UDPClient::~UDPClient()
{
}
{ }
void UDPClient::Connect(std::string playerName, std::string address, int port)
{
@@ -27,12 +25,18 @@ void UDPClient::Disconnect()
void UDPClient::Receive(Packet& packet)
{
int bytesRead = readBuffer();
if (bytesRead > 0) {
packet.ReconstructFromData(m_ReadBuffer, bytesRead);
}
// int bytesRead = readBuffer();
//if (bytesRead > 0) {
// packet.ReconstructFromData(m_ReadBuffer, bytesRead);
//}
}
void UDPClient::ReceivePackets()
{
readBuffer();
}
int UDPClient::readBuffer()
{
if (!m_Socket) {
@@ -40,36 +44,67 @@ int UDPClient::readBuffer()
}
boost::system::error_code error;
// Peek header
m_Socket->receive(boost
m_Socket->receive(boost
::asio::buffer((void*)m_ReadBuffer, 5 * sizeof(int)),
boost::asio::ip::udp::socket::message_peek, error);
boost::asio::ip::udp::socket::message_peek, error);
int sizeOfPacket = 0;
memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
int packetID = 0;
memcpy(&packetID, m_ReadBuffer + 4 * sizeof(int), sizeof(int));
if (sizeOfPacket == 0) {
return 0;
}
int packetGroup = 0;
memcpy(&packetGroup, m_ReadBuffer + sizeof(int), sizeof(int));
int packetGroupIndex = 0;
memcpy(&packetGroupIndex, m_ReadBuffer + 2 * sizeof(int), sizeof(int));
int packetGroupSize = 0;
memcpy(&packetGroupSize, m_ReadBuffer + 3 * sizeof(int), sizeof(int));
//LOG_INFO("Packet group: %i. Group index: %i. Group size: %i", packetGroup, packetGroupIndex, packetGroupSize);
//LOG_INFO("Packet size: %i.", sizeOfPacket);
if (sizeOfPacket > m_Socket->available()) {
LOG_WARNING("UDPClient::readBuffer(): We haven't got the whole packet yet.");
// return;
}
// if the buffer is to small increase the size of it
if (sizeOfPacket > m_BufferSize) {
delete[] m_ReadBuffer;
m_ReadBuffer = new char[sizeOfPacket];
m_BufferSize = sizeOfPacket;
}
boost::shared_ptr<char> packetData(new char[sizeOfPacket]);
// Read the message
size_t bytesReceived = m_Socket->receive_from(boost
::asio::buffer((void*)(m_ReadBuffer),
::asio::buffer((void*)(packetData.get()),
sizeOfPacket),
m_ReceiverEndpoint, 0, error);
if (error) {
//LOG_ERROR("receive: %s", error.message().c_str());
LOG_ERROR("receive: %s", error.message().c_str());
}
// Might want to do this earlier when i figure out a good way to
// remove data from network buffer.
if (hasReceivedPacket(packetGroup, packetGroupIndex)) {
return 0;
}
//std::map<unsigned int, std::vector<std::pair<unsigned int, boost::shared_ptr<char>>>> packetSegmentMap;
// If group exists
if (m_PacketSegmentMap.find(packetGroup) != m_PacketSegmentMap.end()) {
m_PacketSegmentMap.at(packetGroup).push_back(std::make_pair(packetGroupIndex, std::move(packetData)));
} else { // Create group and add element
m_PacketSegmentMap[packetGroup].push_back(std::make_pair(packetGroupIndex, std::move(packetData)));
}
// new char [sizeOfPacket] save in map with packetID as key
return bytesReceived;
}
bool UDPClient::hasReceivedPacket(int packetGroup, int groupIndex)
{
if (m_PacketSegmentMap.find(packetGroup) != m_PacketSegmentMap.end()) {
const std::vector<std::pair<int, boost::shared_ptr<char>>>& loopPacketGroup = m_PacketSegmentMap.at(packetGroup);
for (size_t i = 0; i < loopPacketGroup.size(); i++) {
if (loopPacketGroup.at(i).first == groupIndex) {
return true;
}
}
}
return false;
}
void UDPClient::Send(Packet& packet)
{
packet.UpdateSize();
@@ -77,7 +112,7 @@ void UDPClient::Send(Packet& packet)
packet.Data(),
packet.Size()),
m_ReceiverEndpoint, 0);
}
}
void UDPClient::Broadcast(Packet& packet, int port)
{
@@ -93,8 +128,56 @@ void UDPClient::Broadcast(Packet& packet, int port)
bool UDPClient::IsSocketAvailable()
{
if (!m_Socket) {
if (!m_Socket) {
return false;
}
return m_Socket->available();
}
}
bool UDPClient::GetNextPacket(Packet & packet)
{
// A duplicate packet should not be present in the vector!
// Soo we will assume that this is true and only look if size
// of vector is correct.
std::map<unsigned int, std::vector<std::pair<int, boost::shared_ptr<char>>>>::iterator it = m_PacketSegmentMap.begin();
while (it != m_PacketSegmentMap.end()) {
// pair(Group index, packetData)
std::vector<std::pair<int, boost::shared_ptr<char>>>& currentVector = it->second;
Packet headerInfoPacket(currentVector.at(0).second.get(), packet.HeaderSize());
int groupSize = headerInfoPacket.GroupSize();
//LOG_INFO("UDPClient::GetNextPacket: Packet group : %i.Group index : %i.Group size : %i. lastReceivedSnapshotGroup: %i. MessageType(Ples 4): %i", headerInfoPacket.Group(), headerInfoPacket.GroupIndex(), groupSize, lastReceivedSnapshotGroup, headerInfoPacket.GetMessageType());
//LOG_INFO("UDPClient::GetNextPacket: Packet group : %i.lastReceivedSnapshotGroup: %i. MessageType(Ples 4): %i", headerInfoPacket.Group(), lastReceivedSnapshotGroup, headerInfoPacket.GetMessageType());
int mapSize = m_PacketSegmentMap.size();
if (mapSize > 5) {
it = m_PacketSegmentMap.erase(it);
LOG_INFO("The map is increasing in size, size is %i", mapSize);
continue;
}
if (headerInfoPacket.GetMessageType() == MessageType::Snapshot && lastReceivedSnapshotGroup > headerInfoPacket.Group()) {
it = m_PacketSegmentMap.erase(it);
continue;
//LOG_INFO("Deleted old entry");
}
if (currentVector.size() == groupSize) {
std::sort(currentVector.begin(), currentVector.end());
// Add the first packet in vector
packet.ReconstructFromData(currentVector.at(0).second.get(), packet.HeaderSize());
// Add the rest of the packets.
int sizeOfData = 0;
for (size_t i = 0; i < currentVector.size(); i++) {
memcpy(&sizeOfData, currentVector.at(i).second.get(), sizeof(int));
packet.WriteData(currentVector.at(i).second.get() + packet.HeaderSize(), sizeOfData - packet.HeaderSize());
}
if (headerInfoPacket.GetMessageType() == MessageType::Snapshot) {
lastReceivedSnapshotGroup = packet.Group();
}
// No need to get next it as we are returning.
//LOG_INFO("Packet parsed");
m_PacketSegmentMap.erase(it);
return true;
} else {
++it;
}
}
return false;
}
src/Engine/Network/UDPServer.cpp
+15 -16
View File
@@ -12,22 +12,25 @@ UDPServer::UDPServer(int port)
UDPServer::~UDPServer()
{ }
// TODO: Fix correct groups
void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
{
packet.UpdateSize();
try {
//Debug
int debugTheSixeOfpacket = packet.Size();
//Debug end
// Remove header from packet.
packet.ReadData(packet.HeaderSize());
int bytesSent = 0;
int totalBytesSent = 0;
int sequenceNumber = 1;
int totalMessages = std::ceil(packet.Size() / MAXPACKETSIZE);
int totalMessages = 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);
splitPacket.ChangeSequenceNumber(sequenceNumber, totalMessages, playerDefinition.PacketGroup);
int amountToSend = packetDataSize - packetDataSent;
if (amountToSend > MAXPACKETSIZE) {
amountToSend = MAXPACKETSIZE;
@@ -36,26 +39,22 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
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()),
int bytesSent = 0;
bytesSent = m_Socket->send_to(
boost::asio::buffer(splitPacket.Data(), splitPacket.Size()),
playerDefinition.Endpoint,
0);
packetDataSent = bytesSent - splitPacket.HeaderSize();
packetDataSent += bytesSent - splitPacket.HeaderSize();
totalBytesSent += bytesSent;
// LOG_INFO("bytesSent size %i, groupIndex: %i. Number of packets: %i", bytesSent, sequenceNumber, totalMessages);
++sequenceNumber;
int packetsise = splitPacket.ReadPrimitive<int>();
int groopOffset = splitPacket.ReadPrimitive<int>();
int groopIndes = splitPacket.ReadPrimitive<int>();
int groopSiseOffset = splitPacket.ReadPrimitive<int>();
int mezzagetype = splitPacket.ReadPrimitive<int>();
int pakketIDOffset = splitPacket.ReadPrimitive<int>();
}
playerDefinition.PacketGroup++;
} catch (const boost::system::system_error& e) {
LOG_INFO(e.what());
// TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
playerDefinition.Endpoint = boost::asio::ip::udp::endpoint();
}
}
// Send back to endpoint of received packet
void UDPServer::Send(Packet & packet)