public void SendNextPackets()
{
NetPacket packet;
while (_outgoingPackets.Count > 0)
{
packet = _outgoingPackets.Dequeue();
_peer.SendRawData(packet);
packet.Recycle();
}
}
private void SendAcks(bool aboutToSendData, long currentTime)
{
// Try to send acks with data or after end of time
if (_mustSendAcksStartTimer > 0)
{
long elapsedTime = currentTime - _mustSendAcksStartTimer;
if (aboutToSendData == true || elapsedTime >= (long)(0.5f * (float)_peer.AvgRtt * 1.1f))
{
_mustSendAcksStartTimer = -1;
NetUtils.DebugWrite("[RR]SendAcks");
// Build outgoingAcks packet
if (_packetsToAcknowledge.Count > 0)
{
_packetsToAcknowledge.Sort();
int diff = RelativeSequenceDiff(_packetsToAcknowledge[_packetsToAcknowledge.Count - 1], _packetsToAcknowledge[0]);
_outgoingAcks.Size = NetConstants.SequencedHeaderSize + diff / 8 + 1;
_outgoingAcks.Property = _ordered ? PacketProperty.AckReliableOrdered : PacketProperty.AckReliable;
_outgoingAcks.Channel = _channel;
_outgoingAcks.Sequence = _packetsToAcknowledge[0];
// Set all to 0
Array.Clear(_outgoingAcks.RawData, 0, _outgoingAcks.Size - NetConstants.SequencedHeaderSize);
// Set bit to 1 foreach packet to ack
int ackIdx, ackByte, ackBit;
foreach (ushort seq in _packetsToAcknowledge)
{
ackIdx = RelativeSequenceDiff(seq, _outgoingAcks.Sequence);
ackByte = ackIdx / BitsInByte;
ackBit = ackIdx % BitsInByte;
_outgoingAcks.RawData[ackByte] |= (byte)(1 << ackBit);
}
//Monitor.Enter(_outgoingAcks);
_peer.SendRawData(_outgoingAcks);
//Monitor.Exit(_outgoingAcks);
_packetsToAcknowledge.Clear();
}
}
}
}
public void SendNextPackets()
{
lock (_outgoingPackets)
{
foreach (NetPacket packet in _outgoingPackets)
{
_localSequence = (_localSequence + 1) % NetConstants.MaxSequence;
packet.Sequence = (ushort)_localSequence;
_peer.SendRawData(packet);
packet.Recycle();
}
_outgoingPackets.Clear();
}
}
public void SendNextPackets()
{
lock (_outgoingPackets)
{
while (_outgoingPackets.Count > 0)
{
NetPacket packet = _outgoingPackets.Dequeue();
_localSequence = (_localSequence + 1) % NetConstants.MaxSequence;
packet.Sequence = (ushort)_localSequence;
_peer.SendRawData(packet);
_peer.Recycle(packet);
}
}
}
private void SendConnectAccept(NetPeer peer, ulong id)
{
//Reset connection timer
peer.StartConnectionTimer();
//Make initial packet
var connectPacket = NetPacket.CreateRawPacket(PacketProperty.ConnectAccept, 8);
//Add data
FastBitConverter.GetBytes(connectPacket, 1, id);
//Send raw
peer.SendRawData(connectPacket);
}
internal bool SendNextPacket()
{
NetPacket packet;
lock (_outgoingPackets) {
if (_outgoingPackets.Count == 0)
{
return(false);
}
packet = _outgoingPackets.Dequeue();
}
_peer.SendRawData(packet);
_peer.Recycle(packet);
return(true);
}
public bool SendNextPackets()
{
NetPacket packet;
lock (_outgoingPackets)
{
while (_outgoingPackets.Count > 0)
{
packet = _outgoingPackets.Dequeue();
_peer.SendRawData(packet);
_peer.Recycle(packet);
}
}
return(true);
}
public bool SendNextPacket()
{
NetPacket packet;
lock (_outgoingPackets)
{
if (_outgoingPackets.Count == 0)
{
return(false);
}
packet = _outgoingPackets.Dequeue();
}
_localSequence = (_localSequence + 1) % NetConstants.MaxSequence;
packet.Sequence = (ushort)_localSequence;
_peer.SendRawData(packet);
_peer.Recycle(packet);
return(true);
}
public bool SendNextPacket()
{
if (_outgoingPackets.Count == 0)
{
return(false);
}
_localSequence++;
NetPacket packet;
lock (_outgoingPackets)
{
packet = _outgoingPackets.Dequeue();
}
packet.Sequence = _localSequence;
_peer.SendRawData(packet.RawData);
_peer.Recycle(packet);
return(true);
}
public void SendNextPackets()
{
//check sending acks
if (_mustSendAcks)
{
_mustSendAcks = false;
NetUtils.DebugWrite("[RR]SendAcks");
Monitor.Enter(_outgoingAcks);
_peer.SendRawData(_outgoingAcks);
Monitor.Exit(_outgoingAcks);
}
long currentTime = DateTime.UtcNow.Ticks;
Monitor.Enter(_pendingPackets);
//get packets from queue
Monitor.Enter(_outgoingPackets);
while (_outgoingPackets.Count > 0)
{
int relate = NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart);
if (relate < _windowSize)
{
PendingPacket pendingPacket = _pendingPackets[_localSeqence % _windowSize];
pendingPacket.Packet = _outgoingPackets.Dequeue();
pendingPacket.Packet.Sequence = (ushort)_localSeqence;
pendingPacket.Next = _headPendingPacket;
_headPendingPacket = pendingPacket;
_localSeqence = (_localSeqence + 1) % NetConstants.MaxSequence;
}
else //Queue filled
{
break;
}
}
Monitor.Exit(_outgoingPackets);
//if no pending packets return
if (_headPendingPacket == null)
{
Monitor.Exit(_pendingPackets);
return;
}
//send
double resendDelay = _peer.ResendDelay;
PendingPacket currentPacket = _headPendingPacket;
do
{
if (currentPacket.Sended) //check send time
{
double packetHoldTime = currentTime - currentPacket.TimeStamp;
if (packetHoldTime < resendDelay * TimeSpan.TicksPerMillisecond)
{
continue;
}
NetUtils.DebugWrite("[RC]Resend: {0} > {1}", (int)packetHoldTime, resendDelay);
currentPacket.Resends++;
}
currentPacket.TimeStamp = currentTime;
currentPacket.Sended = true;
if (!_peer.SendRawData(currentPacket.Packet))
{
break;
}
} while ((currentPacket = currentPacket.Next) != null);
Monitor.Exit(_pendingPackets);
}
