private void SendPacket(Client Target, OutgoingUDPPacket Packet)
{
for (ushort i = 0; i < Packet.SliceBuffers.Length; ++i)
{
SendInternal(Target, Packet.SliceBuffers[i]);
}
}
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);
}
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 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);
}
protected override void HandleIncomingBuffer(Client Client, BufferStream Buffer)
{
byte control = Buffer.ReadByte();
double time = Time.CurrentEpochTime;
Client.Statistics.SetLastTouchTime(time);
UDPClient client = (UDPClient)Client;
if (control == Constants.Control.BUFFER)
{
if (!client.IsConnected)
{
return;
}
BufferStream buffer = Packet.CreateIncomingBufferStream(Buffer.Buffer);
ProcessReceivedBuffer(Client, buffer);
}
else if (control == Constants.Control.HANDSHAKE)
{
client.SetIsConnected(true);
uint mtu = Buffer.ReadUInt32();
client.SetMTU(mtu);
lock (clients)
clients.Add(client);
BufferStream buffer = Packet.CreateHandshakeBackBufferStream(client.Statistics.PacketCountRate);
SendInternal(Client, buffer);
RaiseOnClientConnected(client);
}
else if (control == Constants.Control.PING)
{
if (!client.IsConnected)
{
return;
}
double sendTime = Buffer.ReadFloat64();
Client.Statistics.SetLatency((uint)((time - sendTime) * 1000));
BufferStream pingBuffer = OutgoingUDPPacket.CreatePingBufferStream(client.OutgoingReliablePacketHolder, client.IncomingReliablePacketHolder, client.OutgoingNonReliablePacketHolder, client.IncomingNonReliablePacketHolder);
SendInternal(Client, pingBuffer);
ulong lastAckID = Buffer.ReadUInt64();
uint ackMask = Buffer.ReadUInt32();
client.OutgoingReliablePacketHolder.SetLastAckID(lastAckID);
client.OutgoingReliablePacketHolder.SetAckMask(ackMask);
lastAckID = Buffer.ReadUInt64();
ackMask = Buffer.ReadUInt32();
client.OutgoingNonReliablePacketHolder.SetLastAckID(lastAckID);
client.OutgoingNonReliablePacketHolder.SetAckMask(ackMask);
}
}
protected override BufferStream GetPingPacket()
{
return(OutgoingUDPPacket.CreatePingBufferStream(outgoingReliablePacketHolder, incomingReliablePacketHolder, outgoingNonReliablePacketHolder, incomingNonReliablePacketHolder));
}
