diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/XClientNetwork.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XClientNetwork.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XClientNetwork.cs | 833 |
1 files changed, 833 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XClientNetwork.cs b/Client/Assets/Scripts/XMainClient/XClientNetwork.cs new file mode 100644 index 00000000..d9a755ff --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XClientNetwork.cs @@ -0,0 +1,833 @@ +using System;
+using System.Text;
+using KKSG;
+using ProtoBuf;
+using UILib;
+using UnityEngine;
+using XMainClient.UI;
+using XUpdater;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XClientNetwork : XSingleton<XClientNetwork>, INetObserver
+ {
+ private uint _server_id
+ {
+ get
+ {
+ return this.__server_id;
+ }
+ set
+ {
+ this.__server_id = value;
+ XFileLog.ServerID = value.ToString();
+ }
+ }
+
+ public XConnection XConnect
+ {
+ get
+ {
+ return this._connection;
+ }
+ }
+
+ public bool CloseOnServerErrorNtf
+ {
+ get
+ {
+ return this._close_on_server_error_ntf;
+ }
+ set
+ {
+ this._close_on_server_error_ntf = value;
+ }
+ }
+
+ public ulong Session
+ {
+ get
+ {
+ return this._session;
+ }
+ set
+ {
+ this._session = value;
+ }
+ }
+
+ public string XLoginToken
+ {
+ get
+ {
+ return this._loginToken;
+ }
+ set
+ {
+ this._loginToken = value;
+ }
+ }
+
+ public XLoginStep XLoginStep
+ {
+ get
+ {
+ return this._loginStep;
+ }
+ set
+ {
+ this._loginStep = value;
+ }
+ }
+
+ public string Server
+ {
+ get
+ {
+ return string.Format("{0} [{1}] ", this._serverName, this._zoneName);
+ }
+ }
+
+ public uint ServerID
+ {
+ get
+ {
+ return this._server_id;
+ }
+ }
+
+ public string ServerIP
+ {
+ get
+ {
+ return this._server_ip;
+ }
+ }
+
+ public uint ServerPort
+ {
+ get
+ {
+ return this._server_port;
+ }
+ }
+
+ public int RecvBytes
+ {
+ get
+ {
+ return this._network.RecvBytes;
+ }
+ }
+
+ public int SendBytes
+ {
+ get
+ {
+ return this._network.SendBytes;
+ }
+ }
+
+ public string OpenID
+ {
+ get
+ {
+ return this._openid;
+ }
+ }
+
+ public string OpenKey
+ {
+ get
+ {
+ return XSingleton<XLoginDocument>.singleton.TokenCache;
+ }
+ }
+
+ public LoginType AccountType
+ {
+ get
+ {
+ return this._loginType;
+ }
+ }
+
+ public string GameId
+ {
+ get
+ {
+ return "90";
+ }
+ }
+
+ public string AppId
+ {
+ get
+ {
+ bool flag = this.AccountType == LoginType.LOGIN_QQ_PF;
+ string result;
+ if (flag)
+ {
+ result = "1105309683";
+ }
+ else
+ {
+ bool flag2 = this.AccountType == LoginType.LGOIN_WECHAT_PF;
+ if (flag2)
+ {
+ result = "wxfdab5af74990787a";
+ }
+ else
+ {
+ result = null;
+ }
+ }
+ return result;
+ }
+ }
+
+ public string AppKey
+ {
+ get
+ {
+ bool flag = this.AccountType == LoginType.LOGIN_QQ_PF;
+ string result;
+ if (flag)
+ {
+ result = "xa0seqAScOhSsgrm";
+ }
+ else
+ {
+ bool flag2 = this.AccountType == LoginType.LGOIN_WECHAT_PF;
+ if (flag2)
+ {
+ result = "6dea891b19634f98e78d27edc74125bf";
+ }
+ else
+ {
+ result = null;
+ }
+ }
+ return result;
+ }
+ }
+
+ public string MSDKKey
+ {
+ get
+ {
+ return "02a8d5ed226237996eb3f448dfac0b1c";
+ }
+ }
+
+ public string AreaId
+ {
+ get
+ {
+ bool flag = this.AccountType == LoginType.LOGIN_QQ_PF;
+ string result;
+ if (flag)
+ {
+ result = XFastEnumIntEqualityComparer<GameAppType>.ToInt(GameAppType.GAME_APP_QQ).ToString();
+ }
+ else
+ {
+ bool flag2 = this.AccountType == LoginType.LGOIN_WECHAT_PF;
+ if (flag2)
+ {
+ result = XFastEnumIntEqualityComparer<GameAppType>.ToInt(GameAppType.GAME_APP_WECHAT).ToString();
+ }
+ else
+ {
+ result = null;
+ }
+ }
+ return result;
+ }
+ }
+
+ public string OpenCode
+ {
+ get
+ {
+ string text = null;
+ bool flag = this.AccountType == LoginType.LOGIN_QQ_PF;
+ if (flag)
+ {
+ text = "1";
+ }
+ bool flag2 = this.AccountType == LoginType.LGOIN_WECHAT_PF;
+ if (flag2)
+ {
+ text = "2";
+ }
+ byte[] bytes = Encoding.Default.GetBytes(string.Format("{0},{1},{2},{3}", new object[]
+ {
+ this.OpenID,
+ this.OpenKey,
+ this.AppId,
+ text
+ }));
+ return Convert.ToBase64String(bytes);
+ }
+ }
+
+ private CNetwork _network = null;
+
+ private ulong _session = 0UL;
+
+ private uint __server_id = 0u;
+
+ private string _server_ip = "";
+
+ private uint _server_port = 0u;
+
+ private string _serverName = "";
+
+ private string _zoneName = "";
+
+ private string _account;
+
+ private string _password;
+
+ private string _loginToken;
+
+ private string _openid;
+
+ private bool _close_on_server_error_ntf = false;
+
+ private bool _rpc_delayed_ntf = false;
+
+ private ErrorCode _last_error = ErrorCode.ERR_SUCCESS;
+
+ private XLoginStep _loginStep = XLoginStep.Begin;
+
+ private LoginType _loginType = LoginType.LOGIN_PASSWORD;
+
+ private XConnection _connection = null;
+
+ public bool Initialize()
+ {
+ this._loginStep = XLoginStep.Begin;
+ this._connection = new XConnection();
+ this._network = this._connection.Init(this);
+ XSingleton<XInterfaceMgr>.singleton.AttachInterface<CNetwork>(XSingleton<XCommon>.singleton.XHash("ILUANET"), this._network);
+ return this._network != null;
+ }
+
+ public bool IsConnected()
+ {
+ return this._network.GetSocketState() == SocketState.State_Connected;
+ }
+
+ public void ClearServerInfo()
+ {
+ this._server_id = 0u;
+ this._server_ip = "";
+ this._server_port = 0u;
+ this._serverName = "";
+ this._zoneName = "";
+ }
+
+ public void OnConnect(bool bSuccess)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Connection status: ", bSuccess ? "Connected" : "Disconnected", null, null, null, null, XDebugColor.XDebug_None);
+ if (bSuccess)
+ {
+ this.OnConnected();
+ }
+ else
+ {
+ this.OnDisconnected();
+ }
+ }
+
+ public void OnClosed(NetErrCode nErrCode)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Closed with: ", nErrCode.ToString(), " in state ", this._loginStep.ToString(), null, null, XDebugColor.XDebug_None);
+ bool flag = nErrCode == NetErrCode.Net_ConnectError;
+ if (flag)
+ {
+ this.OnConnect(false);
+ }
+ else
+ {
+ bool flag2 = nErrCode == NetErrCode.Net_NoError;
+ if (!flag2)
+ {
+ switch (this._loginStep)
+ {
+ case XLoginStep.Authorization:
+ {
+ NetErrCode netErrCode = nErrCode;
+ if (netErrCode != NetErrCode.Net_Rpc_Delay)
+ {
+ XSingleton<XLoginDocument>.singleton.OnAuthorizedFailed();
+ }
+ else
+ {
+ XSingleton<XLoginDocument>.singleton.OnAuthorizedTimeOut();
+ }
+ break;
+ }
+ case XLoginStep.Login:
+ {
+ NetErrCode netErrCode2 = nErrCode;
+ if (netErrCode2 != NetErrCode.Net_Rpc_Delay)
+ {
+ XSingleton<XLoginDocument>.singleton.OnLoginFailed(null);
+ }
+ else
+ {
+ XSingleton<XLoginDocument>.singleton.OnLoginTimeout();
+ }
+ break;
+ }
+ case XLoginStep.EnterGame:
+ {
+ NetErrCode netErrCode3 = nErrCode;
+ if (netErrCode3 != NetErrCode.Net_SysError)
+ {
+ if (netErrCode3 != NetErrCode.Net_Rpc_Delay)
+ {
+ XSingleton<XLoginDocument>.singleton.OnEnterWorldFailed(null);
+ }
+ else
+ {
+ XSingleton<XLoginDocument>.singleton.OnEnterWorldTimeOut();
+ }
+ }
+ else
+ {
+ this.OnServerErrorNotify(105u, null);
+ }
+ break;
+ }
+ case XLoginStep.Playing:
+ {
+ NetErrCode netErrCode4 = nErrCode;
+ if (netErrCode4 != NetErrCode.Net_SysError)
+ {
+ if (netErrCode4 - NetErrCode.Net_Rpc_Delay <= 1)
+ {
+ bool flag3 = !this._connection.OnReconnect;
+ if (flag3)
+ {
+ this._connection.Reconnect(this._server_ip, (int)this._server_port);
+ }
+ }
+ }
+ else
+ {
+ bool flag4 = !this._connection.OnReconnect;
+ if (flag4)
+ {
+ bool flag5 = !this._close_on_server_error_ntf;
+ if (flag5)
+ {
+ this._connection.Reconnect(this._server_ip, (int)this._server_port);
+ }
+ this._close_on_server_error_ntf = false;
+ }
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ public void OnReceive(uint dwType, int nLen)
+ {
+ }
+
+ public void Send(Protocol proto)
+ {
+ bool flag = !this._network.Send(proto);
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("send proto failed: ", proto.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+ }
+
+ public void Send(Rpc rpc)
+ {
+ rpc.SetTimeOut();
+ bool flag = !this._network.Send(rpc);
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("send rpc failed: ", rpc.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ rpc.CallTimeOut();
+ }
+ }
+
+ public void LuaSendRPC(uint _type, byte[] _reqBuff, DelLuaRespond _onRes, DelLuaError _onError)
+ {
+ bool flag = !this._network.LuaSendRPC(_type, _reqBuff, _onRes, _onError);
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("lua send rpc failed: ", _type.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+ }
+
+ public bool Authorization(LoginType t, string account, string password, string openid)
+ {
+ this._loginStep = XLoginStep.Authorization;
+ this._loginType = t;
+ this._account = account;
+ this._password = password;
+ this._openid = openid;
+ string loginServerAddress;
+ switch (this._loginType)
+ {
+ case LoginType.LOGIN_QQ_PF:
+ loginServerAddress = XSingleton<XCaching>.singleton.GetLoginServerAddress("QQ");
+ break;
+ case LoginType.LGOIN_WECHAT_PF:
+ loginServerAddress = XSingleton<XCaching>.singleton.GetLoginServerAddress("WeChat");
+ break;
+ case LoginType.LOGIN_IOS_GUEST:
+ loginServerAddress = XSingleton<XCaching>.singleton.GetLoginServerAddress("Guest");
+ break;
+ default:
+ loginServerAddress = XSingleton<XCaching>.singleton.GetLoginServerAddress("");
+ break;
+ }
+ string text = loginServerAddress.Substring(0, loginServerAddress.LastIndexOf(':'));
+ string text2 = loginServerAddress.Substring(loginServerAddress.LastIndexOf(':') + 1);
+ XSingleton<XDebug>.singleton.AddLog("login server ", text, " : ", text2, null, null, XDebugColor.XDebug_None);
+ return this.Connect(text, int.Parse(text2));
+ }
+
+ public bool OnAuthorized(QueryGateArg arg, QueryGateRes res)
+ {
+ bool result = false;
+ try
+ {
+ bool flag = res.loginToken.Length != 0;
+ if (flag)
+ {
+ this._loginStep = XLoginStep.Login;
+ LoginGateData recommandGate = res.RecommandGate;
+ XSingleton<XDebug>.singleton.AddLog("query gate ok [", recommandGate.ip, ":", recommandGate.port.ToString(), "] server ", recommandGate.serverid.ToString(), XDebugColor.XDebug_None);
+ bool flag2 = string.IsNullOrEmpty(this._server_ip);
+ if (flag2)
+ {
+ this._server_id = (uint)recommandGate.serverid;
+ this._server_ip = recommandGate.ip;
+ this._server_port = (uint)recommandGate.port;
+ this._serverName = recommandGate.servername;
+ this._zoneName = recommandGate.zonename;
+ }
+ bool flag3 = res.loginToken.Length >= 24 && res.loginToken[20] == 1;
+ if (flag3)
+ {
+ XSingleton<XGame>.singleton.IsGMAccount = true;
+ XSingleton<XDebug>.singleton.AddGreenLog("GM account Authorized", null, null, null, null, null);
+ }
+ else
+ {
+ XSingleton<XGame>.singleton.IsGMAccount = false;
+ }
+ this._loginToken = Convert.ToBase64String(res.loginToken);
+ result = true;
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddLog("query gate ip failed!", null, null, null, null, null, XDebugColor.XDebug_None);
+ result = false;
+ }
+ }
+ catch (Exception ex)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog(ex.Message, null, null, null, null, null);
+ return false;
+ }
+ this.Close(NetErrCode.Net_NoError);
+ return result;
+ }
+
+ public bool Login()
+ {
+ return this.Connect(this._server_ip, (int)this._server_port);
+ }
+
+ public void OnLogin()
+ {
+ XSingleton<XOperationRecord>.singleton.DoScriptRecord("login");
+ }
+
+ public bool OnServerChanged(ServerInfo data)
+ {
+ bool flag = this._server_id == (uint)data.ServerID;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ this._zoneName = data.ZoneName;
+ this._serverName = data.ServerName;
+ this._server_id = (uint)data.ServerID;
+ this._server_ip = data.Ip;
+ this._server_port = data.Port;
+ result = true;
+ }
+ return result;
+ }
+
+ public void OnFatalErrorCallback()
+ {
+ bool flag = this._loginStep == XLoginStep.Playing && XSingleton<XCutScene>.singleton.IsPlaying;
+ if (flag)
+ {
+ XSingleton<XCutScene>.singleton.Stop(true);
+ }
+ XSingleton<XLoginDocument>.singleton.OnError(null);
+ bool flag2 = this._last_error == ErrorCode.ERR_VERSION_FAILED;
+ if (flag2)
+ {
+ Application.Quit();
+ }
+ }
+
+ public void OnServerErrorNotify(uint code, string addtional = null)
+ {
+ this._last_error = (ErrorCode)code;
+ XLoginStep loginStep = this._loginStep;
+ if (loginStep != XLoginStep.Playing)
+ {
+ bool flag = this._last_error == ErrorCode.ERR_VERSION_FAILED;
+ if (flag)
+ {
+ bool sceneReady = XSingleton<XScene>.singleton.SceneReady;
+ if (sceneReady)
+ {
+ string[] array = XSingleton<XUpdater.XUpdater>.singleton.Version.Split(new char[]
+ {
+ '.'
+ });
+ string[] array2 = addtional.Split(new char[]
+ {
+ '.'
+ });
+ bool flag2 = array.Length > 1 && array2.Length > 1;
+ if (flag2)
+ {
+ bool flag3 = array[1] == array2[1];
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.OnFatalErrorClosed(string.Format(XStringDefineProxy.GetString(ErrorCode.ERR_VERSION_FAILED), addtional));
+ }
+ else
+ {
+ bool flag4 = int.Parse(array[1]) < int.Parse(array2[1]);
+ if (flag4)
+ {
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("NEED_TO_DOWNLOAD_CORRECT_PACKAGE"), XStringDefineProxy.GetString("COMMON_OK"), new ButtonClickEventHandler(XSingleton<UiUtility>.singleton.ToDownLoadCorrectPackage), 300);
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("NEED_TO_DOWNLOAD_CORRECT_PACKAGE"), XStringDefineProxy.GetString("COMMON_OK"), new ButtonClickEventHandler(XSingleton<UiUtility>.singleton.ToDownLoadCorrectPackagePre), 300);
+ }
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.OnFatalErrorClosed(string.Format(XStringDefineProxy.GetString(ErrorCode.ERR_VERSION_FAILED), addtional));
+ }
+ }
+ else
+ {
+ XSingleton<XScene>.singleton.Error = this._last_error;
+ XSingleton<XScene>.singleton.ErrorAddtional = addtional;
+ }
+ XSingleton<XLoginDocument>.singleton.OnError();
+ }
+ else
+ {
+ string @string = XStringDefineProxy.GetString(this._last_error);
+ XSingleton<XLoginDocument>.singleton.OnError(@string);
+ }
+ this.Close(NetErrCode.Net_NoError);
+ }
+ else
+ {
+ this._connection.StopReconnection();
+ this._close_on_server_error_ntf = !this.Close(NetErrCode.Net_SrvNtfError);
+ bool sceneReady2 = XSingleton<XScene>.singleton.SceneReady;
+ if (sceneReady2)
+ {
+ XSingleton<UiUtility>.singleton.OnFatalErrorClosed(this._last_error);
+ }
+ else
+ {
+ XSingleton<XScene>.singleton.Error = this._last_error;
+ }
+ }
+ }
+
+ private bool Connect(string IP, int Port)
+ {
+ bool flag = this._connection.Connet(IP, Port);
+ XLoginStep loginStep = this._loginStep;
+ if (loginStep != XLoginStep.Authorization)
+ {
+ if (loginStep == XLoginStep.Login)
+ {
+ bool flag2 = flag;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddLog("connecting to gate server.", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("connect to gate server failed!", null, null, null, null, null);
+ }
+ }
+ }
+ else
+ {
+ bool flag3 = flag;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddLog("connecting to login/authorization server.", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("connect to login/authorization server failed!", null, null, null, null, null);
+ }
+ }
+ return flag;
+ }
+
+ public bool Close(NetErrCode err = NetErrCode.Net_NoError)
+ {
+ return this._connection.Close(err);
+ }
+
+ public void Update()
+ {
+ this._connection.Update();
+ this._network.ProcessMsg();
+ XSingleton<XGameUI>.singleton.UpdateNetUI();
+ bool onRpcDelay = this._connection.OnRpcDelay;
+ if (onRpcDelay)
+ {
+ bool flag = !this._rpc_delayed_ntf && Rpc.RpcDelayedTime > Rpc.DelayThreshold + 1f && this._loginStep == XLoginStep.Playing;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("CHECKING_NETWORK"), "fece00");
+ this._rpc_delayed_ntf = true;
+ }
+ }
+ else
+ {
+ this._rpc_delayed_ntf = false;
+ }
+ }
+
+ private void OnConnected()
+ {
+ XLoginStep loginStep = this._loginStep;
+ if (loginStep == XLoginStep.Authorization)
+ {
+ RpcC2I_QueryGateIP rpcC2I_QueryGateIP = new RpcC2I_QueryGateIP();
+ rpcC2I_QueryGateIP.oArg.type = this._loginType;
+ rpcC2I_QueryGateIP.oArg.platid = PlatType.PLAT_ANDROID;
+ rpcC2I_QueryGateIP.oArg.version = XSingleton<XUpdater.XUpdater>.singleton.Version;
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8)
+ {
+ if ((int)platform == 11)
+ {
+ rpcC2I_QueryGateIP.oArg.platid = PlatType.PLAT_ANDROID;
+ }
+ }
+ else
+ {
+ rpcC2I_QueryGateIP.oArg.platid = PlatType.PLAT_IOS;
+ }
+ switch (this._loginType)
+ {
+ case LoginType.LOGIN_PASSWORD:
+ rpcC2I_QueryGateIP.oArg.account = this._account;
+ rpcC2I_QueryGateIP.oArg.password = this._password;
+ rpcC2I_QueryGateIP.oArg.openid = this._openid;
+ goto IL_18D;
+ case LoginType.LOGIN_QQ_PF:
+ rpcC2I_QueryGateIP.oArg.token = this._account;
+ rpcC2I_QueryGateIP.oArg.openid = this._openid;
+ goto IL_18D;
+ case LoginType.LGOIN_WECHAT_PF:
+ rpcC2I_QueryGateIP.oArg.token = this._account;
+ rpcC2I_QueryGateIP.oArg.openid = this._openid;
+ goto IL_18D;
+ case LoginType.LOGIN_IOS_GUEST:
+ rpcC2I_QueryGateIP.oArg.token = this._account;
+ rpcC2I_QueryGateIP.oArg.openid = this._openid;
+ goto IL_18D;
+ }
+ rpcC2I_QueryGateIP.oArg.token = this._account;
+ rpcC2I_QueryGateIP.oArg.pf = XSingleton<XUpdater.XUpdater>.singleton.XPlatform.GetPFToken();
+ IL_18D:
+ this.Send(rpcC2I_QueryGateIP);
+ }
+ }
+
+ private void OnDisconnected()
+ {
+ switch (this._loginStep)
+ {
+ case XLoginStep.Begin:
+ case XLoginStep.Authorization:
+ XSingleton<XLoginDocument>.singleton.OnAuthorizedConnectFailed();
+ break;
+ case XLoginStep.Login:
+ XSingleton<XLoginDocument>.singleton.OnLoginConnectFailed();
+ break;
+ case XLoginStep.EnterGame:
+ XSingleton<XLoginDocument>.singleton.OnEnterWorldFailed(XStringDefineProxy.GetString("CONNECT_SERVER_FAIL"));
+ break;
+ }
+ }
+
+ public bool IsConnectSignal()
+ {
+ return Application.internetReachability > 0;
+ }
+
+ public bool IsWifiEnable()
+ {
+ bool flag = Application.internetReachability == 0;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag2 = (int)Application.internetReachability == 2;
+ result = flag2;
+ }
+ return result;
+ }
+
+ public void OnGamePause(bool pause)
+ {
+ this._network.OnGamePaused(pause);
+ }
+
+ public void Clear()
+ {
+ Serializer.Clear();
+ bool flag = this._network != null;
+ if (flag)
+ {
+ this._network.Clear();
+ }
+ }
+ }
+}
|