public bool Start()
{
// all addresses for Photon region servers will contain a :port ending. this needs to be removed first.
// PhotonPing.StartPing() requires a plain (IP) address without port or protocol-prefix (on all but Windows 8.1 and WebGL platforms).
string address = this.region.HostAndPort;
int indexOfColon = address.LastIndexOf(':');
if (indexOfColon > 1)
{
address = address.Substring(0, indexOfColon);
}
this.regionAddress = ResolveHost(address);
this.ping = this.GetPingImplementation();
this.Done = false;
this.CurrentAttempt = 0;
#if PING_VIA_COROUTINE
GameObject go = new GameObject();
go.name = "RegionPing_" + this.region.Code + "_" + this.region.Cluster;
this.coroutineMonoBehaviour = go.AddComponent <MonoBehaviourEmpty>(); // is defined below, as special case for Unity WegGL
this.coroutineMonoBehaviour.StartCoroutine(this.RegionPingCoroutine());
#else
SupportClass.StartBackgroundCalls(this.RegionPingThreaded, 0, "RegionPing_" + this.region.Code + "_" + this.region.Cluster);
#endif
return(true);
}
public bool Start()
{
// all addresses for Photon region servers will contain a :port ending. this needs to be removed first.
// PhotonPing.StartPing() requires a plain (IP) address without port or protocol-prefix (on all but Windows 8.1 and WebGL platforms).
string address = this.region.HostAndPort;
int indexOfColon = address.LastIndexOf(':');
if (indexOfColon > 1)
{
address = address.Substring(0, indexOfColon);
}
this.regionAddress = ResolveHost(address);
this.ping = this.GetPingImplementation();
this.Done = false;
this.CurrentAttempt = 0;
this.rttResults = new List <int>(Attempts);
#if PING_VIA_COROUTINE
MonoBehaviourEmpty.Instance.StartCoroutine(this.RegionPingCoroutine());
#elif UNITY_SWITCH
SupportClass.StartBackgroundCalls(this.RegionPingThreaded, 0);
#else
SupportClass.StartBackgroundCalls(this.RegionPingThreaded, 0, "RegionPing_" + this.region.Code + "_" + this.region.Cluster);
#endif
return(true);
}
public static void StartFallbackSendAckThread()
{
#if !UNITY_WEBGL
if (sendThreadShouldRun)
{
return;
}
sendThreadShouldRun = true;
SupportClassPun.CallInBackground(FallbackSendAckThread); // thread will call this every 100ms until method returns false
#endif
}
/// <summary>
/// Connects this client to the Photon Chat Cloud service, which will also authenticate the user (and set a UserId).
/// </summary>
/// <param name="appId">Get your Photon Chat AppId from the <a href="https://www.photonengine.com/en/Chat/Dashboard">Dashboard</a>.</param>
/// <param name="appVersion">Any version string you make up. Used to separate users and variants of your clients, which might be incompatible.</param>
/// <param name="authValues">Values for authentication. You can leave this null, if you set a UserId before. If you set authValues, they will override any UserId set before.</param>
/// <returns></returns>
public bool Connect(string appId, string appVersion, AuthenticationValues authValues)
{
this.chatPeer.TimePingInterval = 3000;
this.DisconnectedCause = ChatDisconnectCause.None;
if (authValues != null)
{
this.AuthValues = authValues;
if (string.IsNullOrEmpty(this.AuthValues.UserId))
{
if (this.DebugOut >= DebugLevel.ERROR)
{
this.listener.DebugReturn(DebugLevel.ERROR, "Connect failed: no UserId specified in authentication values.");
}
return(false);
}
}
else
{
if (this.DebugOut >= DebugLevel.ERROR)
{
this.listener.DebugReturn(DebugLevel.ERROR, "Connect failed: no authentication values specified");
}
return(false);
}
this.AppId = appId;
this.AppVersion = appVersion;
this.didAuthenticate = false;
this.chatPeer.QuickResendAttempts = 2;
this.chatPeer.SentCountAllowance = 7;
// clean all channels
this.PublicChannels.Clear();
this.PrivateChannels.Clear();
this.PublicChannelsUnsubscribing.Clear();
this.NameServerAddress = this.chatPeer.NameServerAddress;
bool isConnecting = this.chatPeer.Connect();
if (isConnecting)
{
this.State = ChatState.ConnectingToNameServer;
}
if (this.UseBackgroundWorkerForSending)
{
SupportClass.StartBackgroundCalls(this.SendOutgoingInBackground, this.msDeltaForServiceCalls, "ChatClient Service Thread");
}
return(isConnecting);
}
public static void StartFallbackSendAckThread()
{
if (Application.platform == RuntimePlatform.WebGLPlayer)
{
if (sendThreadShouldRun)
{
return;
}
sendThreadShouldRun = true;
SupportClassPun.CallInBackground(FallbackSendAckThread); // thread will call this every 100ms until method returns false
}
}
private void ReadPingResult(byte[] inbuff)
{
int num = 0;
int num2 = 0;
int num3 = 1;
Protocol.Deserialize(out num, inbuff, ref num3);
Protocol.Deserialize(out num2, inbuff, ref num3);
this.lastRoundTripTime = SupportClass.GetTickCount() - num2;
bool flag = !this.serverTimeOffsetIsAvailable;
if (flag)
{
this.roundTripTime = this.lastRoundTripTime;
}
base.UpdateRoundTripTimeAndVariance(this.lastRoundTripTime);
bool flag2 = !this.serverTimeOffsetIsAvailable;
if (flag2)
{
this.serverTimeOffset = num + (this.lastRoundTripTime >> 1) - SupportClass.GetTickCount();
this.serverTimeOffsetIsAvailable = true;
}
}
protected internal void ReadPingResult(OperationResponse operationResponse)
{
int num = (int)operationResponse.Parameters[2];
int num2 = (int)operationResponse.Parameters[1];
this.lastRoundTripTime = SupportClass.GetTickCount() - num2;
bool flag = !this.serverTimeOffsetIsAvailable;
if (flag)
{
this.roundTripTime = this.lastRoundTripTime;
}
base.UpdateRoundTripTimeAndVariance(this.lastRoundTripTime);
bool flag2 = !this.serverTimeOffsetIsAvailable;
if (flag2)
{
this.serverTimeOffset = num + (this.lastRoundTripTime >> 1) - SupportClass.GetTickCount();
this.serverTimeOffsetIsAvailable = true;
}
}
public static string DictionaryToString(IDictionary dictionary, bool includeTypes)
{
bool flag = dictionary == null;
string result;
if (flag)
{
result = "null";
}
else
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("{");
foreach (object obj in dictionary.Keys)
{
bool flag2 = stringBuilder.Length > 1;
if (flag2)
{
stringBuilder.Append(", ");
}
bool flag3 = dictionary[obj] == null;
Type type;
string text;
if (flag3)
{
type = typeof(object);
text = "null";
}
else
{
type = dictionary[obj].GetType();
text = dictionary[obj].ToString();
}
bool flag4 = typeof(IDictionary) == type || typeof(Hashtable) == type;
if (flag4)
{
text = SupportClass.DictionaryToString((IDictionary)dictionary[obj]);
}
bool flag5 = typeof(string[]) == type;
if (flag5)
{
text = string.Format("{{{0}}}", string.Join(",", (string[])dictionary[obj]));
}
bool flag6 = typeof(byte[]) == type;
if (flag6)
{
text = string.Format("byte[{0}]", ((byte[])dictionary[obj]).Length);
}
if (includeTypes)
{
stringBuilder.AppendFormat("({0}){1}=({2}){3}", new object[]
{
obj.GetType().Name,
obj,
type.Name,
text
});
}
else
{
stringBuilder.AppendFormat("{0}={1}", obj, text);
}
}
stringBuilder.Append("}");
result = stringBuilder.ToString();
}
return(result);
}
internal override void ReceiveIncomingCommands(byte[] inbuff, int dataLength)
{
bool flag = inbuff == null;
if (flag)
{
bool flag2 = base.debugOut >= DebugLevel.ERROR;
if (flag2)
{
base.EnqueueDebugReturn(DebugLevel.ERROR, "checkAndQueueIncomingCommands() inBuff: null");
}
}
else
{
this.timestampOfLastReceive = SupportClass.GetTickCount();
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
this.timeLastSendOutgoing = this.timeInt;
this.bytesIn += (long)(inbuff.Length + 7);
bool trafficStatsEnabled = base.TrafficStatsEnabled;
if (trafficStatsEnabled)
{
TrafficStats expr_7B = base.TrafficStatsIncoming;
int num = expr_7B.TotalPacketCount;
expr_7B.TotalPacketCount = num + 1;
TrafficStats expr_91 = base.TrafficStatsIncoming;
num = expr_91.TotalCommandsInPackets;
expr_91.TotalCommandsInPackets = num + 1;
}
bool flag3 = inbuff[0] == 243 || inbuff[0] == 244;
if (flag3)
{
Queue <byte[]> obj = this.incomingList;
lock (obj)
{
this.incomingList.Enqueue(inbuff);
bool flag4 = this.incomingList.Count % this.warningSize == 0;
if (flag4)
{
base.EnqueueStatusCallback(StatusCode.QueueIncomingReliableWarning);
}
}
}
else
{
bool flag5 = inbuff[0] == 240;
if (flag5)
{
base.TrafficStatsIncoming.CountControlCommand(inbuff.Length);
this.ReadPingResult(inbuff);
}
else
{
bool flag6 = base.debugOut >= DebugLevel.ERROR;
if (flag6)
{
base.EnqueueDebugReturn(DebugLevel.ERROR, "receiveIncomingCommands() MagicNumber should be 0xF0, 0xF3 or 0xF4. Is: " + inbuff[0]);
}
}
}
}
}
public override object Deserialize(StreamBuffer din, byte type)
{
switch (type)
{
case 105:
return(this.DeserializeInteger(din));
case 115:
return(this.DeserializeString(din));
case 97:
return(this.DeserializeStringArray(din));
case 120:
return(this.DeserializeByteArray(din, -1));
case 110:
return(this.DeserializeIntArray(din, -1));
case 104:
return(this.DeserializeHashTable(din));
case 68:
return(this.DeserializeDictionary(din));
case 111:
return(this.DeserializeBoolean(din));
case 107:
return(this.DeserializeShort(din));
case 108:
return(this.DeserializeLong(din));
case 98:
return(this.DeserializeByte(din));
case 102:
return(this.DeserializeFloat(din));
case 100:
return(this.DeserializeDouble(din));
case 121:
return(this.DeserializeArray(din));
case 99:
{
byte customTypeCode = din.ReadByte();
return(this.DeserializeCustom(din, customTypeCode));
}
case 122:
return(this.DeserializeObjectArray(din));
case 101:
return(this.DeserializeEventData(din, null));
case 113:
return(this.DeserializeOperationRequest(din));
case 112:
return(this.DeserializeOperationResponse(din));
case 0:
case 42:
return(null);
default:
throw new Exception("Deserialize(): " + type + " pos: " + din.Position + " bytes: " + din.Length + ". " + SupportClass.ByteArrayToString(din.GetBuffer()));
}
}
/// <summary>
/// Returns a string-representation of the IDictionary's content, inlcuding type-information.
/// Note: This might turn out a "heavy-duty" call if used frequently but it's usfuly to debug Dictionary or Hashtable content.
/// </summary>
/// <param name="origin">Some Dictionary or Hashtable.</param>
/// <returns>String of the content of the IDictionary.</returns>
public static string ToStringFull(this IDictionary origin)
{
return(SupportClassPun.DictionaryToString(origin, false));
}
internal override bool SendAcksOnly()
{
if (this.rt == null || !this.rt.Connected || (this.peerConnectionState != PeerBase.ConnectionStateValue.Connected || SupportClass.GetTickCount() - this.lastPingResult <= this.timePingInterval))
{
return(false);
}
this.SendPing();
return(false);
}
internal virtual bool DeserializeMessageAndCallback(StreamBuffer stream)
{
if (stream.IntLength < 2)
{
if ((int)this.debugOut >= 1)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "Incoming UDP data too short! " + stream.IntLength);
}
return(false);
}
byte b = stream.ReadByteAsByte();
if (b != 243 && b != 253)
{
if ((int)this.debugOut >= 1)
{
this.Listener.DebugReturn(DebugLevel.ALL, "No regular operation UDP message: " + b);
}
return(false);
}
byte b2 = stream.ReadByteAsByte();
byte b3 = (byte)(b2 & 0x7F);
bool flag = (b2 & 0x80) > 0;
if (b3 != 1)
{
try
{
if (flag)
{
byte[] buf = this.CryptoProvider.Decrypt(stream.GetBuffer(), 2, stream.IntLength - 2);
stream = new StreamBuffer(buf);
}
else
{
stream.Seek(2L, SeekOrigin.Begin);
}
}
catch (Exception ex)
{
if ((int)this.debugOut >= 1)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "msgType: " + b3 + " exception: " + ex.ToString());
}
SupportClass.WriteStackTrace(ex);
return(false);
}
}
if (FullLogging)
{
Listener.DebugReturn(DebugLevel.ERROR, SupportClass.StreamBufferToString(stream));
}
int num = 0;
switch (b3)
{
case 3:
{
OperationResponse operationResponse = this.SerializationProtocol.DeserializeOperationResponse(stream);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountResult(this.ByteCountCurrentDispatch);
num = SupportClass.GetTickCount();
}
this.Listener.OnOperationResponse(operationResponse);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForResponseCallback(operationResponse.OperationCode, SupportClass.GetTickCount() - num);
}
break;
}
case 4:
{
try
{
EventData eventData = this.SerializationProtocol.DeserializeEventData(stream, this.reusableEventData);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountEvent(this.ByteCountCurrentDispatch);
num = SupportClass.GetTickCount();
}
this.Listener.OnEvent(eventData);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForEventCallback(eventData.Code, SupportClass.GetTickCount() - num);
}
if (this.photonPeer.ReuseEventInstance)
{
this.reusableEventData = eventData;
}
}
catch (Exception e)
{
if (debugOut >= DebugLevel.INFO)
{
this.EnqueueDebugReturn(DebugLevel.ERROR, "Received abnormal EventData: " + e.Message + "\nException: " + e.StackTrace);
}
return(true);
}
break;
}
case 1:
this.InitCallback();
break;
case 7:
{
OperationResponse operationResponse = this.SerializationProtocol.DeserializeOperationResponse(stream);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountResult(this.ByteCountCurrentDispatch);
num = SupportClass.GetTickCount();
}
if (operationResponse.OperationCode == PhotonCodes.InitEncryption)
{
this.DeriveSharedKey(operationResponse);
}
else if (operationResponse.OperationCode == PhotonCodes.Ping)
{
TPeer tPeer = this as TPeer;
if (tPeer != null)
{
tPeer.ReadPingResult(operationResponse);
}
}
else
{
this.EnqueueDebugReturn(DebugLevel.ERROR, "Received unknown internal operation. " + operationResponse.ToStringFull());
}
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForResponseCallback(operationResponse.OperationCode, SupportClass.GetTickCount() - num);
}
break;
}
case 8:
{
object obj = this.SerializationProtocol.DeserializeMessage(stream);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountEvent(this.ByteCountCurrentDispatch);
num = SupportClass.GetTickCount();
}
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForMessageCallback(SupportClass.GetTickCount() - num);
}
break;
}
case 9:
{
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountEvent(this.ByteCountCurrentDispatch);
num = SupportClass.GetTickCount();
}
byte[] array = stream.ToArrayFromPos();
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForRawMessageCallback(SupportClass.GetTickCount() - num);
}
break;
}
default:
this.EnqueueDebugReturn(DebugLevel.ERROR, "unexpected msgType " + b3);
break;
}
return(true);
}
public IEnumerator ReceiveLoop()
{
this.Listener.DebugReturn(DebugLevel.INFO, "ReceiveLoop()");
while (!this.sock.Connected && this.sock.Error == null)
{
yield return(new WaitForSeconds(0.1f));
}
if (this.sock.Error != null)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "Exiting receive thread due to error: " + this.sock.Error + " Server: " + this.ServerAddress);
this.HandleException(StatusCode.ExceptionOnConnect);
}
else
{
if (this.ReportDebugOfLevel(DebugLevel.ALL))
{
this.Listener.DebugReturn(DebugLevel.ALL, "Receiving by websocket. this.State: " + State);
}
State = PhotonSocketState.Connected;
while (State == PhotonSocketState.Connected)
{
if (this.sock.Error != null)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "Exiting receive thread (inside loop) due to error: " + this.sock.Error + " Server: " + this.ServerAddress);
this.HandleException(StatusCode.ExceptionOnReceive);
break;
}
else
{
byte[] inBuff = this.sock.Recv();
if (inBuff == null || inBuff.Length == 0)
{
yield return(new WaitForSeconds(0.1f));
continue;
}
if (this.ReportDebugOfLevel(DebugLevel.ALL))
{
this.Listener.DebugReturn(DebugLevel.ALL, "TCP << " + inBuff.Length + " = " + SupportClass.ByteArrayToString(inBuff));
}
// check if it's a ping-result (first byte = 0xF0). this is 9 bytes in total. no other headers!
// note: its a coincidence that ping-result-size == header-size. if this changes we have to refactor this
if (inBuff[0] == 0xF0)
{
try
{
HandleReceivedDatagram(inBuff, inBuff.Length, false);
}
catch (Exception e)
{
if (this.ReportDebugOfLevel(DebugLevel.ERROR))
{
this.EnqueueDebugReturn(DebugLevel.ERROR, "Receive issue. State: " + this.State + ". Server: '" + this.ServerAddress + "' Exception: " + e);
}
this.HandleException(StatusCode.ExceptionOnReceive);
}
continue;
}
// get data and split the datagram into two buffers: head and body
if (inBuff.Length > 0)
{
try
{
HandleReceivedDatagram(inBuff, inBuff.Length, false);
}
catch (Exception e)
{
if (this.ReportDebugOfLevel(DebugLevel.ERROR))
{
this.EnqueueDebugReturn(DebugLevel.ERROR, "Receive issue. State: " + this.State + ". Server: '" + this.ServerAddress + "' Exception: " + e);
}
this.HandleException(StatusCode.ExceptionOnReceive);
}
}
}
}
}
Disconnect();
}
internal override bool SendOutgoingCommands()
{
if (this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected || !this.rt.Connected)
{
return(false);
}
if (this.peerConnectionState == PeerBase.ConnectionStateValue.Connected && SupportClass.GetTickCount() - this.lastPingResult > this.timePingInterval)
{
this.SendPing();
}
lock (this.outgoingStream)
{
if (this.outgoingStream.Position > 0L)
{
this.SendData(this.outgoingStream.ToArray());
this.outgoingStream.Position = 0L;
this.outgoingStream.SetLength(0L);
this.outgoingCommandsInStream = 0;
}
}
return(false);
}
public static byte CallInBackground(Func <bool> myThread, int millisecondsInterval = 100, string taskName = "")
{
return(SupportClass.StartBackgroundCalls(myThread, millisecondsInterval, null));
}
public static int GetTickCount()
{
return(SupportClass.IntegerMilliseconds());
}
public static string HashtableToString(Hashtable hash)
{
return(SupportClass.DictionaryToString(hash));
}
/// <summary>Returns a summary of this Room instance as longer string, including Custom Properties.</summary>
/// <returns>Summary of this Room instance.</returns>
public new string ToStringFull()
{
return(string.Format("Room: '{0}' {1},{2} {4}/{3} players.\ncustomProps: {5}", this.name, this.isVisible ? "visible" : "hidden", this.isOpen ? "open" : "closed", this.maxPlayers, this.PlayerCount, SupportClass.DictionaryToString(this.CustomProperties)));
}
private void ReadPingResult(byte[] inbuff)
{
int num1 = 0;
int num2 = 0;
int offset = 1;
Protocol.Deserialize(out num1, inbuff, ref offset);
Protocol.Deserialize(out num2, inbuff, ref offset);
this.lastRoundTripTime = SupportClass.GetTickCount() - num2;
if (!this.serverTimeOffsetIsAvailable)
{
this.roundTripTime = this.lastRoundTripTime;
}
this.UpdateRoundTripTimeAndVariance(this.lastRoundTripTime);
if (this.serverTimeOffsetIsAvailable)
{
return;
}
this.serverTimeOffset = num1 + (this.lastRoundTripTime >> 1) - SupportClass.GetTickCount();
this.serverTimeOffsetIsAvailable = true;
}
public string CommandLogToString()
{
StringBuilder stringBuilder = new StringBuilder();
int num = (this.usedTransportProtocol == ConnectionProtocol.Udp) ? ((EnetPeer)this).reliableCommandsRepeated : 0;
stringBuilder.AppendFormat("PeerId: {0} Now: {1} Server: {2} State: {3} Total Resends: {4} Received {5}ms ago.\n", this.PeerID, this.timeInt, this.ServerAddress, this.peerConnectionState, num, SupportClass.GetTickCount() - this.timestampOfLastReceive);
if (this.CommandLog == null)
{
return(stringBuilder.ToString());
}
foreach (CmdLogItem item in this.CommandLog)
{
stringBuilder.AppendLine(item.ToString());
}
stringBuilder.AppendLine("Received Reliable Log: ");
foreach (CmdLogItem item2 in this.InReliableLog)
{
stringBuilder.AppendLine(item2.ToString());
}
return(stringBuilder.ToString());
}
public static void WriteStackTrace(Exception throwable)
{
SupportClass.WriteStackTrace(throwable, null);
}
///<summary>
/// Returns a string of the most interesting connection statistics.
/// When you have issues on the client side, these might contain hints about the issue's cause.
///</summary>
///<param name="all">If true, Incoming and Outgoing low-level stats are included in the string.</param>
///<returns>Stats as string.</returns>
public string VitalStatsToString(bool all)
{
if (this.TrafficStatsGameLevel == null)
{
return("Stats not available. Use PhotonPeer.TrafficStatsEnabled.");
}
if (!all)
{
return(string.Format("Rtt(variance): {0}({1}). Ms since last receive: {2}. Stats elapsed: {4}sec.\n{3}", new object[] { this.RoundTripTime, this.RoundTripTimeVariance, SupportClass.GetTickCount() - this.TimestampOfLastSocketReceive, this.TrafficStatsGameLevel.ToStringVitalStats(), this.TrafficStatsElapsedMs / 0x3e8L }));
}
return(string.Format("Rtt(variance): {0}({1}). Ms since last receive: {2}. Stats elapsed: {6}sec.\n{3}\n{4}\n{5}", new object[] { this.RoundTripTime, this.RoundTripTimeVariance, SupportClass.GetTickCount() - this.TimestampOfLastSocketReceive, this.TrafficStatsGameLevel.ToStringVitalStats(), this.TrafficStatsIncoming.ToString(), this.TrafficStatsOutgoing.ToString(), this.TrafficStatsElapsedMs / 0x3e8L }));
}
internal virtual bool DeserializeMessageAndCallback(byte[] inBuff)
{
OperationResponse opRes;
if (inBuff.Length < 2)
{
if (this.debugOut >= DebugLevel.ERROR)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "Incoming UDP data too short! " + inBuff.Length);
}
return(false);
}
if ((inBuff[0] != 0xf3) && (inBuff[0] != 0xfd))
{
if (this.debugOut >= DebugLevel.ERROR)
{
this.Listener.DebugReturn(DebugLevel.ALL, "No regular operation UDP message: " + inBuff[0]);
}
return(false);
}
byte msgType = (byte)(inBuff[1] & 0x7f);
bool isEncrypted = (inBuff[1] & 0x80) > 0;
MemoryStream stream = null;
if (msgType != 1)
{
try
{
if (isEncrypted)
{
inBuff = this.CryptoProvider.Decrypt(inBuff, 2, inBuff.Length - 2);
stream = new MemoryStream(inBuff);
}
else
{
stream = new MemoryStream(inBuff);
stream.Seek(2L, SeekOrigin.Begin);
}
}
catch (Exception ex)
{
if (this.debugOut >= DebugLevel.ERROR)
{
this.Listener.DebugReturn(DebugLevel.ERROR, ex.ToString());
}
SupportClass.WriteStackTrace(ex, null);
return(false);
}
}
int timeBeforeCallback = 0;
switch (msgType)
{
case 1:
this.InitCallback();
break;
case 3:
opRes = Protocol.DeserializeOperationResponse(stream);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountResult(this.ByteCountCurrentDispatch);
timeBeforeCallback = SupportClass.GetTickCount();
}
this.Listener.OnOperationResponse(opRes);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForResponseCallback(opRes.OperationCode, SupportClass.GetTickCount() - timeBeforeCallback);
}
break;
case 4:
{
EventData ev = Protocol.DeserializeEventData(stream);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountEvent(this.ByteCountCurrentDispatch);
timeBeforeCallback = SupportClass.GetTickCount();
}
this.Listener.OnEvent(ev);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForEventCallback(ev.Code, SupportClass.GetTickCount() - timeBeforeCallback);
}
break;
}
case 7:
opRes = Protocol.DeserializeOperationResponse(stream);
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.CountResult(this.ByteCountCurrentDispatch);
timeBeforeCallback = SupportClass.GetTickCount();
}
if (opRes.OperationCode == PhotonCodes.InitEncryption)
{
this.DeriveSharedKey(opRes);
}
else
{
this.EnqueueDebugReturn(DebugLevel.ERROR, "Received unknown internal operation. " + opRes.ToStringFull());
}
if (this.TrafficStatsEnabled)
{
this.TrafficStatsGameLevel.TimeForResponseCallback(opRes.OperationCode, SupportClass.GetTickCount() - timeBeforeCallback);
}
break;
default:
this.EnqueueDebugReturn(DebugLevel.ERROR, "unexpected msgType " + msgType);
break;
}
return(true);
}
/// <summary>Turns the response into an easier to read string.</summary>
/// <returns>String resembling the result.</returns>
public string ToStringFull()
{
return(string.Format("{0}={2}: {1} \"{3}\"", this.Name, SupportClass.DictionaryToString(this.Parameters), this.ResultCode, this.Message));
}
internal override bool SendAcksOnly()
{
bool flag = this.rt == null || !this.rt.Connected;
bool result;
if (flag)
{
result = false;
}
else
{
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
this.timeLastSendOutgoing = this.timeInt;
bool flag2 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected && SupportClass.GetTickCount() - this.lastPingResult > base.timePingInterval;
if (flag2)
{
this.SendPing();
}
result = false;
}
return(result);
}
/// <summary>
/// This Player's NickName and custom properties as string.
/// </summary>
public override string ToString()
{
return(this.NickName + " " + SupportClass.DictionaryToString(this.CustomProperties));
}
public static string DictionaryToString(IDictionary dictionary)
{
return(SupportClass.DictionaryToString(dictionary, true));
}
/// <summary>
/// Brief summary string of the Player. Includes name or player.ID and if it's the Master Client.
/// </summary>
public override string ToString()
{
return((string.IsNullOrEmpty(this.NickName) ? this.ActorNumber.ToString() : this.nickName) + " " + SupportClass.DictionaryToString(this.CustomProperties));
}
internal override bool SendOutgoingCommands()
{
bool flag = this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected;
bool result;
if (flag)
{
result = false;
}
else
{
bool flag2 = !this.rt.Connected;
if (flag2)
{
result = false;
}
else
{
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
this.timeLastSendOutgoing = this.timeInt;
bool flag3 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected && SupportClass.GetTickCount() - this.lastPingResult > base.timePingInterval;
if (flag3)
{
this.SendPing();
}
List <byte[]> obj = this.outgoingStream;
lock (obj)
{
foreach (byte[] current in this.outgoingStream)
{
this.SendData(current);
}
this.outgoingStream.Clear();
this.outgoingCommandsInStream = 0;
}
result = false;
}
}
return(result);
}