scripts
This commit is contained in:
niko
@@ -0,0 +1,1755 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Text;
|
||||
using ExitGames.Client.Photon.EncryptorManaged;
|
||||
|
||||
namespace ExitGames.Client.Photon
|
||||
{
|
||||
// Token: 0x02000017 RID: 23
|
||||
internal class EnetPeer : PeerBase
|
||||
{
|
||||
// Token: 0x1700005C RID: 92
|
||||
// (get) Token: 0x0600014A RID: 330 RVA: 0x0000A930 File Offset: 0x00008B30
|
||||
internal override int QueuedIncomingCommandsCount
|
||||
{
|
||||
get
|
||||
{
|
||||
int num = 0;
|
||||
EnetChannel[] array = this.channelArray;
|
||||
lock (array)
|
||||
{
|
||||
for (int i = 0; i < this.channelArray.Length; i++)
|
||||
{
|
||||
EnetChannel enetChannel = this.channelArray[i];
|
||||
num += enetChannel.incomingReliableCommandsList.Count;
|
||||
num += enetChannel.incomingUnreliableCommandsList.Count;
|
||||
}
|
||||
}
|
||||
return num;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700005D RID: 93
|
||||
// (get) Token: 0x0600014B RID: 331 RVA: 0x0000A9B4 File Offset: 0x00008BB4
|
||||
internal override int QueuedOutgoingCommandsCount
|
||||
{
|
||||
get
|
||||
{
|
||||
int num = 0;
|
||||
EnetChannel[] array = this.channelArray;
|
||||
lock (array)
|
||||
{
|
||||
for (int i = 0; i < this.channelArray.Length; i++)
|
||||
{
|
||||
EnetChannel enetChannel = this.channelArray[i];
|
||||
num += enetChannel.outgoingReliableCommandsList.Count;
|
||||
num += enetChannel.outgoingUnreliableCommandsList.Count;
|
||||
}
|
||||
}
|
||||
return num;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700005E RID: 94
|
||||
// (get) Token: 0x0600014C RID: 332 RVA: 0x0000AA38 File Offset: 0x00008C38
|
||||
private Encryptor encryptor
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.ppeer.encryptor;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700005F RID: 95
|
||||
// (get) Token: 0x0600014D RID: 333 RVA: 0x0000AA58 File Offset: 0x00008C58
|
||||
private Decryptor decryptor
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.ppeer.decryptor;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600014E RID: 334 RVA: 0x0000AA78 File Offset: 0x00008C78
|
||||
internal EnetPeer()
|
||||
{
|
||||
PeerBase.peerCount += 1;
|
||||
base.InitOnce();
|
||||
this.TrafficPackageHeaderSize = 12;
|
||||
}
|
||||
|
||||
// Token: 0x0600014F RID: 335 RVA: 0x0000AAE4 File Offset: 0x00008CE4
|
||||
internal override void InitPeerBase()
|
||||
{
|
||||
base.InitPeerBase();
|
||||
bool flag = this.ppeer.PayloadEncryptionSecret != null && this.usedProtocol == ConnectionProtocol.Udp;
|
||||
if (flag)
|
||||
{
|
||||
this.InitEncryption(this.ppeer.PayloadEncryptionSecret);
|
||||
}
|
||||
bool flag2 = this.encryptor != null && this.decryptor != null;
|
||||
if (flag2)
|
||||
{
|
||||
this.isEncryptionAvailable = true;
|
||||
}
|
||||
this.peerID = (this.ppeer.EnableServerTracing ? -2 : -1);
|
||||
this.challenge = SupportClass.ThreadSafeRandom.Next();
|
||||
bool flag3 = this.udpBuffer == null || this.udpBuffer.Length != base.mtu;
|
||||
if (flag3)
|
||||
{
|
||||
this.udpBuffer = new byte[base.mtu];
|
||||
}
|
||||
this.reliableCommandsSent = 0;
|
||||
this.reliableCommandsRepeated = 0;
|
||||
EnetChannel[] array = this.channelArray;
|
||||
lock (array)
|
||||
{
|
||||
EnetChannel[] array2 = this.channelArray;
|
||||
bool flag4 = array2.Length != (int)(base.ChannelCount + 1);
|
||||
if (flag4)
|
||||
{
|
||||
array2 = new EnetChannel[(int)(base.ChannelCount + 1)];
|
||||
}
|
||||
for (byte b = 0; b < base.ChannelCount; b += 1)
|
||||
{
|
||||
array2[(int)b] = new EnetChannel(b, this.commandBufferSize);
|
||||
}
|
||||
array2[(int)base.ChannelCount] = new EnetChannel(byte.MaxValue, this.commandBufferSize);
|
||||
this.channelArray = array2;
|
||||
}
|
||||
List<NCommand> list = this.sentReliableCommands;
|
||||
lock (list)
|
||||
{
|
||||
this.sentReliableCommands = new List<NCommand>(this.commandBufferSize);
|
||||
}
|
||||
this.outgoingAcknowledgementsPool = new StreamBuffer(0);
|
||||
base.CommandLogInit();
|
||||
}
|
||||
|
||||
// Token: 0x06000150 RID: 336 RVA: 0x0000ACAC File Offset: 0x00008EAC
|
||||
internal override bool Connect(string ipport, string appID, object custom = null)
|
||||
{
|
||||
bool flag = this.peerConnectionState > PeerBase.ConnectionStateValue.Disconnected;
|
||||
bool flag2;
|
||||
if (flag)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.WARNING, "Connect() can't be called if peer is not Disconnected. Not connecting. peerConnectionState: " + this.peerConnectionState);
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag3 = base.debugOut >= DebugLevel.ALL;
|
||||
if (flag3)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ALL, "Connect()");
|
||||
}
|
||||
base.ServerAddress = ipport;
|
||||
this.InitPeerBase();
|
||||
bool flag4 = base.SocketImplementation != null;
|
||||
if (flag4)
|
||||
{
|
||||
this.rt = (IPhotonSocket)Activator.CreateInstance(base.SocketImplementation, new object[] { this });
|
||||
}
|
||||
else
|
||||
{
|
||||
this.rt = new SocketUdp(this);
|
||||
}
|
||||
bool flag5 = this.rt == null;
|
||||
if (flag5)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ERROR, "Connect() failed, because SocketImplementation or socket was null. Set PhotonPeer.SocketImplementation before Connect().");
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag6 = this.rt.Connect();
|
||||
if (flag6)
|
||||
{
|
||||
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled)
|
||||
{
|
||||
base.TrafficStatsOutgoing.ControlCommandBytes += 44;
|
||||
base.TrafficStatsOutgoing.ControlCommandCount++;
|
||||
}
|
||||
this.peerConnectionState = PeerBase.ConnectionStateValue.Connecting;
|
||||
flag2 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return flag2;
|
||||
}
|
||||
|
||||
// Token: 0x06000151 RID: 337 RVA: 0x0000ADE2 File Offset: 0x00008FE2
|
||||
public override void OnConnect()
|
||||
{
|
||||
this.QueueOutgoingReliableCommand(new NCommand(this, 2, null, byte.MaxValue));
|
||||
}
|
||||
|
||||
// Token: 0x06000152 RID: 338 RVA: 0x0000ADFC File Offset: 0x00008FFC
|
||||
internal override void Disconnect()
|
||||
{
|
||||
bool flag = this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected || this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnecting;
|
||||
if (!flag)
|
||||
{
|
||||
bool flag2 = this.sentReliableCommands != null;
|
||||
if (flag2)
|
||||
{
|
||||
List<NCommand> list = this.sentReliableCommands;
|
||||
lock (list)
|
||||
{
|
||||
this.sentReliableCommands.Clear();
|
||||
}
|
||||
}
|
||||
EnetChannel[] array = this.channelArray;
|
||||
lock (array)
|
||||
{
|
||||
foreach (EnetChannel enetChannel in this.channelArray)
|
||||
{
|
||||
enetChannel.clearAll();
|
||||
}
|
||||
}
|
||||
bool isSimulationEnabled = base.NetworkSimulationSettings.IsSimulationEnabled;
|
||||
base.NetworkSimulationSettings.IsSimulationEnabled = false;
|
||||
NCommand ncommand = new NCommand(this, 4, null, byte.MaxValue);
|
||||
this.QueueOutgoingReliableCommand(ncommand);
|
||||
this.SendOutgoingCommands();
|
||||
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled)
|
||||
{
|
||||
base.TrafficStatsOutgoing.CountControlCommand(ncommand.Size);
|
||||
}
|
||||
base.NetworkSimulationSettings.IsSimulationEnabled = isSimulationEnabled;
|
||||
this.rt.Disconnect();
|
||||
this.peerConnectionState = PeerBase.ConnectionStateValue.Disconnected;
|
||||
base.EnqueueStatusCallback(StatusCode.Disconnect);
|
||||
this.datagramEncryptedConnection = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000153 RID: 339 RVA: 0x0000AF50 File Offset: 0x00009150
|
||||
internal override void StopConnection()
|
||||
{
|
||||
bool flag = this.rt != null;
|
||||
if (flag)
|
||||
{
|
||||
this.rt.Disconnect();
|
||||
}
|
||||
this.peerConnectionState = PeerBase.ConnectionStateValue.Disconnected;
|
||||
bool flag2 = base.Listener != null;
|
||||
if (flag2)
|
||||
{
|
||||
base.Listener.OnStatusChanged(StatusCode.Disconnect);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000154 RID: 340 RVA: 0x0000AFA0 File Offset: 0x000091A0
|
||||
internal override void FetchServerTimestamp()
|
||||
{
|
||||
bool flag = this.peerConnectionState != PeerBase.ConnectionStateValue.Connected || !this.ApplicationIsInitialized;
|
||||
if (flag)
|
||||
{
|
||||
bool flag2 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag2)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.INFO, "FetchServerTimestamp() was skipped, as the client is not connected. Current ConnectionState: " + this.peerConnectionState);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
this.CreateAndEnqueueCommand(12, new byte[0], byte.MaxValue);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000155 RID: 341 RVA: 0x0000B010 File Offset: 0x00009210
|
||||
internal override bool DispatchIncomingCommands()
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
Queue<PeerBase.MyAction> actionQueue = this.ActionQueue;
|
||||
PeerBase.MyAction myAction;
|
||||
lock (actionQueue)
|
||||
{
|
||||
bool flag = this.ActionQueue.Count <= 0;
|
||||
if (flag)
|
||||
{
|
||||
break;
|
||||
}
|
||||
myAction = this.ActionQueue.Dequeue();
|
||||
}
|
||||
myAction();
|
||||
}
|
||||
NCommand ncommand = null;
|
||||
EnetChannel[] array = this.channelArray;
|
||||
lock (array)
|
||||
{
|
||||
for (int i = 0; i < this.channelArray.Length; i++)
|
||||
{
|
||||
EnetChannel enetChannel = this.channelArray[i];
|
||||
bool flag2 = enetChannel.incomingUnreliableCommandsList.Count > 0;
|
||||
if (flag2)
|
||||
{
|
||||
int num = int.MaxValue;
|
||||
foreach (int num2 in enetChannel.incomingUnreliableCommandsList.Keys)
|
||||
{
|
||||
NCommand ncommand2 = enetChannel.incomingUnreliableCommandsList[num2];
|
||||
bool flag3 = num2 < enetChannel.incomingUnreliableSequenceNumber || ncommand2.reliableSequenceNumber < enetChannel.incomingReliableSequenceNumber;
|
||||
if (flag3)
|
||||
{
|
||||
this.commandsToRemove.Enqueue(num2);
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag4 = base.limitOfUnreliableCommands > 0 && enetChannel.incomingUnreliableCommandsList.Count > base.limitOfUnreliableCommands;
|
||||
if (flag4)
|
||||
{
|
||||
this.commandsToRemove.Enqueue(num2);
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag5 = num2 < num;
|
||||
if (flag5)
|
||||
{
|
||||
bool flag6 = ncommand2.reliableSequenceNumber > enetChannel.incomingReliableSequenceNumber;
|
||||
if (!flag6)
|
||||
{
|
||||
num = num2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
while (this.commandsToRemove.Count > 0)
|
||||
{
|
||||
enetChannel.incomingUnreliableCommandsList.Remove(this.commandsToRemove.Dequeue());
|
||||
}
|
||||
bool flag7 = num < int.MaxValue;
|
||||
if (flag7)
|
||||
{
|
||||
ncommand = enetChannel.incomingUnreliableCommandsList[num];
|
||||
}
|
||||
bool flag8 = ncommand != null;
|
||||
if (flag8)
|
||||
{
|
||||
enetChannel.incomingUnreliableCommandsList.Remove(ncommand.unreliableSequenceNumber);
|
||||
enetChannel.incomingUnreliableSequenceNumber = ncommand.unreliableSequenceNumber;
|
||||
break;
|
||||
}
|
||||
}
|
||||
bool flag9 = ncommand == null && enetChannel.incomingReliableCommandsList.Count > 0;
|
||||
if (flag9)
|
||||
{
|
||||
enetChannel.incomingReliableCommandsList.TryGetValue(enetChannel.incomingReliableSequenceNumber + 1, out ncommand);
|
||||
bool flag10 = ncommand == null;
|
||||
if (!flag10)
|
||||
{
|
||||
bool flag11 = ncommand.commandType != 8;
|
||||
if (flag11)
|
||||
{
|
||||
enetChannel.incomingReliableSequenceNumber = ncommand.reliableSequenceNumber;
|
||||
enetChannel.incomingReliableCommandsList.Remove(ncommand.reliableSequenceNumber);
|
||||
break;
|
||||
}
|
||||
bool flag12 = ncommand.fragmentsRemaining > 0;
|
||||
if (flag12)
|
||||
{
|
||||
ncommand = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
byte[] array2 = new byte[ncommand.totalLength];
|
||||
for (int j = ncommand.startSequenceNumber; j < ncommand.startSequenceNumber + ncommand.fragmentCount; j++)
|
||||
{
|
||||
bool flag13 = enetChannel.ContainsReliableSequenceNumber(j);
|
||||
if (!flag13)
|
||||
{
|
||||
throw new Exception("command.fragmentsRemaining was 0, but not all fragments are found to be combined!");
|
||||
}
|
||||
NCommand ncommand3 = enetChannel.FetchReliableSequenceNumber(j);
|
||||
Buffer.BlockCopy(ncommand3.Payload, 0, array2, ncommand3.fragmentOffset, ncommand3.Payload.Length);
|
||||
enetChannel.incomingReliableCommandsList.Remove(ncommand3.reliableSequenceNumber);
|
||||
}
|
||||
bool flag14 = base.debugOut >= DebugLevel.ALL;
|
||||
if (flag14)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ALL, "assembled fragmented payload from " + ncommand.fragmentCount + " parts. Dispatching now.");
|
||||
}
|
||||
ncommand.Payload = array2;
|
||||
ncommand.Size = 12 * ncommand.fragmentCount + ncommand.totalLength;
|
||||
enetChannel.incomingReliableSequenceNumber = ncommand.reliableSequenceNumber + ncommand.fragmentCount - 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool flag15 = ncommand != null && ncommand.Payload != null;
|
||||
if (flag15)
|
||||
{
|
||||
this.ByteCountCurrentDispatch = ncommand.Size;
|
||||
this.CommandInCurrentDispatch = ncommand;
|
||||
bool flag16 = this.DeserializeMessageAndCallback(ncommand.Payload);
|
||||
if (flag16)
|
||||
{
|
||||
this.CommandInCurrentDispatch = null;
|
||||
return true;
|
||||
}
|
||||
this.CommandInCurrentDispatch = null;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Token: 0x06000156 RID: 342 RVA: 0x0000B488 File Offset: 0x00009688
|
||||
private int GetFragmentLength()
|
||||
{
|
||||
int num = base.mtu;
|
||||
bool flag = this.datagramEncryptedConnection;
|
||||
int num2;
|
||||
if (flag)
|
||||
{
|
||||
num = num - 7 - EnetPeer.HMAC_SIZE - EnetPeer.IV_SIZE;
|
||||
num = num / EnetPeer.BLOCK_SIZE * EnetPeer.BLOCK_SIZE;
|
||||
num = num - 5 - 36;
|
||||
num2 = num;
|
||||
}
|
||||
else
|
||||
{
|
||||
num2 = num - 12 - 36;
|
||||
}
|
||||
return num2;
|
||||
}
|
||||
|
||||
// Token: 0x06000157 RID: 343 RVA: 0x0000B4DC File Offset: 0x000096DC
|
||||
private int CalculateBufferLen()
|
||||
{
|
||||
int num = base.mtu;
|
||||
bool flag = this.datagramEncryptedConnection;
|
||||
int num2;
|
||||
if (flag)
|
||||
{
|
||||
num = num - 7 - EnetPeer.HMAC_SIZE - EnetPeer.IV_SIZE;
|
||||
num = num / EnetPeer.BLOCK_SIZE * EnetPeer.BLOCK_SIZE;
|
||||
num--;
|
||||
num2 = num;
|
||||
}
|
||||
else
|
||||
{
|
||||
num2 = num;
|
||||
}
|
||||
return num2;
|
||||
}
|
||||
|
||||
// Token: 0x06000158 RID: 344 RVA: 0x0000B528 File Offset: 0x00009728
|
||||
private int CalculateInitialOffset()
|
||||
{
|
||||
bool flag = this.datagramEncryptedConnection;
|
||||
int num;
|
||||
if (flag)
|
||||
{
|
||||
num = 5;
|
||||
}
|
||||
else
|
||||
{
|
||||
int num2 = 12;
|
||||
bool crcEnabled = base.crcEnabled;
|
||||
if (crcEnabled)
|
||||
{
|
||||
num2 += 4;
|
||||
}
|
||||
num = num2;
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x06000159 RID: 345 RVA: 0x0000B560 File Offset: 0x00009760
|
||||
internal override bool SendAcksOnly()
|
||||
{
|
||||
bool flag = this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected;
|
||||
bool flag2;
|
||||
if (flag)
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag3 = this.rt == null || !this.rt.Connected;
|
||||
if (flag3)
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
byte[] array = this.udpBuffer;
|
||||
lock (array)
|
||||
{
|
||||
int num = 0;
|
||||
this.udpBufferIndex = this.CalculateInitialOffset();
|
||||
this.udpBufferLength = this.CalculateBufferLen();
|
||||
this.udpCommandCount = 0;
|
||||
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
|
||||
StreamBuffer streamBuffer = this.outgoingAcknowledgementsPool;
|
||||
lock (streamBuffer)
|
||||
{
|
||||
num = this.SerializeAckToBuffer();
|
||||
this.timeLastSendAck = this.timeInt;
|
||||
}
|
||||
bool flag4 = this.timeInt > this.timeoutInt && this.sentReliableCommands.Count > 0;
|
||||
if (flag4)
|
||||
{
|
||||
List<NCommand> list = this.sentReliableCommands;
|
||||
lock (list)
|
||||
{
|
||||
foreach (NCommand ncommand in this.sentReliableCommands)
|
||||
{
|
||||
bool flag5 = ncommand != null && ncommand.roundTripTimeout != 0 && this.timeInt - ncommand.commandSentTime > ncommand.roundTripTimeout;
|
||||
if (flag5)
|
||||
{
|
||||
ncommand.commandSentCount = 1;
|
||||
ncommand.roundTripTimeout = 0;
|
||||
ncommand.timeoutTime = int.MaxValue;
|
||||
ncommand.commandSentTime = this.timeInt;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool flag6 = this.udpCommandCount <= 0;
|
||||
if (flag6)
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled)
|
||||
{
|
||||
TrafficStats trafficStatsOutgoing = base.TrafficStatsOutgoing;
|
||||
int totalPacketCount = trafficStatsOutgoing.TotalPacketCount;
|
||||
trafficStatsOutgoing.TotalPacketCount = totalPacketCount + 1;
|
||||
base.TrafficStatsOutgoing.TotalCommandsInPackets += (int)this.udpCommandCount;
|
||||
}
|
||||
this.SendData(this.udpBuffer, this.udpBufferIndex);
|
||||
flag2 = num > 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return flag2;
|
||||
}
|
||||
|
||||
// Token: 0x0600015A RID: 346 RVA: 0x0000B7D0 File Offset: 0x000099D0
|
||||
internal override bool SendOutgoingCommands()
|
||||
{
|
||||
bool flag = this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected;
|
||||
bool flag2;
|
||||
if (flag)
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag3 = !this.rt.Connected;
|
||||
if (flag3)
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
byte[] array = this.udpBuffer;
|
||||
lock (array)
|
||||
{
|
||||
int num = 0;
|
||||
this.udpBufferIndex = this.CalculateInitialOffset();
|
||||
this.udpBufferLength = this.CalculateBufferLen();
|
||||
this.udpCommandCount = 0;
|
||||
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
|
||||
this.timeLastSendOutgoing = this.timeInt;
|
||||
StreamBuffer streamBuffer = this.outgoingAcknowledgementsPool;
|
||||
lock (streamBuffer)
|
||||
{
|
||||
bool flag4 = this.outgoingAcknowledgementsPool.Length > 0L;
|
||||
if (flag4)
|
||||
{
|
||||
num = this.SerializeAckToBuffer();
|
||||
this.timeLastSendAck = this.timeInt;
|
||||
}
|
||||
}
|
||||
bool flag5 = !base.IsSendingOnlyAcks && this.timeInt > this.timeoutInt && this.sentReliableCommands.Count > 0;
|
||||
if (flag5)
|
||||
{
|
||||
List<NCommand> list = this.sentReliableCommands;
|
||||
lock (list)
|
||||
{
|
||||
this.commandsToResend.Clear();
|
||||
foreach (NCommand ncommand in this.sentReliableCommands)
|
||||
{
|
||||
bool flag6 = ncommand != null && this.timeInt - ncommand.commandSentTime > ncommand.roundTripTimeout;
|
||||
if (flag6)
|
||||
{
|
||||
bool flag7 = (int)ncommand.commandSentCount > base.sentCountAllowance || this.timeInt > ncommand.timeoutTime;
|
||||
if (flag7)
|
||||
{
|
||||
bool flag8 = base.debugOut >= DebugLevel.WARNING;
|
||||
if (flag8)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.WARNING, string.Concat(new object[]
|
||||
{
|
||||
"Timeout-disconnect! Command: ",
|
||||
ncommand,
|
||||
" now: ",
|
||||
this.timeInt,
|
||||
" challenge: ",
|
||||
Convert.ToString(this.challenge, 16)
|
||||
}));
|
||||
}
|
||||
bool flag9 = this.CommandLog != null;
|
||||
if (flag9)
|
||||
{
|
||||
this.CommandLog.Enqueue(new CmdLogSentReliable(ncommand, this.timeInt, this.roundTripTime, this.roundTripTimeVariance, true));
|
||||
base.CommandLogResize();
|
||||
}
|
||||
this.peerConnectionState = PeerBase.ConnectionStateValue.Zombie;
|
||||
base.Listener.OnStatusChanged(StatusCode.TimeoutDisconnect);
|
||||
this.Disconnect();
|
||||
return false;
|
||||
}
|
||||
this.commandsToResend.Enqueue(ncommand);
|
||||
}
|
||||
}
|
||||
while (this.commandsToResend.Count > 0)
|
||||
{
|
||||
NCommand ncommand2 = this.commandsToResend.Dequeue();
|
||||
this.QueueOutgoingReliableCommand(ncommand2);
|
||||
this.sentReliableCommands.Remove(ncommand2);
|
||||
this.reliableCommandsRepeated++;
|
||||
bool flag10 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag10)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, string.Format("Resending: {0}. times out after: {1} sent: {3} now: {2} rtt/var: {4}/{5} last recv: {6}", new object[]
|
||||
{
|
||||
ncommand2,
|
||||
ncommand2.roundTripTimeout,
|
||||
this.timeInt,
|
||||
ncommand2.commandSentTime,
|
||||
this.roundTripTime,
|
||||
this.roundTripTimeVariance,
|
||||
SupportClass.GetTickCount() - this.timestampOfLastReceive
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool flag11 = !base.IsSendingOnlyAcks && this.peerConnectionState == PeerBase.ConnectionStateValue.Connected && base.timePingInterval > 0 && this.sentReliableCommands.Count == 0 && this.timeInt - this.timeLastAckReceive > base.timePingInterval && !this.AreReliableCommandsInTransit() && this.udpBufferIndex + 12 < this.udpBufferLength;
|
||||
if (flag11)
|
||||
{
|
||||
NCommand ncommand3 = new NCommand(this, 5, null, byte.MaxValue);
|
||||
this.QueueOutgoingReliableCommand(ncommand3);
|
||||
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled)
|
||||
{
|
||||
base.TrafficStatsOutgoing.CountControlCommand(ncommand3.Size);
|
||||
}
|
||||
}
|
||||
bool flag12 = !base.IsSendingOnlyAcks;
|
||||
if (flag12)
|
||||
{
|
||||
EnetChannel[] array2 = this.channelArray;
|
||||
lock (array2)
|
||||
{
|
||||
for (int i = 0; i < this.channelArray.Length; i++)
|
||||
{
|
||||
EnetChannel enetChannel = this.channelArray[i];
|
||||
num += this.SerializeToBuffer(enetChannel.outgoingReliableCommandsList);
|
||||
num += this.SerializeToBuffer(enetChannel.outgoingUnreliableCommandsList);
|
||||
}
|
||||
}
|
||||
}
|
||||
bool flag13 = this.udpCommandCount <= 0;
|
||||
if (flag13)
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled2)
|
||||
{
|
||||
TrafficStats trafficStatsOutgoing = base.TrafficStatsOutgoing;
|
||||
int totalPacketCount = trafficStatsOutgoing.TotalPacketCount;
|
||||
trafficStatsOutgoing.TotalPacketCount = totalPacketCount + 1;
|
||||
base.TrafficStatsOutgoing.TotalCommandsInPackets += (int)this.udpCommandCount;
|
||||
}
|
||||
this.SendData(this.udpBuffer, this.udpBufferIndex);
|
||||
flag2 = num > 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return flag2;
|
||||
}
|
||||
|
||||
// Token: 0x0600015B RID: 347 RVA: 0x0000BD58 File Offset: 0x00009F58
|
||||
private bool AreReliableCommandsInTransit()
|
||||
{
|
||||
EnetChannel[] array = this.channelArray;
|
||||
lock (array)
|
||||
{
|
||||
for (int i = 0; i < this.channelArray.Length; i++)
|
||||
{
|
||||
EnetChannel enetChannel = this.channelArray[i];
|
||||
bool flag = enetChannel.outgoingReliableCommandsList.Count > 0;
|
||||
if (flag)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Token: 0x0600015C RID: 348 RVA: 0x0000BDD4 File Offset: 0x00009FD4
|
||||
internal override bool EnqueueOperation(Dictionary<byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypt, PeerBase.EgMessageType messageType)
|
||||
{
|
||||
bool flag = this.peerConnectionState != PeerBase.ConnectionStateValue.Connected;
|
||||
bool flag3;
|
||||
if (flag)
|
||||
{
|
||||
bool flag2 = base.debugOut >= DebugLevel.ERROR;
|
||||
if (flag2)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat(new object[] { "Cannot send op: ", opCode, " Not connected. PeerState: ", this.peerConnectionState }));
|
||||
}
|
||||
base.Listener.OnStatusChanged(StatusCode.SendError);
|
||||
flag3 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag4 = channelId >= base.ChannelCount;
|
||||
if (flag4)
|
||||
{
|
||||
bool flag5 = base.debugOut >= DebugLevel.ERROR;
|
||||
if (flag5)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat(new object[] { "Cannot send op: Selected channel (", channelId, ")>= channelCount (", base.ChannelCount, ")." }));
|
||||
}
|
||||
base.Listener.OnStatusChanged(StatusCode.SendError);
|
||||
flag3 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
byte[] array = this.SerializeOperationToMessage(opCode, parameters, messageType, encrypt);
|
||||
flag3 = this.CreateAndEnqueueCommand(sendReliable ? 6 : 7, array, channelId);
|
||||
}
|
||||
}
|
||||
return flag3;
|
||||
}
|
||||
|
||||
// Token: 0x0600015D RID: 349 RVA: 0x0000BF04 File Offset: 0x0000A104
|
||||
private EnetChannel GetChannel(byte channelNumber)
|
||||
{
|
||||
return (channelNumber == byte.MaxValue) ? this.channelArray[this.channelArray.Length - 1] : this.channelArray[(int)channelNumber];
|
||||
}
|
||||
|
||||
// Token: 0x0600015E RID: 350 RVA: 0x0000BF3C File Offset: 0x0000A13C
|
||||
internal bool CreateAndEnqueueCommand(byte commandType, byte[] payload, byte channelNumber)
|
||||
{
|
||||
bool flag = payload == null;
|
||||
bool flag2;
|
||||
if (flag)
|
||||
{
|
||||
flag2 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
EnetChannel channel = this.GetChannel(channelNumber);
|
||||
this.ByteCountLastOperation = 0;
|
||||
int num = this.GetFragmentLength();
|
||||
bool flag3 = payload.Length > num;
|
||||
if (flag3)
|
||||
{
|
||||
int num2 = (payload.Length + num - 1) / num;
|
||||
int num3 = channel.outgoingReliableSequenceNumber + 1;
|
||||
int num4 = 0;
|
||||
for (int i = 0; i < payload.Length; i += num)
|
||||
{
|
||||
bool flag4 = payload.Length - i < num;
|
||||
if (flag4)
|
||||
{
|
||||
num = payload.Length - i;
|
||||
}
|
||||
byte[] array = new byte[num];
|
||||
Buffer.BlockCopy(payload, i, array, 0, num);
|
||||
NCommand ncommand = new NCommand(this, 8, array, channel.ChannelNumber);
|
||||
ncommand.fragmentNumber = num4;
|
||||
ncommand.startSequenceNumber = num3;
|
||||
ncommand.fragmentCount = num2;
|
||||
ncommand.totalLength = payload.Length;
|
||||
ncommand.fragmentOffset = i;
|
||||
this.QueueOutgoingReliableCommand(ncommand);
|
||||
this.ByteCountLastOperation += ncommand.Size;
|
||||
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled)
|
||||
{
|
||||
base.TrafficStatsOutgoing.CountFragmentOpCommand(ncommand.Size);
|
||||
base.TrafficStatsGameLevel.CountOperation(ncommand.Size);
|
||||
}
|
||||
num4++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
NCommand ncommand2 = new NCommand(this, commandType, payload, channel.ChannelNumber);
|
||||
bool flag5 = ncommand2.commandFlags == 1;
|
||||
if (flag5)
|
||||
{
|
||||
this.QueueOutgoingReliableCommand(ncommand2);
|
||||
this.ByteCountLastOperation = ncommand2.Size;
|
||||
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled2)
|
||||
{
|
||||
base.TrafficStatsOutgoing.CountReliableOpCommand(ncommand2.Size);
|
||||
base.TrafficStatsGameLevel.CountOperation(ncommand2.Size);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
this.QueueOutgoingUnreliableCommand(ncommand2);
|
||||
this.ByteCountLastOperation = ncommand2.Size;
|
||||
bool trafficStatsEnabled3 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled3)
|
||||
{
|
||||
base.TrafficStatsOutgoing.CountUnreliableOpCommand(ncommand2.Size);
|
||||
base.TrafficStatsGameLevel.CountOperation(ncommand2.Size);
|
||||
}
|
||||
}
|
||||
}
|
||||
flag2 = true;
|
||||
}
|
||||
return flag2;
|
||||
}
|
||||
|
||||
// Token: 0x0600015F RID: 351 RVA: 0x0000C144 File Offset: 0x0000A344
|
||||
internal override byte[] SerializeOperationToMessage(byte opCode, Dictionary<byte, object> parameters, PeerBase.EgMessageType messageType, bool encrypt)
|
||||
{
|
||||
encrypt = encrypt && !this.datagramEncryptedConnection;
|
||||
StreamBuffer serializeMemStream = this.SerializeMemStream;
|
||||
byte[] array2;
|
||||
lock (serializeMemStream)
|
||||
{
|
||||
this.SerializeMemStream.SetLength(0L);
|
||||
bool flag = !encrypt;
|
||||
if (flag)
|
||||
{
|
||||
this.SerializeMemStream.Write(EnetPeer.messageHeader, 0, EnetPeer.messageHeader.Length);
|
||||
}
|
||||
this.protocol.SerializeOperationRequest(this.SerializeMemStream, opCode, parameters, false);
|
||||
bool flag2 = encrypt;
|
||||
if (flag2)
|
||||
{
|
||||
byte[] array = this.CryptoProvider.Encrypt(this.SerializeMemStream.GetBuffer(), 0, (int)this.SerializeMemStream.Length);
|
||||
this.SerializeMemStream.SetLength(0L);
|
||||
this.SerializeMemStream.Write(EnetPeer.messageHeader, 0, EnetPeer.messageHeader.Length);
|
||||
this.SerializeMemStream.Write(array, 0, array.Length);
|
||||
}
|
||||
array2 = this.SerializeMemStream.ToArray();
|
||||
}
|
||||
bool flag3 = messageType != PeerBase.EgMessageType.Operation;
|
||||
if (flag3)
|
||||
{
|
||||
array2[EnetPeer.messageHeader.Length - 1] = (byte)messageType;
|
||||
}
|
||||
bool flag4 = encrypt;
|
||||
if (flag4)
|
||||
{
|
||||
array2[EnetPeer.messageHeader.Length - 1] = array2[EnetPeer.messageHeader.Length - 1] | 128;
|
||||
}
|
||||
return array2;
|
||||
}
|
||||
|
||||
// Token: 0x06000160 RID: 352 RVA: 0x0000C294 File Offset: 0x0000A494
|
||||
internal int SerializeAckToBuffer()
|
||||
{
|
||||
this.outgoingAcknowledgementsPool.Seek(0L, SeekOrigin.Begin);
|
||||
while (this.outgoingAcknowledgementsPool.Position + 20L <= this.outgoingAcknowledgementsPool.Length)
|
||||
{
|
||||
bool flag = this.udpBufferIndex + 20 > this.udpBufferLength;
|
||||
if (flag)
|
||||
{
|
||||
bool flag2 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag2)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
||||
{
|
||||
"UDP package is full. Commands in Package: ",
|
||||
this.udpCommandCount,
|
||||
". bytes left in queue: ",
|
||||
this.outgoingAcknowledgementsPool.Position
|
||||
}));
|
||||
}
|
||||
break;
|
||||
}
|
||||
int num;
|
||||
byte[] bufferAndAdvance = this.outgoingAcknowledgementsPool.GetBufferAndAdvance(20, out num);
|
||||
Buffer.BlockCopy(bufferAndAdvance, num, this.udpBuffer, this.udpBufferIndex, 20);
|
||||
this.udpBufferIndex += 20;
|
||||
this.udpCommandCount += 1;
|
||||
}
|
||||
this.outgoingAcknowledgementsPool.Compact();
|
||||
this.outgoingAcknowledgementsPool.Position = this.outgoingAcknowledgementsPool.Length;
|
||||
return (int)this.outgoingAcknowledgementsPool.Length / 20;
|
||||
}
|
||||
|
||||
// Token: 0x06000161 RID: 353 RVA: 0x0000C3D0 File Offset: 0x0000A5D0
|
||||
internal int SerializeToBuffer(Queue<NCommand> commandList)
|
||||
{
|
||||
while (commandList.Count > 0)
|
||||
{
|
||||
NCommand ncommand = commandList.Peek();
|
||||
bool flag = ncommand == null;
|
||||
if (flag)
|
||||
{
|
||||
commandList.Dequeue();
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag2 = this.udpBufferIndex + ncommand.Size > this.udpBufferLength;
|
||||
if (flag2)
|
||||
{
|
||||
bool flag3 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag3)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[] { "UDP package is full. Commands in Package: ", this.udpCommandCount, ". Commands left in queue: ", commandList.Count }));
|
||||
}
|
||||
break;
|
||||
}
|
||||
ncommand.SerializeHeader(this.udpBuffer, ref this.udpBufferIndex);
|
||||
bool flag4 = ncommand.SizeOfPayload > 0;
|
||||
if (flag4)
|
||||
{
|
||||
Buffer.BlockCopy(ncommand.Serialize(), 0, this.udpBuffer, this.udpBufferIndex, ncommand.SizeOfPayload);
|
||||
this.udpBufferIndex += ncommand.SizeOfPayload;
|
||||
}
|
||||
this.udpCommandCount += 1;
|
||||
bool flag5 = (ncommand.commandFlags & 1) > 0;
|
||||
if (flag5)
|
||||
{
|
||||
this.QueueSentCommand(ncommand);
|
||||
bool flag6 = this.CommandLog != null;
|
||||
if (flag6)
|
||||
{
|
||||
this.CommandLog.Enqueue(new CmdLogSentReliable(ncommand, this.timeInt, this.roundTripTime, this.roundTripTimeVariance, false));
|
||||
base.CommandLogResize();
|
||||
}
|
||||
}
|
||||
commandList.Dequeue();
|
||||
}
|
||||
}
|
||||
return commandList.Count;
|
||||
}
|
||||
|
||||
// Token: 0x06000162 RID: 354 RVA: 0x0000C558 File Offset: 0x0000A758
|
||||
internal void SendData(byte[] data, int length)
|
||||
{
|
||||
try
|
||||
{
|
||||
bool flag = this.datagramEncryptedConnection;
|
||||
if (flag)
|
||||
{
|
||||
this.SendDataEncrypted(data, length);
|
||||
}
|
||||
else
|
||||
{
|
||||
int num = 0;
|
||||
Protocol.Serialize(this.peerID, data, ref num);
|
||||
data[2] = (base.crcEnabled ? 204 : 0);
|
||||
data[3] = this.udpCommandCount;
|
||||
num = 4;
|
||||
Protocol.Serialize(this.timeInt, data, ref num);
|
||||
Protocol.Serialize(this.challenge, data, ref num);
|
||||
bool crcEnabled = base.crcEnabled;
|
||||
if (crcEnabled)
|
||||
{
|
||||
Protocol.Serialize(0, data, ref num);
|
||||
uint num2 = SupportClass.CalculateCrc(data, length);
|
||||
num -= 4;
|
||||
Protocol.Serialize((int)num2, data, ref num);
|
||||
}
|
||||
this.bytesOut += (long)length;
|
||||
this.SendToSocket(data, length);
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
bool flag2 = base.debugOut >= DebugLevel.ERROR;
|
||||
if (flag2)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ERROR, ex.ToString());
|
||||
}
|
||||
SupportClass.WriteStackTrace(ex);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000163 RID: 355 RVA: 0x0000C65C File Offset: 0x0000A85C
|
||||
private void SendToSocket(byte[] data, int length)
|
||||
{
|
||||
bool isSimulationEnabled = base.NetworkSimulationSettings.IsSimulationEnabled;
|
||||
if (isSimulationEnabled)
|
||||
{
|
||||
byte[] array = new byte[length];
|
||||
Buffer.BlockCopy(data, 0, array, 0, length);
|
||||
base.SendNetworkSimulated(array);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.rt.Send(data, length);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000164 RID: 356 RVA: 0x0000C6A8 File Offset: 0x0000A8A8
|
||||
private void SendDataEncrypted(byte[] data, int length)
|
||||
{
|
||||
bool flag = this.bufferForEncryption == null || this.bufferForEncryption.Length != base.mtu;
|
||||
if (flag)
|
||||
{
|
||||
this.bufferForEncryption = new byte[base.mtu];
|
||||
}
|
||||
byte[] array = this.bufferForEncryption;
|
||||
int num = 0;
|
||||
Protocol.Serialize(this.peerID, array, ref num);
|
||||
array[2] = 1;
|
||||
num++;
|
||||
Protocol.Serialize(this.challenge, array, ref num);
|
||||
data[0] = this.udpCommandCount;
|
||||
int num2 = 1;
|
||||
Protocol.Serialize(this.timeInt, data, ref num2);
|
||||
this.encryptor.Encrypt(data, length, array, ref num);
|
||||
Buffer.BlockCopy(this.encryptor.FinishHMAC(array, 0, num), 0, array, num, EnetPeer.HMAC_SIZE);
|
||||
this.SendToSocket(array, num + EnetPeer.HMAC_SIZE);
|
||||
}
|
||||
|
||||
// Token: 0x06000165 RID: 357 RVA: 0x0000C770 File Offset: 0x0000A970
|
||||
internal void QueueSentCommand(NCommand command)
|
||||
{
|
||||
command.commandSentTime = this.timeInt;
|
||||
command.commandSentCount += 1;
|
||||
bool flag = command.roundTripTimeout == 0;
|
||||
if (flag)
|
||||
{
|
||||
command.roundTripTimeout = this.roundTripTime + 4 * this.roundTripTimeVariance;
|
||||
command.timeoutTime = this.timeInt + base.DisconnectTimeout;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag2 = command.commandSentCount <= base.QuickResendAttempts + 1;
|
||||
if (!flag2)
|
||||
{
|
||||
command.roundTripTimeout *= 2;
|
||||
}
|
||||
}
|
||||
List<NCommand> list = this.sentReliableCommands;
|
||||
lock (list)
|
||||
{
|
||||
bool flag3 = this.sentReliableCommands.Count == 0;
|
||||
if (flag3)
|
||||
{
|
||||
int num = command.commandSentTime + command.roundTripTimeout;
|
||||
bool flag4 = num < this.timeoutInt;
|
||||
if (flag4)
|
||||
{
|
||||
this.timeoutInt = num;
|
||||
}
|
||||
}
|
||||
this.reliableCommandsSent++;
|
||||
this.sentReliableCommands.Add(command);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000166 RID: 358 RVA: 0x0000C884 File Offset: 0x0000AA84
|
||||
internal void QueueOutgoingReliableCommand(NCommand command)
|
||||
{
|
||||
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
||||
EnetChannel enetChannel = channel;
|
||||
lock (enetChannel)
|
||||
{
|
||||
bool flag = command.reliableSequenceNumber == 0;
|
||||
if (flag)
|
||||
{
|
||||
EnetChannel enetChannel2 = channel;
|
||||
int num = enetChannel2.outgoingReliableSequenceNumber + 1;
|
||||
enetChannel2.outgoingReliableSequenceNumber = num;
|
||||
command.reliableSequenceNumber = num;
|
||||
}
|
||||
channel.outgoingReliableCommandsList.Enqueue(command);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000167 RID: 359 RVA: 0x0000C8F8 File Offset: 0x0000AAF8
|
||||
internal void QueueOutgoingUnreliableCommand(NCommand command)
|
||||
{
|
||||
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
||||
EnetChannel enetChannel = channel;
|
||||
lock (enetChannel)
|
||||
{
|
||||
command.reliableSequenceNumber = channel.outgoingReliableSequenceNumber;
|
||||
EnetChannel enetChannel2 = channel;
|
||||
int num = enetChannel2.outgoingUnreliableSequenceNumber + 1;
|
||||
enetChannel2.outgoingUnreliableSequenceNumber = num;
|
||||
command.unreliableSequenceNumber = num;
|
||||
channel.outgoingUnreliableCommandsList.Enqueue(command);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000168 RID: 360 RVA: 0x0000C968 File Offset: 0x0000AB68
|
||||
internal void QueueOutgoingAcknowledgement(NCommand readCommand, int sendTime)
|
||||
{
|
||||
StreamBuffer streamBuffer = this.outgoingAcknowledgementsPool;
|
||||
lock (streamBuffer)
|
||||
{
|
||||
int num;
|
||||
byte[] bufferAndAdvance = this.outgoingAcknowledgementsPool.GetBufferAndAdvance(20, out num);
|
||||
NCommand.CreateAck(bufferAndAdvance, num, readCommand, sendTime);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000169 RID: 361 RVA: 0x0000C9BC File Offset: 0x0000ABBC
|
||||
internal override void ReceiveIncomingCommands(byte[] inBuff, int dataLength)
|
||||
{
|
||||
this.timestampOfLastReceive = SupportClass.GetTickCount();
|
||||
try
|
||||
{
|
||||
int num = 0;
|
||||
short num2;
|
||||
Protocol.Deserialize(out num2, inBuff, ref num);
|
||||
byte b = inBuff[num++];
|
||||
bool flag = b == 1;
|
||||
int num3;
|
||||
byte b2;
|
||||
if (flag)
|
||||
{
|
||||
bool flag2 = this.decryptor == null;
|
||||
if (flag2)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.ERROR, "Got encrypted packet, but encryption is not set up. Packet ignored");
|
||||
return;
|
||||
}
|
||||
this.datagramEncryptedConnection = true;
|
||||
bool flag3 = !this.decryptor.CheckHMAC(inBuff, dataLength);
|
||||
if (flag3)
|
||||
{
|
||||
this.packetLossByCrc++;
|
||||
bool flag4 = this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnected && base.debugOut >= DebugLevel.INFO;
|
||||
if (flag4)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.INFO, "Ignored package due to wrong HMAC.");
|
||||
}
|
||||
return;
|
||||
}
|
||||
Protocol.Deserialize(out num3, inBuff, ref num);
|
||||
inBuff = this.decryptor.DecryptBufferWithIV(inBuff, num, dataLength - num - EnetPeer.HMAC_SIZE, out dataLength);
|
||||
dataLength = inBuff.Length;
|
||||
num = 0;
|
||||
b2 = inBuff[num++];
|
||||
Protocol.Deserialize(out this.serverSentTime, inBuff, ref num);
|
||||
this.bytesIn += (long)(12 + EnetPeer.IV_SIZE + EnetPeer.HMAC_SIZE + dataLength + (EnetPeer.BLOCK_SIZE - dataLength % EnetPeer.BLOCK_SIZE));
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag5 = this.datagramEncryptedConnection;
|
||||
if (flag5)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.WARNING, "Got not encrypted packet, but expected only encrypted. Packet ignored");
|
||||
return;
|
||||
}
|
||||
b2 = inBuff[num++];
|
||||
Protocol.Deserialize(out this.serverSentTime, inBuff, ref num);
|
||||
Protocol.Deserialize(out num3, inBuff, ref num);
|
||||
bool flag6 = b == 204;
|
||||
if (flag6)
|
||||
{
|
||||
int num4;
|
||||
Protocol.Deserialize(out num4, inBuff, ref num);
|
||||
this.bytesIn += 4L;
|
||||
num -= 4;
|
||||
Protocol.Serialize(0, inBuff, ref num);
|
||||
uint num5 = SupportClass.CalculateCrc(inBuff, dataLength);
|
||||
bool flag7 = num4 != (int)num5;
|
||||
if (flag7)
|
||||
{
|
||||
this.packetLossByCrc++;
|
||||
bool flag8 = this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnected && base.debugOut >= DebugLevel.INFO;
|
||||
if (flag8)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.INFO, string.Format("Ignored package due to wrong CRC. Incoming: {0:X} Local: {1:X}", (uint)num4, num5));
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
this.bytesIn += 12L;
|
||||
}
|
||||
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled)
|
||||
{
|
||||
TrafficStats trafficStatsIncoming = base.TrafficStatsIncoming;
|
||||
int totalPacketCount = trafficStatsIncoming.TotalPacketCount;
|
||||
trafficStatsIncoming.TotalPacketCount = totalPacketCount + 1;
|
||||
base.TrafficStatsIncoming.TotalCommandsInPackets += (int)b2;
|
||||
}
|
||||
bool flag9 = (int)b2 > this.commandBufferSize || b2 <= 0;
|
||||
if (flag9)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.ERROR, string.Concat(new object[] { "too many/few incoming commands in package: ", b2, " > ", this.commandBufferSize }));
|
||||
}
|
||||
bool flag10 = num3 != this.challenge;
|
||||
if (flag10)
|
||||
{
|
||||
this.packetLossByChallenge++;
|
||||
bool flag11 = this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnected && base.debugOut >= DebugLevel.ALL;
|
||||
if (flag11)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.ALL, string.Concat(new object[] { "Info: Ignoring received package due to wrong challenge. Challenge in-package!=local:", num3, "!=", this.challenge, " Commands in it: ", b2 }));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
|
||||
for (int i = 0; i < (int)b2; i++)
|
||||
{
|
||||
NCommand readCommand = new NCommand(this, inBuff, ref num);
|
||||
bool flag12 = readCommand.commandType != 1;
|
||||
if (flag12)
|
||||
{
|
||||
base.EnqueueActionForDispatch(delegate
|
||||
{
|
||||
this.ExecuteCommand(readCommand);
|
||||
});
|
||||
}
|
||||
else
|
||||
{
|
||||
this.ExecuteCommand(readCommand);
|
||||
}
|
||||
bool flag13 = (readCommand.commandFlags & 1) > 0;
|
||||
if (flag13)
|
||||
{
|
||||
bool flag14 = this.InReliableLog != null;
|
||||
if (flag14)
|
||||
{
|
||||
this.InReliableLog.Enqueue(new CmdLogReceivedReliable(readCommand, this.timeInt, this.roundTripTime, this.roundTripTimeVariance, this.timeInt - this.timeLastSendOutgoing, this.timeInt - this.timeLastSendAck));
|
||||
base.CommandLogResize();
|
||||
}
|
||||
this.QueueOutgoingAcknowledgement(readCommand, this.serverSentTime);
|
||||
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled2)
|
||||
{
|
||||
base.TrafficStatsIncoming.TimestampOfLastReliableCommand = SupportClass.GetTickCount();
|
||||
base.TrafficStatsOutgoing.CountControlCommand(20);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
bool flag15 = base.debugOut >= DebugLevel.ERROR;
|
||||
if (flag15)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.ERROR, string.Format("Exception while reading commands from incoming data: {0}", ex));
|
||||
}
|
||||
SupportClass.WriteStackTrace(ex);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600016A RID: 362 RVA: 0x0000CEA8 File Offset: 0x0000B0A8
|
||||
internal bool ExecuteCommand(NCommand command)
|
||||
{
|
||||
bool flag = true;
|
||||
switch (command.commandType)
|
||||
{
|
||||
case 1:
|
||||
{
|
||||
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled)
|
||||
{
|
||||
base.TrafficStatsIncoming.TimestampOfLastAck = SupportClass.GetTickCount();
|
||||
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
||||
}
|
||||
this.timeLastAckReceive = this.timeInt;
|
||||
this.lastRoundTripTime = this.timeInt - command.ackReceivedSentTime;
|
||||
NCommand ncommand = this.RemoveSentReliableCommand(command.ackReceivedReliableSequenceNumber, (int)command.commandChannelID);
|
||||
bool flag2 = this.CommandLog != null;
|
||||
if (flag2)
|
||||
{
|
||||
this.CommandLog.Enqueue(new CmdLogReceivedAck(command, this.timeInt, this.roundTripTime, this.roundTripTimeVariance));
|
||||
base.CommandLogResize();
|
||||
}
|
||||
bool flag3 = ncommand != null;
|
||||
if (flag3)
|
||||
{
|
||||
bool flag4 = ncommand.commandType == 12;
|
||||
if (flag4)
|
||||
{
|
||||
bool flag5 = this.lastRoundTripTime <= this.roundTripTime;
|
||||
if (flag5)
|
||||
{
|
||||
this.serverTimeOffset = this.serverSentTime + (this.lastRoundTripTime >> 1) - SupportClass.GetTickCount();
|
||||
this.serverTimeOffsetIsAvailable = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.FetchServerTimestamp();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
base.UpdateRoundTripTimeAndVariance(this.lastRoundTripTime);
|
||||
bool flag6 = ncommand.commandType == 4 && this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnecting;
|
||||
if (flag6)
|
||||
{
|
||||
bool flag7 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag7)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.INFO, "Received disconnect ACK by server");
|
||||
}
|
||||
base.EnqueueActionForDispatch(delegate
|
||||
{
|
||||
this.rt.Disconnect();
|
||||
});
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag8 = ncommand.commandType == 2;
|
||||
if (flag8)
|
||||
{
|
||||
this.roundTripTime = this.lastRoundTripTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
case 5:
|
||||
{
|
||||
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled2)
|
||||
{
|
||||
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
{
|
||||
bool trafficStatsEnabled3 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled3)
|
||||
{
|
||||
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
||||
}
|
||||
bool flag9 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connecting;
|
||||
if (flag9)
|
||||
{
|
||||
byte[] array = base.PrepareConnectData(base.ServerAddress, this.AppId, this.CustomInitData);
|
||||
this.CreateAndEnqueueCommand(6, array, 0);
|
||||
this.peerConnectionState = PeerBase.ConnectionStateValue.Connected;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 4:
|
||||
{
|
||||
bool trafficStatsEnabled4 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled4)
|
||||
{
|
||||
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
||||
}
|
||||
StatusCode statusCode = StatusCode.DisconnectByServer;
|
||||
bool flag10 = command.reservedByte == 1;
|
||||
if (flag10)
|
||||
{
|
||||
statusCode = StatusCode.DisconnectByServerLogic;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag11 = command.reservedByte == 3;
|
||||
if (flag11)
|
||||
{
|
||||
statusCode = StatusCode.DisconnectByServerUserLimit;
|
||||
}
|
||||
}
|
||||
bool flag12 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag12)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
||||
{
|
||||
"Server ",
|
||||
base.ServerAddress,
|
||||
" sent disconnect. PeerId: ",
|
||||
(ushort)this.peerID,
|
||||
" RTT/Variance:",
|
||||
this.roundTripTime,
|
||||
"/",
|
||||
this.roundTripTimeVariance,
|
||||
" reason byte: ",
|
||||
command.reservedByte
|
||||
}));
|
||||
}
|
||||
PeerBase.ConnectionStateValue peerConnectionState = this.peerConnectionState;
|
||||
this.peerConnectionState = PeerBase.ConnectionStateValue.Disconnecting;
|
||||
base.Listener.OnStatusChanged(statusCode);
|
||||
this.peerConnectionState = peerConnectionState;
|
||||
this.Disconnect();
|
||||
break;
|
||||
}
|
||||
case 6:
|
||||
{
|
||||
bool trafficStatsEnabled5 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled5)
|
||||
{
|
||||
base.TrafficStatsIncoming.CountReliableOpCommand(command.Size);
|
||||
}
|
||||
bool flag13 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected;
|
||||
if (flag13)
|
||||
{
|
||||
flag = this.QueueIncomingCommand(command);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 7:
|
||||
{
|
||||
bool trafficStatsEnabled6 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled6)
|
||||
{
|
||||
base.TrafficStatsIncoming.CountUnreliableOpCommand(command.Size);
|
||||
}
|
||||
bool flag14 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected;
|
||||
if (flag14)
|
||||
{
|
||||
flag = this.QueueIncomingCommand(command);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 8:
|
||||
{
|
||||
bool trafficStatsEnabled7 = base.TrafficStatsEnabled;
|
||||
if (trafficStatsEnabled7)
|
||||
{
|
||||
base.TrafficStatsIncoming.CountFragmentOpCommand(command.Size);
|
||||
}
|
||||
bool flag15 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected;
|
||||
if (flag15)
|
||||
{
|
||||
bool flag16 = command.fragmentNumber > command.fragmentCount || command.fragmentOffset >= command.totalLength || command.fragmentOffset + command.Payload.Length > command.totalLength;
|
||||
if (flag16)
|
||||
{
|
||||
bool flag17 = base.debugOut >= DebugLevel.ERROR;
|
||||
if (flag17)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ERROR, "Received fragment has bad size: " + command);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
flag = this.QueueIncomingCommand(command);
|
||||
bool flag18 = flag;
|
||||
if (flag18)
|
||||
{
|
||||
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
||||
bool flag19 = command.reliableSequenceNumber == command.startSequenceNumber;
|
||||
if (flag19)
|
||||
{
|
||||
command.fragmentsRemaining--;
|
||||
int num = command.startSequenceNumber + 1;
|
||||
while (command.fragmentsRemaining > 0 && num < command.startSequenceNumber + command.fragmentCount)
|
||||
{
|
||||
bool flag20 = channel.ContainsReliableSequenceNumber(num++);
|
||||
if (flag20)
|
||||
{
|
||||
command.fragmentsRemaining--;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag21 = channel.ContainsReliableSequenceNumber(command.startSequenceNumber);
|
||||
if (flag21)
|
||||
{
|
||||
NCommand ncommand2 = channel.FetchReliableSequenceNumber(command.startSequenceNumber);
|
||||
ncommand2.fragmentsRemaining--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return flag;
|
||||
}
|
||||
|
||||
// Token: 0x0600016B RID: 363 RVA: 0x0000D41C File Offset: 0x0000B61C
|
||||
internal bool QueueIncomingCommand(NCommand command)
|
||||
{
|
||||
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
||||
bool flag = channel == null;
|
||||
bool flag3;
|
||||
if (flag)
|
||||
{
|
||||
bool flag2 = base.debugOut >= DebugLevel.ERROR;
|
||||
if (flag2)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ERROR, "Received command for non-existing channel: " + command.commandChannelID);
|
||||
}
|
||||
flag3 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag4 = base.debugOut >= DebugLevel.ALL;
|
||||
if (flag4)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.ALL, string.Concat(new object[] { "queueIncomingCommand() ", command, " channel seq# r/u: ", channel.incomingReliableSequenceNumber, "/", channel.incomingUnreliableSequenceNumber }));
|
||||
}
|
||||
bool flag5 = command.commandFlags == 1;
|
||||
if (flag5)
|
||||
{
|
||||
bool flag6 = command.reliableSequenceNumber <= channel.incomingReliableSequenceNumber;
|
||||
if (flag6)
|
||||
{
|
||||
bool flag7 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag7)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[] { "incoming command ", command, " is old (not saving it). Dispatched incomingReliableSequenceNumber: ", channel.incomingReliableSequenceNumber }));
|
||||
}
|
||||
flag3 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag8 = channel.ContainsReliableSequenceNumber(command.reliableSequenceNumber);
|
||||
if (flag8)
|
||||
{
|
||||
bool flag9 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag9)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
||||
{
|
||||
"Info: command was received before! Old/New: ",
|
||||
channel.FetchReliableSequenceNumber(command.reliableSequenceNumber),
|
||||
"/",
|
||||
command,
|
||||
" inReliableSeq#: ",
|
||||
channel.incomingReliableSequenceNumber
|
||||
}));
|
||||
}
|
||||
flag3 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
channel.incomingReliableCommandsList.Add(command.reliableSequenceNumber, command);
|
||||
flag3 = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag10 = command.commandFlags == 0;
|
||||
if (flag10)
|
||||
{
|
||||
bool flag11 = command.reliableSequenceNumber < channel.incomingReliableSequenceNumber;
|
||||
if (flag11)
|
||||
{
|
||||
bool flag12 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag12)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, "incoming reliable-seq# < Dispatched-rel-seq#. not saved.");
|
||||
}
|
||||
flag3 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag13 = command.unreliableSequenceNumber <= channel.incomingUnreliableSequenceNumber;
|
||||
if (flag13)
|
||||
{
|
||||
bool flag14 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag14)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, "incoming unreliable-seq# < Dispatched-unrel-seq#. not saved.");
|
||||
}
|
||||
flag3 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag15 = channel.ContainsUnreliableSequenceNumber(command.unreliableSequenceNumber);
|
||||
if (flag15)
|
||||
{
|
||||
bool flag16 = base.debugOut >= DebugLevel.INFO;
|
||||
if (flag16)
|
||||
{
|
||||
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
||||
{
|
||||
"command was received before! Old/New: ",
|
||||
channel.incomingUnreliableCommandsList[command.unreliableSequenceNumber],
|
||||
"/",
|
||||
command
|
||||
}));
|
||||
}
|
||||
flag3 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
channel.incomingUnreliableCommandsList.Add(command.unreliableSequenceNumber, command);
|
||||
flag3 = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
flag3 = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return flag3;
|
||||
}
|
||||
|
||||
// Token: 0x0600016C RID: 364 RVA: 0x0000D71C File Offset: 0x0000B91C
|
||||
internal NCommand RemoveSentReliableCommand(int ackReceivedReliableSequenceNumber, int ackReceivedChannel)
|
||||
{
|
||||
NCommand ncommand = null;
|
||||
List<NCommand> list = this.sentReliableCommands;
|
||||
lock (list)
|
||||
{
|
||||
foreach (NCommand ncommand2 in this.sentReliableCommands)
|
||||
{
|
||||
bool flag = ncommand2 != null && ncommand2.reliableSequenceNumber == ackReceivedReliableSequenceNumber && (int)ncommand2.commandChannelID == ackReceivedChannel;
|
||||
if (flag)
|
||||
{
|
||||
ncommand = ncommand2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
bool flag2 = ncommand != null;
|
||||
if (flag2)
|
||||
{
|
||||
this.sentReliableCommands.Remove(ncommand);
|
||||
bool flag3 = this.sentReliableCommands.Count > 0;
|
||||
if (flag3)
|
||||
{
|
||||
this.timeoutInt = this.timeInt + 25;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag4 = base.debugOut >= DebugLevel.ALL && this.peerConnectionState != PeerBase.ConnectionStateValue.Connected && this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnecting;
|
||||
if (flag4)
|
||||
{
|
||||
base.EnqueueDebugReturn(DebugLevel.ALL, string.Format("No sent command for ACK (Ch: {0} Sq#: {1}). PeerState: {2}.", ackReceivedReliableSequenceNumber, ackReceivedChannel, this.peerConnectionState));
|
||||
}
|
||||
}
|
||||
}
|
||||
return ncommand;
|
||||
}
|
||||
|
||||
// Token: 0x0600016D RID: 365 RVA: 0x0000D854 File Offset: 0x0000BA54
|
||||
internal string CommandListToString(NCommand[] list)
|
||||
{
|
||||
bool flag = base.debugOut < DebugLevel.ALL;
|
||||
string text;
|
||||
if (flag)
|
||||
{
|
||||
text = string.Empty;
|
||||
}
|
||||
else
|
||||
{
|
||||
StringBuilder stringBuilder = new StringBuilder();
|
||||
for (int i = 0; i < list.Length; i++)
|
||||
{
|
||||
stringBuilder.Append(i + "=");
|
||||
stringBuilder.Append(list[i]);
|
||||
stringBuilder.Append(" # ");
|
||||
}
|
||||
text = stringBuilder.ToString();
|
||||
}
|
||||
return text;
|
||||
}
|
||||
|
||||
// Token: 0x040000A9 RID: 169
|
||||
private const int CRC_LENGTH = 4;
|
||||
|
||||
// Token: 0x040000AA RID: 170
|
||||
private static readonly int HMAC_SIZE = 32;
|
||||
|
||||
// Token: 0x040000AB RID: 171
|
||||
private static readonly int BLOCK_SIZE = 16;
|
||||
|
||||
// Token: 0x040000AC RID: 172
|
||||
private static readonly int IV_SIZE = 16;
|
||||
|
||||
// Token: 0x040000AD RID: 173
|
||||
private const int EncryptedDataGramHeaderSize = 7;
|
||||
|
||||
// Token: 0x040000AE RID: 174
|
||||
private const int EncryptedHeaderSize = 5;
|
||||
|
||||
// Token: 0x040000AF RID: 175
|
||||
private List<NCommand> sentReliableCommands = new List<NCommand>();
|
||||
|
||||
// Token: 0x040000B0 RID: 176
|
||||
private StreamBuffer outgoingAcknowledgementsPool;
|
||||
|
||||
// Token: 0x040000B1 RID: 177
|
||||
internal readonly int windowSize = 128;
|
||||
|
||||
// Token: 0x040000B2 RID: 178
|
||||
private byte udpCommandCount;
|
||||
|
||||
// Token: 0x040000B3 RID: 179
|
||||
private byte[] udpBuffer;
|
||||
|
||||
// Token: 0x040000B4 RID: 180
|
||||
private int udpBufferIndex;
|
||||
|
||||
// Token: 0x040000B5 RID: 181
|
||||
private int udpBufferLength;
|
||||
|
||||
// Token: 0x040000B6 RID: 182
|
||||
private byte[] bufferForEncryption;
|
||||
|
||||
// Token: 0x040000B7 RID: 183
|
||||
internal int challenge;
|
||||
|
||||
// Token: 0x040000B8 RID: 184
|
||||
internal int reliableCommandsRepeated;
|
||||
|
||||
// Token: 0x040000B9 RID: 185
|
||||
internal int reliableCommandsSent;
|
||||
|
||||
// Token: 0x040000BA RID: 186
|
||||
internal int serverSentTime;
|
||||
|
||||
// Token: 0x040000BB RID: 187
|
||||
internal static readonly byte[] udpHeader0xF3 = new byte[] { 243, 2 };
|
||||
|
||||
// Token: 0x040000BC RID: 188
|
||||
internal static readonly byte[] messageHeader = EnetPeer.udpHeader0xF3;
|
||||
|
||||
// Token: 0x040000BD RID: 189
|
||||
protected bool datagramEncryptedConnection;
|
||||
|
||||
// Token: 0x040000BE RID: 190
|
||||
private EnetChannel[] channelArray = new EnetChannel[0];
|
||||
|
||||
// Token: 0x040000BF RID: 191
|
||||
private const byte ControlChannelNumber = 255;
|
||||
|
||||
// Token: 0x040000C0 RID: 192
|
||||
protected internal const short PeerIdForConnect = -1;
|
||||
|
||||
// Token: 0x040000C1 RID: 193
|
||||
protected internal const short PeerIdForConnectTrace = -2;
|
||||
|
||||
// Token: 0x040000C2 RID: 194
|
||||
private Queue<int> commandsToRemove = new Queue<int>();
|
||||
|
||||
// Token: 0x040000C3 RID: 195
|
||||
private Queue<NCommand> commandsToResend = new Queue<NCommand>();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user