internal void Update(int deltaTime)
{
Interlocked.Add(ref _timeSinceLastPacket, deltaTime);
switch (_connectionState)
{
case ConnectionState.Connected:
if (_timeSinceLastPacket > NetManager.DisconnectTimeout)
{
NetDebug.Write(
"[UPDATE] Disconnect by timeout: {0} > {1}",
_timeSinceLastPacket,
NetManager.DisconnectTimeout);
NetManager.DisconnectPeerForce(this, DisconnectReason.Timeout, 0, null);
return;
}
break;
case ConnectionState.ShutdownRequested:
if (_timeSinceLastPacket > NetManager.DisconnectTimeout)
{
_connectionState = ConnectionState.Disconnected;
}
else
{
_shutdownTimer += deltaTime;
if (_shutdownTimer >= ShutdownDelay)
{
_shutdownTimer = 0;
NetManager.SendRaw(_shutdownPacket, EndPoint);
}
}
return;
case ConnectionState.Outgoing:
_connectTimer += deltaTime;
if (_connectTimer > NetManager.ReconnectDelay)
{
_connectTimer = 0;
_connectAttempts++;
if (_connectAttempts > NetManager.MaxConnectAttempts)
{
NetManager.DisconnectPeerForce(this, DisconnectReason.ConnectionFailed, 0, null);
return;
}
//else send connect again
NetManager.SendRaw(_connectRequestPacket, EndPoint);
}
return;
case ConnectionState.Disconnected:
return;
}
//Send ping
_pingSendTimer += deltaTime;
if (_pingSendTimer >= NetManager.PingInterval)
{
NetDebug.Write("[PP] Send ping...");
//reset timer
_pingSendTimer = 0;
//send ping
_pingPacket.Sequence++;
//ping timeout
if (_pingTimer.IsRunning)
{
UpdateRoundTripTime((int)_pingTimer.ElapsedMilliseconds);
}
_pingTimer.Reset();
_pingTimer.Start();
NetManager.SendRaw(_pingPacket, EndPoint);
}
//RTT - round trip time
_rttResetTimer += deltaTime;
if (_rttResetTimer >= NetManager.PingInterval * 3)
{
_rttResetTimer = 0;
_rtt = _avgRtt;
_rttCount = 1;
}
UpdateMtuLogic(deltaTime);
//Pending send
BaseChannel currentChannel = _headChannel;
while (currentChannel != null)
{
currentChannel.SendNextPackets();
currentChannel = currentChannel.Next;
}
lock (_unreliableChannel)
{
while (_unreliableChannel.Count > 0)
{
NetPacket packet = _unreliableChannel.Dequeue();
SendUserData(packet);
NetManager.NetPacketPool.Recycle(packet);
}
}
SendMerged();
}
private void SendInternal(
byte[] data,
int start,
int length,
byte channelNumber,
DeliveryMethod deliveryMethod,
object userData)
{
if (_connectionState != ConnectionState.Connected || channelNumber >= _channels.Length)
{
return;
}
//Select channel
PacketProperty property;
BaseChannel channel = null;
if (deliveryMethod == DeliveryMethod.Unreliable)
{
property = PacketProperty.Unreliable;
}
else
{
property = PacketProperty.Channeled;
channel = CreateChannel((byte)(channelNumber * 4 + (byte)deliveryMethod));
}
//Prepare
NetDebug.Write("[RS]Packet: " + property);
//Check fragmentation
int headerSize = NetPacket.GetHeaderSize(property);
//Save mtu for multithread
int mtu = _mtu;
if (length + headerSize > mtu)
{
//if cannot be fragmented
if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != DeliveryMethod.ReliableUnordered)
{
throw new TooBigPacketException("Unreliable packet size exceeded maximum of " + (mtu - headerSize) + " bytes");
}
int packetFullSize = mtu - headerSize;
int packetDataSize = packetFullSize - NetConstants.FragmentHeaderSize;
int totalPackets = length / packetDataSize + (length % packetDataSize == 0 ? 0 : 1);
NetDebug.Write("FragmentSend:\n" +
" MTU: {0}\n" +
" headerSize: {1}\n" +
" packetFullSize: {2}\n" +
" packetDataSize: {3}\n" +
" totalPackets: {4}",
mtu, headerSize, packetFullSize, packetDataSize, totalPackets);
if (totalPackets > ushort.MaxValue)
{
throw new TooBigPacketException("Data was split in " + totalPackets + " fragments, which exceeds " + ushort.MaxValue);
}
ushort currentFramentId;
lock (_sendLock)
{
currentFramentId = _fragmentId;
_fragmentId++;
}
for (ushort partIdx = 0; partIdx < totalPackets; partIdx++)
{
int sendLength = length > packetDataSize ? packetDataSize : length;
NetPacket p = _packetPool.GetPacket(headerSize + sendLength + NetConstants.FragmentHeaderSize);
p.Property = property;
p.UserData = userData;
p.FragmentId = currentFramentId;
p.FragmentPart = partIdx;
p.FragmentsTotal = (ushort)totalPackets;
p.MarkFragmented();
Buffer.BlockCopy(data, partIdx * packetDataSize, p.RawData, NetConstants.FragmentedHeaderTotalSize, sendLength);
channel.AddToQueue(p);
length -= sendLength;
}
return;
}
//Else just send
NetPacket packet = _packetPool.GetPacket(headerSize + length);
packet.Property = property;
Buffer.BlockCopy(data, start, packet.RawData, headerSize, length);
packet.UserData = userData;
if (channel == null) //unreliable
{
lock (_unreliableChannel)
_unreliableChannel.Enqueue(packet);
}
else
{
channel.AddToQueue(packet);
}
}
//Process incoming packet
internal void ProcessPacket(NetPacket packet)
{
//not initialized
if (_connectionState == ConnectionState.Incoming)
{
_packetPool.Recycle(packet);
return;
}
if (packet.ConnectionNumber != _connectNum && packet.Property != PacketProperty.ShutdownOk) //without connectionNum
{
NetDebug.Write(NetLogLevel.Trace, "[RR]Old packet");
_packetPool.Recycle(packet);
return;
}
_timeSinceLastPacket = 0;
NetDebug.Write("[RR]PacketProperty: {0}", packet.Property);
switch (packet.Property)
{
case PacketProperty.Merged:
int pos = NetConstants.HeaderSize;
while (pos < packet.Size)
{
ushort size = BitConverter.ToUInt16(packet.RawData, pos);
pos += 2;
NetPacket mergedPacket = _packetPool.GetPacket(size, false);
if (!mergedPacket.FromBytes(packet.RawData, pos, size))
{
_packetPool.Recycle(packet);
break;
}
pos += size;
ProcessPacket(mergedPacket);
}
break;
//If we get ping, send pong
case PacketProperty.Ping:
if (NetUtils.RelativeSequenceNumber(packet.Sequence, _pongPacket.Sequence) > 0)
{
NetDebug.Write("[PP]Ping receive, send pong");
FastBitConverter.GetBytes(_pongPacket.RawData, 3, DateTime.UtcNow.Ticks);
_pongPacket.Sequence = packet.Sequence;
_netManager.SendRaw(_pongPacket, _remoteEndPoint);
}
_packetPool.Recycle(packet);
break;
//If we get pong, calculate ping time and rtt
case PacketProperty.Pong:
if (packet.Sequence == _pingPacket.Sequence)
{
_pingTimer.Stop();
int elapsedMs = (int)_pingTimer.ElapsedMilliseconds;
_remoteDelta = BitConverter.ToInt64(packet.RawData, 3) + (elapsedMs * TimeSpan.TicksPerMillisecond) / 2 - DateTime.UtcNow.Ticks;
UpdateRoundTripTime(elapsedMs);
_netManager.ConnectionLatencyUpdated(this, elapsedMs / 2);
NetDebug.Write("[PP]Ping: {0} - {1} - {2}", packet.Sequence, elapsedMs, _remoteDelta);
}
_packetPool.Recycle(packet);
break;
case PacketProperty.Ack:
if (packet.ChannelId > _channelsTotalCount)
{
_packetPool.Recycle(packet);
break;
}
BaseChannel channel = _channels[packet.ChannelId];
if (channel != null)
{
channel.ProcessPacket(packet);
}
break;
case PacketProperty.Channeled:
if (packet.ChannelId > _channelsTotalCount)
{
_packetPool.Recycle(packet);
break;
}
channel = _channels[packet.ChannelId] ?? CreateChannel(packet.ChannelId);
channel.ProcessPacket(packet);
break;
//Simple packet without acks
case PacketProperty.Unreliable:
AddIncomingPacket(packet);
return;
case PacketProperty.MtuCheck:
case PacketProperty.MtuOk:
ProcessMtuPacket(packet);
break;
case PacketProperty.ShutdownOk:
if (_connectionState == ConnectionState.ShutdownRequested)
{
_connectionState = ConnectionState.Disconnected;
}
_packetPool.Recycle(packet);
break;
default:
NetDebug.WriteError("Error! Unexpected packet type: " + packet.Property);
break;
}
}
