niko
1294 lines
35 KiB
C#
1294 lines
35 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using UnityEngine.Networking.Match;
|
|
using UnityEngine.Networking.NetworkSystem;
|
|
|
|
namespace UnityEngine.Networking
|
|
{
|
|
// Token: 0x0200003D RID: 61
|
|
public class NetworkClient
|
|
{
|
|
// Token: 0x06000160 RID: 352 RVA: 0x00004CE4 File Offset: 0x00002EE4
|
|
public NetworkClient()
|
|
{
|
|
if (LogFilter.logDev)
|
|
{
|
|
Debug.Log("Client created version " + Version.Current);
|
|
}
|
|
this.m_MsgBuffer = new byte[65535];
|
|
this.m_MsgReader = new NetworkReader(this.m_MsgBuffer);
|
|
NetworkClient.AddClient(this);
|
|
}
|
|
|
|
// Token: 0x06000161 RID: 353 RVA: 0x00004D88 File Offset: 0x00002F88
|
|
public NetworkClient(NetworkConnection conn)
|
|
{
|
|
if (LogFilter.logDev)
|
|
{
|
|
Debug.Log("Client created version " + Version.Current);
|
|
}
|
|
this.m_MsgBuffer = new byte[65535];
|
|
this.m_MsgReader = new NetworkReader(this.m_MsgBuffer);
|
|
NetworkClient.AddClient(this);
|
|
NetworkClient.SetActive(true);
|
|
this.m_Connection = conn;
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Connected;
|
|
conn.SetHandlers(this.m_MessageHandlers);
|
|
this.RegisterSystemHandlers(false);
|
|
}
|
|
|
|
// Token: 0x1700002C RID: 44
|
|
// (get) Token: 0x06000162 RID: 354 RVA: 0x00004E54 File Offset: 0x00003054
|
|
public static List<NetworkClient> allClients
|
|
{
|
|
get
|
|
{
|
|
return NetworkClient.s_Clients;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002D RID: 45
|
|
// (get) Token: 0x06000163 RID: 355 RVA: 0x00004E70 File Offset: 0x00003070
|
|
public static bool active
|
|
{
|
|
get
|
|
{
|
|
return NetworkClient.s_IsActive;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000164 RID: 356 RVA: 0x00004E8A File Offset: 0x0000308A
|
|
internal void SetHandlers(NetworkConnection conn)
|
|
{
|
|
conn.SetHandlers(this.m_MessageHandlers);
|
|
}
|
|
|
|
// Token: 0x1700002E RID: 46
|
|
// (get) Token: 0x06000165 RID: 357 RVA: 0x00004E9C File Offset: 0x0000309C
|
|
public string serverIp
|
|
{
|
|
get
|
|
{
|
|
return this.m_ServerIp;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002F RID: 47
|
|
// (get) Token: 0x06000166 RID: 358 RVA: 0x00004EB8 File Offset: 0x000030B8
|
|
public int serverPort
|
|
{
|
|
get
|
|
{
|
|
return this.m_ServerPort;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000030 RID: 48
|
|
// (get) Token: 0x06000167 RID: 359 RVA: 0x00004ED4 File Offset: 0x000030D4
|
|
public NetworkConnection connection
|
|
{
|
|
get
|
|
{
|
|
return this.m_Connection;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000031 RID: 49
|
|
// (get) Token: 0x06000168 RID: 360 RVA: 0x00004EF0 File Offset: 0x000030F0
|
|
[Obsolete("Moved to NetworkMigrationManager.")]
|
|
public PeerInfoMessage[] peers
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000032 RID: 50
|
|
// (get) Token: 0x06000169 RID: 361 RVA: 0x00004F08 File Offset: 0x00003108
|
|
internal int hostId
|
|
{
|
|
get
|
|
{
|
|
return this.m_ClientId;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000033 RID: 51
|
|
// (get) Token: 0x0600016A RID: 362 RVA: 0x00004F24 File Offset: 0x00003124
|
|
public Dictionary<short, NetworkMessageDelegate> handlers
|
|
{
|
|
get
|
|
{
|
|
return this.m_MessageHandlers.GetHandlers();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000034 RID: 52
|
|
// (get) Token: 0x0600016B RID: 363 RVA: 0x00004F44 File Offset: 0x00003144
|
|
public int numChannels
|
|
{
|
|
get
|
|
{
|
|
return this.m_HostTopology.DefaultConfig.ChannelCount;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000035 RID: 53
|
|
// (get) Token: 0x0600016C RID: 364 RVA: 0x00004F6C File Offset: 0x0000316C
|
|
public HostTopology hostTopology
|
|
{
|
|
get
|
|
{
|
|
return this.m_HostTopology;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000036 RID: 54
|
|
// (get) Token: 0x0600016D RID: 365 RVA: 0x00004F88 File Offset: 0x00003188
|
|
// (set) Token: 0x0600016E RID: 366 RVA: 0x00004FA3 File Offset: 0x000031A3
|
|
public int hostPort
|
|
{
|
|
get
|
|
{
|
|
return this.m_HostPort;
|
|
}
|
|
set
|
|
{
|
|
if (value < 0)
|
|
{
|
|
throw new ArgumentException("Port must not be a negative number.");
|
|
}
|
|
if (value > 65535)
|
|
{
|
|
throw new ArgumentException("Port must not be greater than 65535.");
|
|
}
|
|
this.m_HostPort = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000037 RID: 55
|
|
// (get) Token: 0x0600016F RID: 367 RVA: 0x00004FD8 File Offset: 0x000031D8
|
|
public bool isConnected
|
|
{
|
|
get
|
|
{
|
|
return this.m_AsyncConnect == NetworkClient.ConnectState.Connected;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000038 RID: 56
|
|
// (get) Token: 0x06000170 RID: 368 RVA: 0x00004FF8 File Offset: 0x000031F8
|
|
public Type networkConnectionClass
|
|
{
|
|
get
|
|
{
|
|
return this.m_NetworkConnectionClass;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000171 RID: 369 RVA: 0x00005013 File Offset: 0x00003213
|
|
public void SetNetworkConnectionClass<T>() where T : NetworkConnection
|
|
{
|
|
this.m_NetworkConnectionClass = typeof(T);
|
|
}
|
|
|
|
// Token: 0x06000172 RID: 370 RVA: 0x00005028 File Offset: 0x00003228
|
|
public bool Configure(ConnectionConfig config, int maxConnections)
|
|
{
|
|
HostTopology hostTopology = new HostTopology(config, maxConnections);
|
|
return this.Configure(hostTopology);
|
|
}
|
|
|
|
// Token: 0x06000173 RID: 371 RVA: 0x0000504C File Offset: 0x0000324C
|
|
public bool Configure(HostTopology topology)
|
|
{
|
|
this.m_HostTopology = topology;
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000174 RID: 372 RVA: 0x00005069 File Offset: 0x00003269
|
|
public void Connect(MatchInfo matchInfo)
|
|
{
|
|
this.PrepareForConnect();
|
|
this.ConnectWithRelay(matchInfo);
|
|
}
|
|
|
|
// Token: 0x06000175 RID: 373 RVA: 0x0000507C File Offset: 0x0000327C
|
|
public bool ReconnectToNewHost(string serverIp, int serverPort)
|
|
{
|
|
bool flag;
|
|
if (!NetworkClient.active)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect - NetworkClient must be active");
|
|
}
|
|
flag = false;
|
|
}
|
|
else if (this.m_Connection == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect - no old connection exists");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logInfo)
|
|
{
|
|
Debug.Log(string.Concat(new object[] { "NetworkClient Reconnect ", serverIp, ":", serverPort }));
|
|
}
|
|
ClientScene.HandleClientDisconnect(this.m_Connection);
|
|
ClientScene.ClearLocalPlayers();
|
|
this.m_Connection.Disconnect();
|
|
this.m_Connection = null;
|
|
this.m_ClientId = NetworkTransport.AddHost(this.m_HostTopology, this.m_HostPort);
|
|
this.m_ServerPort = serverPort;
|
|
if (Application.platform == RuntimePlatform.WebGLPlayer)
|
|
{
|
|
this.m_ServerIp = serverIp;
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Resolved;
|
|
}
|
|
else if (serverIp.Equals("127.0.0.1") || serverIp.Equals("localhost"))
|
|
{
|
|
this.m_ServerIp = "127.0.0.1";
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Resolved;
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Async DNS START:" + serverIp);
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Resolving;
|
|
Dns.BeginGetHostAddresses(serverIp, new AsyncCallback(NetworkClient.GetHostAddressesCallback), this);
|
|
}
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000176 RID: 374 RVA: 0x000051F4 File Offset: 0x000033F4
|
|
public bool ReconnectToNewHost(EndPoint secureTunnelEndPoint)
|
|
{
|
|
bool flag;
|
|
if (!NetworkClient.active)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect - NetworkClient must be active");
|
|
}
|
|
flag = false;
|
|
}
|
|
else if (this.m_Connection == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect - no old connection exists");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logInfo)
|
|
{
|
|
Debug.Log("NetworkClient Reconnect to remoteSockAddr");
|
|
}
|
|
ClientScene.HandleClientDisconnect(this.m_Connection);
|
|
ClientScene.ClearLocalPlayers();
|
|
this.m_Connection.Disconnect();
|
|
this.m_Connection = null;
|
|
this.m_ClientId = NetworkTransport.AddHost(this.m_HostTopology, this.m_HostPort);
|
|
if (secureTunnelEndPoint == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect failed: null endpoint passed in");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
flag = false;
|
|
}
|
|
else if (secureTunnelEndPoint.AddressFamily != AddressFamily.InterNetwork && secureTunnelEndPoint.AddressFamily != AddressFamily.InterNetworkV6)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect failed: Endpoint AddressFamily must be either InterNetwork or InterNetworkV6");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
string fullName = secureTunnelEndPoint.GetType().FullName;
|
|
if (fullName == "System.Net.IPEndPoint")
|
|
{
|
|
IPEndPoint ipendPoint = (IPEndPoint)secureTunnelEndPoint;
|
|
this.Connect(ipendPoint.Address.ToString(), ipendPoint.Port);
|
|
flag = this.m_AsyncConnect != NetworkClient.ConnectState.Failed;
|
|
}
|
|
else if (fullName != "UnityEngine.XboxOne.XboxOneEndPoint" && fullName != "UnityEngine.PS4.SceEndPoint")
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect failed: invalid Endpoint (not IPEndPoint or XboxOneEndPoint or SceEndPoint)");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
byte b = 0;
|
|
this.m_RemoteEndPoint = secureTunnelEndPoint;
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Connecting;
|
|
try
|
|
{
|
|
this.m_ClientConnectionId = NetworkTransport.ConnectEndPoint(this.m_ClientId, this.m_RemoteEndPoint, 0, out b);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect failed: Exception when trying to connect to EndPoint: " + ex);
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
return false;
|
|
}
|
|
if (this.m_ClientConnectionId == 0)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Reconnect failed: Unable to connect to EndPoint (" + b + ")");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.m_Connection = (NetworkConnection)Activator.CreateInstance(this.m_NetworkConnectionClass);
|
|
this.m_Connection.SetHandlers(this.m_MessageHandlers);
|
|
this.m_Connection.Initialize(this.m_ServerIp, this.m_ClientId, this.m_ClientConnectionId, this.m_HostTopology);
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000177 RID: 375 RVA: 0x000054A0 File Offset: 0x000036A0
|
|
public void ConnectWithSimulator(string serverIp, int serverPort, int latency, float packetLoss)
|
|
{
|
|
this.m_UseSimulator = true;
|
|
this.m_SimulatedLatency = latency;
|
|
this.m_PacketLoss = packetLoss;
|
|
this.Connect(serverIp, serverPort);
|
|
}
|
|
|
|
// Token: 0x06000178 RID: 376 RVA: 0x000054C4 File Offset: 0x000036C4
|
|
private static bool IsValidIpV6(string address)
|
|
{
|
|
foreach (char c in address)
|
|
{
|
|
if (c != ':' && (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F'))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000179 RID: 377 RVA: 0x00005540 File Offset: 0x00003740
|
|
public void Connect(string serverIp, int serverPort)
|
|
{
|
|
this.PrepareForConnect();
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log(string.Concat(new object[] { "Client Connect: ", serverIp, ":", serverPort }));
|
|
}
|
|
this.m_ServerPort = serverPort;
|
|
if (Application.platform == RuntimePlatform.WebGLPlayer)
|
|
{
|
|
this.m_ServerIp = serverIp;
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Resolved;
|
|
}
|
|
else if (serverIp.Equals("127.0.0.1") || serverIp.Equals("localhost"))
|
|
{
|
|
this.m_ServerIp = "127.0.0.1";
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Resolved;
|
|
}
|
|
else if (serverIp.IndexOf(":") != -1 && NetworkClient.IsValidIpV6(serverIp))
|
|
{
|
|
this.m_ServerIp = serverIp;
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Resolved;
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Async DNS START:" + serverIp);
|
|
}
|
|
this.m_RequestedServerHost = serverIp;
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Resolving;
|
|
Dns.BeginGetHostAddresses(serverIp, new AsyncCallback(NetworkClient.GetHostAddressesCallback), this);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600017A RID: 378 RVA: 0x00005674 File Offset: 0x00003874
|
|
public void Connect(EndPoint secureTunnelEndPoint)
|
|
{
|
|
bool flag = NetworkTransport.DoesEndPointUsePlatformProtocols(secureTunnelEndPoint);
|
|
this.PrepareForConnect(flag);
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Client Connect to remoteSockAddr");
|
|
}
|
|
if (secureTunnelEndPoint == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Connect failed: null endpoint passed in");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
}
|
|
else if (secureTunnelEndPoint.AddressFamily != AddressFamily.InterNetwork && secureTunnelEndPoint.AddressFamily != AddressFamily.InterNetworkV6)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Connect failed: Endpoint AddressFamily must be either InterNetwork or InterNetworkV6");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
}
|
|
else
|
|
{
|
|
string fullName = secureTunnelEndPoint.GetType().FullName;
|
|
if (fullName == "System.Net.IPEndPoint")
|
|
{
|
|
IPEndPoint ipendPoint = (IPEndPoint)secureTunnelEndPoint;
|
|
this.Connect(ipendPoint.Address.ToString(), ipendPoint.Port);
|
|
}
|
|
else if (fullName != "UnityEngine.XboxOne.XboxOneEndPoint" && fullName != "UnityEngine.PS4.SceEndPoint" && fullName != "UnityEngine.PSVita.SceEndPoint")
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Connect failed: invalid Endpoint (not IPEndPoint or XboxOneEndPoint or SceEndPoint)");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
}
|
|
else
|
|
{
|
|
byte b = 0;
|
|
this.m_RemoteEndPoint = secureTunnelEndPoint;
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Connecting;
|
|
try
|
|
{
|
|
this.m_ClientConnectionId = NetworkTransport.ConnectEndPoint(this.m_ClientId, this.m_RemoteEndPoint, 0, out b);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Connect failed: Exception when trying to connect to EndPoint: " + ex);
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
return;
|
|
}
|
|
if (this.m_ClientConnectionId == 0)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Connect failed: Unable to connect to EndPoint (" + b + ")");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
}
|
|
else
|
|
{
|
|
this.m_Connection = (NetworkConnection)Activator.CreateInstance(this.m_NetworkConnectionClass);
|
|
this.m_Connection.SetHandlers(this.m_MessageHandlers);
|
|
this.m_Connection.Initialize(this.m_ServerIp, this.m_ClientId, this.m_ClientConnectionId, this.m_HostTopology);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600017B RID: 379 RVA: 0x00005894 File Offset: 0x00003A94
|
|
private void PrepareForConnect()
|
|
{
|
|
this.PrepareForConnect(false);
|
|
}
|
|
|
|
// Token: 0x0600017C RID: 380 RVA: 0x000058A0 File Offset: 0x00003AA0
|
|
private void PrepareForConnect(bool usePlatformSpecificProtocols)
|
|
{
|
|
NetworkClient.SetActive(true);
|
|
this.RegisterSystemHandlers(false);
|
|
if (this.m_HostTopology == null)
|
|
{
|
|
ConnectionConfig connectionConfig = new ConnectionConfig();
|
|
connectionConfig.AddChannel(QosType.ReliableSequenced);
|
|
connectionConfig.AddChannel(QosType.Unreliable);
|
|
connectionConfig.UsePlatformSpecificProtocols = usePlatformSpecificProtocols;
|
|
this.m_HostTopology = new HostTopology(connectionConfig, 8);
|
|
}
|
|
if (this.m_UseSimulator)
|
|
{
|
|
int num = this.m_SimulatedLatency / 3 - 1;
|
|
if (num < 1)
|
|
{
|
|
num = 1;
|
|
}
|
|
int num2 = this.m_SimulatedLatency * 3;
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log(string.Concat(new object[] { "AddHost Using Simulator ", num, "/", num2 }));
|
|
}
|
|
this.m_ClientId = NetworkTransport.AddHostWithSimulator(this.m_HostTopology, num, num2, this.m_HostPort);
|
|
}
|
|
else
|
|
{
|
|
this.m_ClientId = NetworkTransport.AddHost(this.m_HostTopology, this.m_HostPort);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600017D RID: 381 RVA: 0x00005994 File Offset: 0x00003B94
|
|
internal static void GetHostAddressesCallback(IAsyncResult ar)
|
|
{
|
|
try
|
|
{
|
|
IPAddress[] array = Dns.EndGetHostAddresses(ar);
|
|
NetworkClient networkClient = (NetworkClient)ar.AsyncState;
|
|
if (array.Length == 0)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("DNS lookup failed for:" + networkClient.m_RequestedServerHost);
|
|
}
|
|
networkClient.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
}
|
|
else
|
|
{
|
|
networkClient.m_ServerIp = array[0].ToString();
|
|
networkClient.m_AsyncConnect = NetworkClient.ConnectState.Resolved;
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log(string.Concat(new string[] { "Async DNS Result:", networkClient.m_ServerIp, " for ", networkClient.m_RequestedServerHost, ": ", networkClient.m_ServerIp }));
|
|
}
|
|
}
|
|
}
|
|
catch (SocketException ex)
|
|
{
|
|
NetworkClient networkClient2 = (NetworkClient)ar.AsyncState;
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("DNS resolution failed: " + ex.GetErrorCode());
|
|
}
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Exception:" + ex);
|
|
}
|
|
networkClient2.m_AsyncConnect = NetworkClient.ConnectState.Failed;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600017E RID: 382 RVA: 0x00005AC0 File Offset: 0x00003CC0
|
|
internal void ContinueConnect()
|
|
{
|
|
if (this.m_UseSimulator)
|
|
{
|
|
int num = this.m_SimulatedLatency / 3;
|
|
if (num < 1)
|
|
{
|
|
num = 1;
|
|
}
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log(string.Concat(new object[]
|
|
{
|
|
"Connect Using Simulator ",
|
|
this.m_SimulatedLatency / 3,
|
|
"/",
|
|
this.m_SimulatedLatency
|
|
}));
|
|
}
|
|
ConnectionSimulatorConfig connectionSimulatorConfig = new ConnectionSimulatorConfig(num, this.m_SimulatedLatency, num, this.m_SimulatedLatency, this.m_PacketLoss);
|
|
byte b;
|
|
this.m_ClientConnectionId = NetworkTransport.ConnectWithSimulator(this.m_ClientId, this.m_ServerIp, this.m_ServerPort, 0, out b, connectionSimulatorConfig);
|
|
}
|
|
else
|
|
{
|
|
byte b;
|
|
this.m_ClientConnectionId = NetworkTransport.Connect(this.m_ClientId, this.m_ServerIp, this.m_ServerPort, 0, out b);
|
|
}
|
|
this.m_Connection = (NetworkConnection)Activator.CreateInstance(this.m_NetworkConnectionClass);
|
|
this.m_Connection.SetHandlers(this.m_MessageHandlers);
|
|
this.m_Connection.Initialize(this.m_ServerIp, this.m_ClientId, this.m_ClientConnectionId, this.m_HostTopology);
|
|
}
|
|
|
|
// Token: 0x0600017F RID: 383 RVA: 0x00005BE8 File Offset: 0x00003DE8
|
|
private void ConnectWithRelay(MatchInfo info)
|
|
{
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Connecting;
|
|
this.Update();
|
|
byte b;
|
|
this.m_ClientConnectionId = NetworkTransport.ConnectToNetworkPeer(this.m_ClientId, info.address, info.port, 0, 0, info.networkId, Utility.GetSourceID(), info.nodeId, out b);
|
|
this.m_Connection = (NetworkConnection)Activator.CreateInstance(this.m_NetworkConnectionClass);
|
|
this.m_Connection.SetHandlers(this.m_MessageHandlers);
|
|
this.m_Connection.Initialize(info.address, this.m_ClientId, this.m_ClientConnectionId, this.m_HostTopology);
|
|
if (b != 0)
|
|
{
|
|
Debug.LogError("ConnectToNetworkPeer Error: " + b);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000180 RID: 384 RVA: 0x00005C9C File Offset: 0x00003E9C
|
|
public virtual void Disconnect()
|
|
{
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Disconnected;
|
|
ClientScene.HandleClientDisconnect(this.m_Connection);
|
|
if (this.m_Connection != null)
|
|
{
|
|
this.m_Connection.Disconnect();
|
|
this.m_Connection.Dispose();
|
|
this.m_Connection = null;
|
|
if (this.m_ClientId != -1)
|
|
{
|
|
NetworkTransport.RemoveHost(this.m_ClientId);
|
|
this.m_ClientId = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000181 RID: 385 RVA: 0x00005D08 File Offset: 0x00003F08
|
|
public bool Send(short msgType, MessageBase msg)
|
|
{
|
|
bool flag;
|
|
if (this.m_Connection != null)
|
|
{
|
|
if (this.m_AsyncConnect != NetworkClient.ConnectState.Connected)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient Send when not connected to a server");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
flag = this.m_Connection.Send(msgType, msg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient Send with no connection");
|
|
}
|
|
flag = false;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000182 RID: 386 RVA: 0x00005D80 File Offset: 0x00003F80
|
|
public bool SendWriter(NetworkWriter writer, int channelId)
|
|
{
|
|
bool flag;
|
|
if (this.m_Connection != null)
|
|
{
|
|
if (this.m_AsyncConnect != NetworkClient.ConnectState.Connected)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendWriter when not connected to a server");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
flag = this.m_Connection.SendWriter(writer, channelId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendWriter with no connection");
|
|
}
|
|
flag = false;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000183 RID: 387 RVA: 0x00005DF8 File Offset: 0x00003FF8
|
|
public bool SendBytes(byte[] data, int numBytes, int channelId)
|
|
{
|
|
bool flag;
|
|
if (this.m_Connection != null)
|
|
{
|
|
if (this.m_AsyncConnect != NetworkClient.ConnectState.Connected)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendBytes when not connected to a server");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
flag = this.m_Connection.SendBytes(data, numBytes, channelId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendBytes with no connection");
|
|
}
|
|
flag = false;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000184 RID: 388 RVA: 0x00005E70 File Offset: 0x00004070
|
|
public bool SendUnreliable(short msgType, MessageBase msg)
|
|
{
|
|
bool flag;
|
|
if (this.m_Connection != null)
|
|
{
|
|
if (this.m_AsyncConnect != NetworkClient.ConnectState.Connected)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendUnreliable when not connected to a server");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
flag = this.m_Connection.SendUnreliable(msgType, msg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendUnreliable with no connection");
|
|
}
|
|
flag = false;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000185 RID: 389 RVA: 0x00005EE8 File Offset: 0x000040E8
|
|
public bool SendByChannel(short msgType, MessageBase msg, int channelId)
|
|
{
|
|
bool flag;
|
|
if (this.m_Connection != null)
|
|
{
|
|
if (this.m_AsyncConnect != NetworkClient.ConnectState.Connected)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendByChannel when not connected to a server");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
flag = this.m_Connection.SendByChannel(msgType, msg, channelId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkClient SendByChannel with no connection");
|
|
}
|
|
flag = false;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000186 RID: 390 RVA: 0x00005F5E File Offset: 0x0000415E
|
|
public void SetMaxDelay(float seconds)
|
|
{
|
|
if (this.m_Connection == null)
|
|
{
|
|
if (LogFilter.logWarn)
|
|
{
|
|
Debug.LogWarning("SetMaxDelay failed, not connected.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.m_Connection.SetMaxDelay(seconds);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000187 RID: 391 RVA: 0x00005F94 File Offset: 0x00004194
|
|
public void Shutdown()
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Shutting down client " + this.m_ClientId);
|
|
}
|
|
if (this.m_ClientId != -1)
|
|
{
|
|
NetworkTransport.RemoveHost(this.m_ClientId);
|
|
this.m_ClientId = -1;
|
|
}
|
|
NetworkClient.RemoveClient(this);
|
|
if (NetworkClient.s_Clients.Count == 0)
|
|
{
|
|
NetworkClient.SetActive(false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000188 RID: 392 RVA: 0x00006008 File Offset: 0x00004208
|
|
internal virtual void Update()
|
|
{
|
|
if (this.m_ClientId != -1)
|
|
{
|
|
switch (this.m_AsyncConnect)
|
|
{
|
|
case NetworkClient.ConnectState.None:
|
|
case NetworkClient.ConnectState.Resolving:
|
|
case NetworkClient.ConnectState.Disconnected:
|
|
return;
|
|
case NetworkClient.ConnectState.Resolved:
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Connecting;
|
|
this.ContinueConnect();
|
|
return;
|
|
case NetworkClient.ConnectState.Failed:
|
|
this.GenerateConnectError(11);
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Disconnected;
|
|
return;
|
|
}
|
|
if (this.m_Connection != null)
|
|
{
|
|
if ((int)Time.time != this.m_StatResetTime)
|
|
{
|
|
this.m_Connection.ResetStats();
|
|
this.m_StatResetTime = (int)Time.time;
|
|
}
|
|
}
|
|
int num = 0;
|
|
byte b;
|
|
for (;;)
|
|
{
|
|
int num2;
|
|
int num3;
|
|
int num4;
|
|
NetworkEventType networkEventType = NetworkTransport.ReceiveFromHost(this.m_ClientId, out num2, out num3, this.m_MsgBuffer, (int)((ushort)this.m_MsgBuffer.Length), out num4, out b);
|
|
if (this.m_Connection != null)
|
|
{
|
|
this.m_Connection.lastError = (NetworkError)b;
|
|
}
|
|
if (networkEventType != NetworkEventType.Nothing)
|
|
{
|
|
if (LogFilter.logDev)
|
|
{
|
|
Debug.Log(string.Concat(new object[] { "Client event: host=", this.m_ClientId, " event=", networkEventType, " error=", b }));
|
|
}
|
|
}
|
|
switch (networkEventType)
|
|
{
|
|
case NetworkEventType.DataEvent:
|
|
if (b != 0)
|
|
{
|
|
goto Block_11;
|
|
}
|
|
this.m_MsgReader.SeekZero();
|
|
this.m_Connection.TransportReceive(this.m_MsgBuffer, num4, num3);
|
|
break;
|
|
case NetworkEventType.ConnectEvent:
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Client connected");
|
|
}
|
|
if (b != 0)
|
|
{
|
|
goto Block_10;
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Connected;
|
|
this.m_Connection.InvokeHandlerNoData(32);
|
|
break;
|
|
case NetworkEventType.DisconnectEvent:
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Client disconnected");
|
|
}
|
|
this.m_AsyncConnect = NetworkClient.ConnectState.Disconnected;
|
|
if (b != 0)
|
|
{
|
|
if (b != 6)
|
|
{
|
|
this.GenerateDisconnectError((int)b);
|
|
}
|
|
}
|
|
ClientScene.HandleClientDisconnect(this.m_Connection);
|
|
if (this.m_Connection != null)
|
|
{
|
|
this.m_Connection.InvokeHandlerNoData(33);
|
|
}
|
|
break;
|
|
case NetworkEventType.Nothing:
|
|
break;
|
|
default:
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Unknown network message type received: " + networkEventType);
|
|
}
|
|
break;
|
|
}
|
|
if (++num >= 500)
|
|
{
|
|
goto Block_17;
|
|
}
|
|
if (this.m_ClientId == -1)
|
|
{
|
|
goto Block_19;
|
|
}
|
|
if (networkEventType == NetworkEventType.Nothing)
|
|
{
|
|
goto IL_2C6;
|
|
}
|
|
}
|
|
Block_10:
|
|
this.GenerateConnectError((int)b);
|
|
return;
|
|
Block_11:
|
|
this.GenerateDataError((int)b);
|
|
return;
|
|
Block_17:
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("MaxEventsPerFrame hit (" + 500 + ")");
|
|
}
|
|
Block_19:
|
|
IL_2C6:
|
|
if (this.m_Connection != null && this.m_AsyncConnect == NetworkClient.ConnectState.Connected)
|
|
{
|
|
this.m_Connection.FlushChannels();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000189 RID: 393 RVA: 0x000062FD File Offset: 0x000044FD
|
|
private void GenerateConnectError(int error)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("UNet Client Error Connect Error: " + error);
|
|
}
|
|
this.GenerateError(error);
|
|
}
|
|
|
|
// Token: 0x0600018A RID: 394 RVA: 0x00006328 File Offset: 0x00004528
|
|
private void GenerateDataError(int error)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("UNet Client Data Error: " + (NetworkError)error);
|
|
}
|
|
this.GenerateError(error);
|
|
}
|
|
|
|
// Token: 0x0600018B RID: 395 RVA: 0x00006360 File Offset: 0x00004560
|
|
private void GenerateDisconnectError(int error)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("UNet Client Disconnect Error: " + (NetworkError)error);
|
|
}
|
|
this.GenerateError(error);
|
|
}
|
|
|
|
// Token: 0x0600018C RID: 396 RVA: 0x00006398 File Offset: 0x00004598
|
|
private void GenerateError(int error)
|
|
{
|
|
NetworkMessageDelegate networkMessageDelegate = this.m_MessageHandlers.GetHandler(34);
|
|
if (networkMessageDelegate == null)
|
|
{
|
|
networkMessageDelegate = this.m_MessageHandlers.GetHandler(34);
|
|
}
|
|
if (networkMessageDelegate != null)
|
|
{
|
|
ErrorMessage errorMessage = new ErrorMessage();
|
|
errorMessage.errorCode = error;
|
|
byte[] array = new byte[200];
|
|
NetworkWriter networkWriter = new NetworkWriter(array);
|
|
errorMessage.Serialize(networkWriter);
|
|
NetworkReader networkReader = new NetworkReader(array);
|
|
networkMessageDelegate(new NetworkMessage
|
|
{
|
|
msgType = 34,
|
|
reader = networkReader,
|
|
conn = this.m_Connection,
|
|
channelId = 0
|
|
});
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600018D RID: 397 RVA: 0x00006436 File Offset: 0x00004636
|
|
public void GetStatsOut(out int numMsgs, out int numBufferedMsgs, out int numBytes, out int lastBufferedPerSecond)
|
|
{
|
|
numMsgs = 0;
|
|
numBufferedMsgs = 0;
|
|
numBytes = 0;
|
|
lastBufferedPerSecond = 0;
|
|
if (this.m_Connection != null)
|
|
{
|
|
this.m_Connection.GetStatsOut(out numMsgs, out numBufferedMsgs, out numBytes, out lastBufferedPerSecond);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600018E RID: 398 RVA: 0x00006463 File Offset: 0x00004663
|
|
public void GetStatsIn(out int numMsgs, out int numBytes)
|
|
{
|
|
numMsgs = 0;
|
|
numBytes = 0;
|
|
if (this.m_Connection != null)
|
|
{
|
|
this.m_Connection.GetStatsIn(out numMsgs, out numBytes);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600018F RID: 399 RVA: 0x00006488 File Offset: 0x00004688
|
|
public Dictionary<short, NetworkConnection.PacketStat> GetConnectionStats()
|
|
{
|
|
Dictionary<short, NetworkConnection.PacketStat> dictionary;
|
|
if (this.m_Connection == null)
|
|
{
|
|
dictionary = null;
|
|
}
|
|
else
|
|
{
|
|
dictionary = this.m_Connection.packetStats;
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
// Token: 0x06000190 RID: 400 RVA: 0x000064BA File Offset: 0x000046BA
|
|
public void ResetConnectionStats()
|
|
{
|
|
if (this.m_Connection != null)
|
|
{
|
|
this.m_Connection.ResetStats();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000191 RID: 401 RVA: 0x000064D8 File Offset: 0x000046D8
|
|
public int GetRTT()
|
|
{
|
|
int num;
|
|
if (this.m_ClientId == -1)
|
|
{
|
|
num = 0;
|
|
}
|
|
else
|
|
{
|
|
byte b;
|
|
num = NetworkTransport.GetCurrentRTT(this.m_ClientId, this.m_ClientConnectionId, out b);
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000192 RID: 402 RVA: 0x00006514 File Offset: 0x00004714
|
|
internal void RegisterSystemHandlers(bool localClient)
|
|
{
|
|
ClientScene.RegisterSystemHandlers(this, localClient);
|
|
this.RegisterHandlerSafe(14, new NetworkMessageDelegate(this.OnCRC));
|
|
this.RegisterHandlerSafe(17, new NetworkMessageDelegate(NetworkConnection.OnFragment));
|
|
}
|
|
|
|
// Token: 0x06000193 RID: 403 RVA: 0x00006562 File Offset: 0x00004762
|
|
private void OnCRC(NetworkMessage netMsg)
|
|
{
|
|
netMsg.ReadMessage<CRCMessage>(NetworkClient.s_CRCMessage);
|
|
NetworkCRC.Validate(NetworkClient.s_CRCMessage.scripts, this.numChannels);
|
|
}
|
|
|
|
// Token: 0x06000194 RID: 404 RVA: 0x00006586 File Offset: 0x00004786
|
|
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
|
|
{
|
|
this.m_MessageHandlers.RegisterHandler(msgType, handler);
|
|
}
|
|
|
|
// Token: 0x06000195 RID: 405 RVA: 0x00006596 File Offset: 0x00004796
|
|
public void RegisterHandlerSafe(short msgType, NetworkMessageDelegate handler)
|
|
{
|
|
this.m_MessageHandlers.RegisterHandlerSafe(msgType, handler);
|
|
}
|
|
|
|
// Token: 0x06000196 RID: 406 RVA: 0x000065A6 File Offset: 0x000047A6
|
|
public void UnregisterHandler(short msgType)
|
|
{
|
|
this.m_MessageHandlers.UnregisterHandler(msgType);
|
|
}
|
|
|
|
// Token: 0x06000197 RID: 407 RVA: 0x000065B8 File Offset: 0x000047B8
|
|
public static Dictionary<short, NetworkConnection.PacketStat> GetTotalConnectionStats()
|
|
{
|
|
Dictionary<short, NetworkConnection.PacketStat> dictionary = new Dictionary<short, NetworkConnection.PacketStat>();
|
|
for (int i = 0; i < NetworkClient.s_Clients.Count; i++)
|
|
{
|
|
NetworkClient networkClient = NetworkClient.s_Clients[i];
|
|
Dictionary<short, NetworkConnection.PacketStat> connectionStats = networkClient.GetConnectionStats();
|
|
foreach (short num in connectionStats.Keys)
|
|
{
|
|
if (dictionary.ContainsKey(num))
|
|
{
|
|
NetworkConnection.PacketStat packetStat = dictionary[num];
|
|
packetStat.count += connectionStats[num].count;
|
|
packetStat.bytes += connectionStats[num].bytes;
|
|
dictionary[num] = packetStat;
|
|
}
|
|
else
|
|
{
|
|
dictionary[num] = new NetworkConnection.PacketStat(connectionStats[num]);
|
|
}
|
|
}
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
// Token: 0x06000198 RID: 408 RVA: 0x000066C8 File Offset: 0x000048C8
|
|
internal static void AddClient(NetworkClient client)
|
|
{
|
|
NetworkClient.s_Clients.Add(client);
|
|
}
|
|
|
|
// Token: 0x06000199 RID: 409 RVA: 0x000066D8 File Offset: 0x000048D8
|
|
internal static bool RemoveClient(NetworkClient client)
|
|
{
|
|
return NetworkClient.s_Clients.Remove(client);
|
|
}
|
|
|
|
// Token: 0x0600019A RID: 410 RVA: 0x000066F8 File Offset: 0x000048F8
|
|
internal static void UpdateClients()
|
|
{
|
|
for (int i = 0; i < NetworkClient.s_Clients.Count; i++)
|
|
{
|
|
if (NetworkClient.s_Clients[i] != null)
|
|
{
|
|
NetworkClient.s_Clients[i].Update();
|
|
}
|
|
else
|
|
{
|
|
NetworkClient.s_Clients.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600019B RID: 411 RVA: 0x00006753 File Offset: 0x00004953
|
|
public static void ShutdownAll()
|
|
{
|
|
while (NetworkClient.s_Clients.Count != 0)
|
|
{
|
|
NetworkClient.s_Clients[0].Shutdown();
|
|
}
|
|
NetworkClient.s_Clients = new List<NetworkClient>();
|
|
NetworkClient.s_IsActive = false;
|
|
ClientScene.Shutdown();
|
|
}
|
|
|
|
// Token: 0x0600019C RID: 412 RVA: 0x00006791 File Offset: 0x00004991
|
|
internal static void SetActive(bool state)
|
|
{
|
|
if (!NetworkClient.s_IsActive && state)
|
|
{
|
|
NetworkTransport.Init();
|
|
}
|
|
NetworkClient.s_IsActive = state;
|
|
}
|
|
|
|
// Token: 0x040000CF RID: 207
|
|
private Type m_NetworkConnectionClass = typeof(NetworkConnection);
|
|
|
|
// Token: 0x040000D0 RID: 208
|
|
private const int k_MaxEventsPerFrame = 500;
|
|
|
|
// Token: 0x040000D1 RID: 209
|
|
private static List<NetworkClient> s_Clients = new List<NetworkClient>();
|
|
|
|
// Token: 0x040000D2 RID: 210
|
|
private static bool s_IsActive;
|
|
|
|
// Token: 0x040000D3 RID: 211
|
|
private HostTopology m_HostTopology;
|
|
|
|
// Token: 0x040000D4 RID: 212
|
|
private int m_HostPort;
|
|
|
|
// Token: 0x040000D5 RID: 213
|
|
private bool m_UseSimulator;
|
|
|
|
// Token: 0x040000D6 RID: 214
|
|
private int m_SimulatedLatency;
|
|
|
|
// Token: 0x040000D7 RID: 215
|
|
private float m_PacketLoss;
|
|
|
|
// Token: 0x040000D8 RID: 216
|
|
private string m_ServerIp = "";
|
|
|
|
// Token: 0x040000D9 RID: 217
|
|
private int m_ServerPort;
|
|
|
|
// Token: 0x040000DA RID: 218
|
|
private int m_ClientId = -1;
|
|
|
|
// Token: 0x040000DB RID: 219
|
|
private int m_ClientConnectionId = -1;
|
|
|
|
// Token: 0x040000DC RID: 220
|
|
private int m_StatResetTime;
|
|
|
|
// Token: 0x040000DD RID: 221
|
|
private EndPoint m_RemoteEndPoint;
|
|
|
|
// Token: 0x040000DE RID: 222
|
|
private static CRCMessage s_CRCMessage = new CRCMessage();
|
|
|
|
// Token: 0x040000DF RID: 223
|
|
private NetworkMessageHandlers m_MessageHandlers = new NetworkMessageHandlers();
|
|
|
|
// Token: 0x040000E0 RID: 224
|
|
protected NetworkConnection m_Connection;
|
|
|
|
// Token: 0x040000E1 RID: 225
|
|
private byte[] m_MsgBuffer;
|
|
|
|
// Token: 0x040000E2 RID: 226
|
|
private NetworkReader m_MsgReader;
|
|
|
|
// Token: 0x040000E3 RID: 227
|
|
protected NetworkClient.ConnectState m_AsyncConnect = NetworkClient.ConnectState.None;
|
|
|
|
// Token: 0x040000E4 RID: 228
|
|
private string m_RequestedServerHost = "";
|
|
|
|
// Token: 0x0200003E RID: 62
|
|
protected enum ConnectState
|
|
{
|
|
// Token: 0x040000E8 RID: 232
|
|
None,
|
|
// Token: 0x040000E9 RID: 233
|
|
Resolving,
|
|
// Token: 0x040000EA RID: 234
|
|
Resolved,
|
|
// Token: 0x040000EB RID: 235
|
|
Connecting,
|
|
// Token: 0x040000EC RID: 236
|
|
Connected,
|
|
// Token: 0x040000ED RID: 237
|
|
Disconnected,
|
|
// Token: 0x040000EE RID: 238
|
|
Failed
|
|
}
|
|
}
|
|
}
|