public static void ProcessReliablePackets(OutgoingUDPPacketsHolder Holder, Action <OutgoingUDPPacket> SendPacket)
{
ulong lastAckID = Holder.LastAckID;
if (lastAckID == 0)
{
return;
}
ushort bitCount = Constants.UDP.ACK_MASK_SIZE * 8;
ushort count = (ushort)Math.Min(Holder.LastAckID - 1, bitCount);
for (short i = (short)count; i >= 0; --i)
{
ulong id = (ulong)((long)lastAckID - i);
bool acked = (BitwiseHelper.IsEnabled(Holder.AckMask, (ushort)(bitCount - i)) || id == lastAckID);
if (acked)
{
Holder.PacketsMap.Remove(id);
continue;
}
OutgoingUDPPacket packet = Holder.PacketsMap[id];
SendPacket(packet);
}
}
private void ProcessOutgoingNonReliablePackets(UDPClient Target)
{
OutgoingUDPPacketsHolder.ProcessNonReliablePackets(Target.OutgoingNonReliablePacketHolder, (Packet) =>
{
SendPacket(Target, Packet);
});
}
public UDPClient(IPEndPoint EndPoint)
{
endPoint = EndPoint;
IncomingReliablePacketHolder = new IncomingUDPPacketsHolder();
IncomingNonReliablePacketHolder = new IncomingUDPPacketsHolder();
OutgoingReliablePacketHolder = new OutgoingUDPPacketsHolder();
OutgoingNonReliablePacketHolder = new OutgoingUDPPacketsHolder();
}
public virtual void Send(byte[] Buffer, uint Index, uint Length, bool Reliable = true)
{
OutgoingUDPPacketsHolder outgoingHolder = (Reliable ? outgoingReliablePacketHolder : outgoingNonReliablePacketHolder);
IncomingUDPPacketsHolder incomingHolder = (Reliable ? incomingReliablePacketHolder : incomingNonReliablePacketHolder);
OutgoingUDPPacket packet = OutgoingUDPPacket.CreateOutgoingBufferStream(outgoingHolder, incomingHolder, Buffer, Index, Length, MTU, Reliable);
SendPacket(packet);
}
protected override void ProcessReceivedBuffer(Client Sender, BufferStream Buffer)
{
ulong lastAckID = Buffer.ReadUInt64();
uint ackMask = Buffer.ReadUInt32();
bool isReliable = Buffer.ReadBool();
ulong packetID = Buffer.ReadUInt64();
ushort sliceCount = Buffer.ReadUInt16();
ushort sliceIndex = Buffer.ReadUInt16();
BufferStream buffer = new BufferStream(Buffer.Buffer, Constants.UDP.PACKET_HEADER_SIZE, Buffer.Size - Constants.UDP.PACKET_HEADER_SIZE);
UDPClient client = (UDPClient)Sender;
IncomingUDPPacketsHolder incomingHolder = (isReliable ? client.IncomingReliablePacketHolder : client.IncomingNonReliablePacketHolder);
IncomingUDPPacket packet = incomingHolder.GetPacket(packetID);
if (packet == null)
{
packet = new IncomingUDPPacket(packetID, sliceCount);
incomingHolder.AddPacket(packet);
}
packet.SetSliceBuffer(sliceIndex, buffer);
if (packet.IsCompleted)
{
if (incomingHolder.LastID < packet.ID)
{
incomingHolder.SetLastID(packet.ID);
}
if (isReliable)
{
ProcessIncomingReliablePackets(client);
}
else
{
ProcessIncomingNonReliablePacket(client, packet);
}
}
OutgoingUDPPacketsHolder outgoingHolder = (isReliable ? client.OutgoingReliablePacketHolder : client.OutgoingNonReliablePacketHolder);
outgoingHolder.SetLastAckID(lastAckID);
outgoingHolder.SetAckMask(ackMask);
if (isReliable)
{
ProcessOutgoingReliablePackets(client);
}
else
{
ProcessOutgoingNonReliablePackets(client);
}
}
public UDPClientSocket() : base(Protocols.UDP)
{
incomingReliablePacketHolder = new IncomingUDPPacketsHolder();
incomingNonReliablePacketHolder = new IncomingUDPPacketsHolder();
outgoingReliablePacketHolder = new OutgoingUDPPacketsHolder();
outgoingNonReliablePacketHolder = new OutgoingUDPPacketsHolder();
FindOptimumMTU = true;
MTU = Constants.UDP.MAX_MTU;
}
public virtual void Send(Client Target, byte[] Buffer, uint Index, uint Length, bool Reliable = true)
{
UDPClient client = (UDPClient)Target;
OutgoingUDPPacketsHolder outgoingHolder = (Reliable ? client.OutgoingReliablePacketHolder : client.OutgoingNonReliablePacketHolder);
IncomingUDPPacketsHolder incomingHolder = (Reliable ? client.IncomingReliablePacketHolder : client.IncomingNonReliablePacketHolder);
OutgoingUDPPacket packet = OutgoingUDPPacket.CreateOutgoingBufferStream(outgoingHolder, incomingHolder, Buffer, Index, Length, client.MTU, Reliable);
SendPacket(Target, packet);
}
public static BufferStream CreatePingBufferStream(OutgoingUDPPacketsHolder ReliableOutgoingHolder, IncomingUDPPacketsHolder ReliableIncomingHolder, OutgoingUDPPacketsHolder NonReliableOutgoingHolder, IncomingUDPPacketsHolder NonReliableIncomingHolder)
{
BufferStream buffer = Packet.CreatePingBufferStream((Constants.UDP.LAST_ACK_ID_SIZE + Constants.UDP.ACK_MASK_SIZE) * 2);
uint ackMask = IncomingUDPPacketsHolder.GetAckMask(ReliableIncomingHolder, ReliableOutgoingHolder.AckMask);
buffer.WriteUInt64(ReliableIncomingHolder.LastID);
buffer.WriteUInt32(ackMask);
ackMask = IncomingUDPPacketsHolder.GetAckMask(NonReliableIncomingHolder, NonReliableOutgoingHolder.AckMask);
buffer.WriteUInt64(NonReliableIncomingHolder.LastID);
buffer.WriteUInt32(ackMask);
return(buffer);
}
public static OutgoingUDPPacket CreateOutgoingBufferStream(OutgoingUDPPacketsHolder OutgoingHolder, IncomingUDPPacketsHolder IncomingHolder, byte[] Buffer, uint Index, uint Length, uint MTU, bool IsReliable)
{
if (Constants.UDP.PACKET_HEADER_SIZE >= MTU)
{
throw new Exception("PACKET_HEADER_SIZE [" + Constants.UDP.PACKET_HEADER_SIZE + "] is greater than or equal to MTU [" + MTU + "]");
}
OutgoingHolder.IncreaseLastID();
ulong id = OutgoingHolder.LastID;
uint mtu = MTU - Constants.UDP.PACKET_HEADER_SIZE;
ushort sliceCount = (ushort)Math.Ceiling(Length / (float)mtu);
OutgoingUDPPacket packet = new OutgoingUDPPacket(id, sliceCount);
uint ackMask = IncomingUDPPacketsHolder.GetAckMask(IncomingHolder, OutgoingHolder.AckMask);
for (ushort i = 0; i < sliceCount; ++i)
{
uint index = Index + (i * mtu);
uint length = (uint)Math.Min(mtu, Length - (i * mtu));
BufferStream buffer = Packet.CreateOutgoingBufferStream(Constants.UDP.PACKET_HEADER_SIZE + length);
buffer.WriteUInt64(IncomingHolder.LastID);
buffer.WriteUInt32(ackMask);
buffer.WriteBool(IsReliable);
buffer.WriteUInt64(id);
buffer.WriteUInt16(sliceCount);
buffer.WriteUInt16(i);
buffer.WriteBytes(Buffer, index, length);
packet.SetSliceBuffer(i, buffer);
}
OutgoingHolder.AddPacket(packet);
return(packet);
}
public static void ProcessNonReliablePackets(OutgoingUDPPacketsHolder Holder, Action <OutgoingUDPPacket> SendPacket)
{
ProcessReliablePackets(Holder, SendPacket);
}
private void ProcessOutgoingNonReliablePackets()
{
OutgoingUDPPacketsHolder.ProcessNonReliablePackets(outgoingNonReliablePacketHolder, SendPacket);
}
