using System;
using System.Collections.Generic;
using System.Net;
using UnityEngine.Networking.Match;
using UnityEngine.Networking.NetworkSystem;
using UnityEngine.Networking.Types;
using UnityEngine.SceneManagement;

namespace UnityEngine.Networking
{
	// Token: 0x0200004C RID: 76
	[AddComponentMenu("Network/NetworkManager")]
	public class NetworkManager : MonoBehaviour
	{
		// Token: 0x1700006A RID: 106
		// (get) Token: 0x060002AB RID: 683 RVA: 0x0000DB3C File Offset: 0x0000BD3C
		// (set) Token: 0x060002AC RID: 684 RVA: 0x0000DB57 File Offset: 0x0000BD57
		public int networkPort
		{
			get
			{
				return this.m_NetworkPort;
			}
			set
			{
				this.m_NetworkPort = value;
			}
		}

		// Token: 0x1700006B RID: 107
		// (get) Token: 0x060002AD RID: 685 RVA: 0x0000DB64 File Offset: 0x0000BD64
		// (set) Token: 0x060002AE RID: 686 RVA: 0x0000DB7F File Offset: 0x0000BD7F
		public bool serverBindToIP
		{
			get
			{
				return this.m_ServerBindToIP;
			}
			set
			{
				this.m_ServerBindToIP = value;
			}
		}

		// Token: 0x1700006C RID: 108
		// (get) Token: 0x060002AF RID: 687 RVA: 0x0000DB8C File Offset: 0x0000BD8C
		// (set) Token: 0x060002B0 RID: 688 RVA: 0x0000DBA7 File Offset: 0x0000BDA7
		public string serverBindAddress
		{
			get
			{
				return this.m_ServerBindAddress;
			}
			set
			{
				this.m_ServerBindAddress = value;
			}
		}

		// Token: 0x1700006D RID: 109
		// (get) Token: 0x060002B1 RID: 689 RVA: 0x0000DBB4 File Offset: 0x0000BDB4
		// (set) Token: 0x060002B2 RID: 690 RVA: 0x0000DBCF File Offset: 0x0000BDCF
		public string networkAddress
		{
			get
			{
				return this.m_NetworkAddress;
			}
			set
			{
				this.m_NetworkAddress = value;
			}
		}

		// Token: 0x1700006E RID: 110
		// (get) Token: 0x060002B3 RID: 691 RVA: 0x0000DBDC File Offset: 0x0000BDDC
		// (set) Token: 0x060002B4 RID: 692 RVA: 0x0000DBF7 File Offset: 0x0000BDF7
		public bool dontDestroyOnLoad
		{
			get
			{
				return this.m_DontDestroyOnLoad;
			}
			set
			{
				this.m_DontDestroyOnLoad = value;
			}
		}

		// Token: 0x1700006F RID: 111
		// (get) Token: 0x060002B5 RID: 693 RVA: 0x0000DC04 File Offset: 0x0000BE04
		// (set) Token: 0x060002B6 RID: 694 RVA: 0x0000DC1F File Offset: 0x0000BE1F
		public bool runInBackground
		{
			get
			{
				return this.m_RunInBackground;
			}
			set
			{
				this.m_RunInBackground = value;
			}
		}

		// Token: 0x17000070 RID: 112
		// (get) Token: 0x060002B7 RID: 695 RVA: 0x0000DC2C File Offset: 0x0000BE2C
		// (set) Token: 0x060002B8 RID: 696 RVA: 0x0000DC47 File Offset: 0x0000BE47
		public bool scriptCRCCheck
		{
			get
			{
				return this.m_ScriptCRCCheck;
			}
			set
			{
				this.m_ScriptCRCCheck = value;
			}
		}

		// Token: 0x17000071 RID: 113
		// (get) Token: 0x060002B9 RID: 697 RVA: 0x0000DC54 File Offset: 0x0000BE54
		// (set) Token: 0x060002BA RID: 698 RVA: 0x0000DC6A File Offset: 0x0000BE6A
		[Obsolete("moved to NetworkMigrationManager")]
		public bool sendPeerInfo
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		// Token: 0x17000072 RID: 114
		// (get) Token: 0x060002BB RID: 699 RVA: 0x0000DC70 File Offset: 0x0000BE70
		// (set) Token: 0x060002BC RID: 700 RVA: 0x0000DC8B File Offset: 0x0000BE8B
		public float maxDelay
		{
			get
			{
				return this.m_MaxDelay;
			}
			set
			{
				this.m_MaxDelay = value;
			}
		}

		// Token: 0x17000073 RID: 115
		// (get) Token: 0x060002BD RID: 701 RVA: 0x0000DC98 File Offset: 0x0000BE98
		// (set) Token: 0x060002BE RID: 702 RVA: 0x0000DCB3 File Offset: 0x0000BEB3
		public LogFilter.FilterLevel logLevel
		{
			get
			{
				return this.m_LogLevel;
			}
			set
			{
				this.m_LogLevel = value;
				LogFilter.currentLogLevel = (int)value;
			}
		}

		// Token: 0x17000074 RID: 116
		// (get) Token: 0x060002BF RID: 703 RVA: 0x0000DCC4 File Offset: 0x0000BEC4
		// (set) Token: 0x060002C0 RID: 704 RVA: 0x0000DCDF File Offset: 0x0000BEDF
		public GameObject playerPrefab
		{
			get
			{
				return this.m_PlayerPrefab;
			}
			set
			{
				this.m_PlayerPrefab = value;
			}
		}

		// Token: 0x17000075 RID: 117
		// (get) Token: 0x060002C1 RID: 705 RVA: 0x0000DCEC File Offset: 0x0000BEEC
		// (set) Token: 0x060002C2 RID: 706 RVA: 0x0000DD07 File Offset: 0x0000BF07
		public bool autoCreatePlayer
		{
			get
			{
				return this.m_AutoCreatePlayer;
			}
			set
			{
				this.m_AutoCreatePlayer = value;
			}
		}

		// Token: 0x17000076 RID: 118
		// (get) Token: 0x060002C3 RID: 707 RVA: 0x0000DD14 File Offset: 0x0000BF14
		// (set) Token: 0x060002C4 RID: 708 RVA: 0x0000DD2F File Offset: 0x0000BF2F
		public PlayerSpawnMethod playerSpawnMethod
		{
			get
			{
				return this.m_PlayerSpawnMethod;
			}
			set
			{
				this.m_PlayerSpawnMethod = value;
			}
		}

		// Token: 0x17000077 RID: 119
		// (get) Token: 0x060002C5 RID: 709 RVA: 0x0000DD3C File Offset: 0x0000BF3C
		// (set) Token: 0x060002C6 RID: 710 RVA: 0x0000DD57 File Offset: 0x0000BF57
		public string offlineScene
		{
			get
			{
				return this.m_OfflineScene;
			}
			set
			{
				this.m_OfflineScene = value;
			}
		}

		// Token: 0x17000078 RID: 120
		// (get) Token: 0x060002C7 RID: 711 RVA: 0x0000DD64 File Offset: 0x0000BF64
		// (set) Token: 0x060002C8 RID: 712 RVA: 0x0000DD7F File Offset: 0x0000BF7F
		public string onlineScene
		{
			get
			{
				return this.m_OnlineScene;
			}
			set
			{
				this.m_OnlineScene = value;
			}
		}

		// Token: 0x17000079 RID: 121
		// (get) Token: 0x060002C9 RID: 713 RVA: 0x0000DD8C File Offset: 0x0000BF8C
		public List<GameObject> spawnPrefabs
		{
			get
			{
				return this.m_SpawnPrefabs;
			}
		}

		// Token: 0x1700007A RID: 122
		// (get) Token: 0x060002CA RID: 714 RVA: 0x0000DDA8 File Offset: 0x0000BFA8
		public List<Transform> startPositions
		{
			get
			{
				return NetworkManager.s_StartPositions;
			}
		}

		// Token: 0x1700007B RID: 123
		// (get) Token: 0x060002CB RID: 715 RVA: 0x0000DDC4 File Offset: 0x0000BFC4
		// (set) Token: 0x060002CC RID: 716 RVA: 0x0000DDDF File Offset: 0x0000BFDF
		public bool customConfig
		{
			get
			{
				return this.m_CustomConfig;
			}
			set
			{
				this.m_CustomConfig = value;
			}
		}

		// Token: 0x1700007C RID: 124
		// (get) Token: 0x060002CD RID: 717 RVA: 0x0000DDEC File Offset: 0x0000BFEC
		public ConnectionConfig connectionConfig
		{
			get
			{
				if (this.m_ConnectionConfig == null)
				{
					this.m_ConnectionConfig = new ConnectionConfig();
				}
				return this.m_ConnectionConfig;
			}
		}

		// Token: 0x1700007D RID: 125
		// (get) Token: 0x060002CE RID: 718 RVA: 0x0000DE20 File Offset: 0x0000C020
		public GlobalConfig globalConfig
		{
			get
			{
				if (this.m_GlobalConfig == null)
				{
					this.m_GlobalConfig = new GlobalConfig();
				}
				return this.m_GlobalConfig;
			}
		}

		// Token: 0x1700007E RID: 126
		// (get) Token: 0x060002CF RID: 719 RVA: 0x0000DE54 File Offset: 0x0000C054
		// (set) Token: 0x060002D0 RID: 720 RVA: 0x0000DE6F File Offset: 0x0000C06F
		public int maxConnections
		{
			get
			{
				return this.m_MaxConnections;
			}
			set
			{
				this.m_MaxConnections = value;
			}
		}

		// Token: 0x1700007F RID: 127
		// (get) Token: 0x060002D1 RID: 721 RVA: 0x0000DE7C File Offset: 0x0000C07C
		public List<QosType> channels
		{
			get
			{
				return this.m_Channels;
			}
		}

		// Token: 0x17000080 RID: 128
		// (get) Token: 0x060002D2 RID: 722 RVA: 0x0000DE98 File Offset: 0x0000C098
		// (set) Token: 0x060002D3 RID: 723 RVA: 0x0000DEB3 File Offset: 0x0000C0B3
		public EndPoint secureTunnelEndpoint
		{
			get
			{
				return this.m_EndPoint;
			}
			set
			{
				this.m_EndPoint = value;
			}
		}

		// Token: 0x17000081 RID: 129
		// (get) Token: 0x060002D4 RID: 724 RVA: 0x0000DEC0 File Offset: 0x0000C0C0
		// (set) Token: 0x060002D5 RID: 725 RVA: 0x0000DEDB File Offset: 0x0000C0DB
		public bool useWebSockets
		{
			get
			{
				return this.m_UseWebSockets;
			}
			set
			{
				this.m_UseWebSockets = value;
			}
		}

		// Token: 0x17000082 RID: 130
		// (get) Token: 0x060002D6 RID: 726 RVA: 0x0000DEE8 File Offset: 0x0000C0E8
		// (set) Token: 0x060002D7 RID: 727 RVA: 0x0000DF03 File Offset: 0x0000C103
		public bool useSimulator
		{
			get
			{
				return this.m_UseSimulator;
			}
			set
			{
				this.m_UseSimulator = value;
			}
		}

		// Token: 0x17000083 RID: 131
		// (get) Token: 0x060002D8 RID: 728 RVA: 0x0000DF10 File Offset: 0x0000C110
		// (set) Token: 0x060002D9 RID: 729 RVA: 0x0000DF2B File Offset: 0x0000C12B
		public int simulatedLatency
		{
			get
			{
				return this.m_SimulatedLatency;
			}
			set
			{
				this.m_SimulatedLatency = value;
			}
		}

		// Token: 0x17000084 RID: 132
		// (get) Token: 0x060002DA RID: 730 RVA: 0x0000DF38 File Offset: 0x0000C138
		// (set) Token: 0x060002DB RID: 731 RVA: 0x0000DF53 File Offset: 0x0000C153
		public float packetLossPercentage
		{
			get
			{
				return this.m_PacketLossPercentage;
			}
			set
			{
				this.m_PacketLossPercentage = value;
			}
		}

		// Token: 0x17000085 RID: 133
		// (get) Token: 0x060002DC RID: 732 RVA: 0x0000DF60 File Offset: 0x0000C160
		// (set) Token: 0x060002DD RID: 733 RVA: 0x0000DF7B File Offset: 0x0000C17B
		public string matchHost
		{
			get
			{
				return this.m_MatchHost;
			}
			set
			{
				this.m_MatchHost = value;
			}
		}

		// Token: 0x17000086 RID: 134
		// (get) Token: 0x060002DE RID: 734 RVA: 0x0000DF88 File Offset: 0x0000C188
		// (set) Token: 0x060002DF RID: 735 RVA: 0x0000DFA3 File Offset: 0x0000C1A3
		public int matchPort
		{
			get
			{
				return this.m_MatchPort;
			}
			set
			{
				this.m_MatchPort = value;
			}
		}

		// Token: 0x17000087 RID: 135
		// (get) Token: 0x060002E0 RID: 736 RVA: 0x0000DFB0 File Offset: 0x0000C1B0
		// (set) Token: 0x060002E1 RID: 737 RVA: 0x0000DFCB File Offset: 0x0000C1CB
		public bool clientLoadedScene
		{
			get
			{
				return this.m_ClientLoadedScene;
			}
			set
			{
				this.m_ClientLoadedScene = value;
			}
		}

		// Token: 0x17000088 RID: 136
		// (get) Token: 0x060002E2 RID: 738 RVA: 0x0000DFD8 File Offset: 0x0000C1D8
		public NetworkMigrationManager migrationManager
		{
			get
			{
				return this.m_MigrationManager;
			}
		}

		// Token: 0x17000089 RID: 137
		// (get) Token: 0x060002E3 RID: 739 RVA: 0x0000DFF4 File Offset: 0x0000C1F4
		public int numPlayers
		{
			get
			{
				int num = 0;
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection networkConnection = NetworkServer.connections[i];
					if (networkConnection != null)
					{
						for (int j = 0; j < networkConnection.playerControllers.Count; j++)
						{
							if (networkConnection.playerControllers[j].IsValid)
							{
								num++;
							}
						}
					}
				}
				return num;
			}
		}

		// Token: 0x060002E4 RID: 740 RVA: 0x0000E07C File Offset: 0x0000C27C
		private void Awake()
		{
			this.InitializeSingleton();
		}

		// Token: 0x060002E5 RID: 741 RVA: 0x0000E088 File Offset: 0x0000C288
		private void InitializeSingleton()
		{
			if (!(NetworkManager.singleton != null) || !(NetworkManager.singleton == this))
			{
				int logLevel = (int)this.m_LogLevel;
				if (logLevel != -1)
				{
					LogFilter.currentLogLevel = logLevel;
				}
				if (this.m_DontDestroyOnLoad)
				{
					if (NetworkManager.singleton != null)
					{
						if (LogFilter.logDev)
						{
							Debug.Log("Multiple NetworkManagers detected in the scene. Only one NetworkManager can exist at a time. The duplicate NetworkManager will not be used.");
						}
						Object.Destroy(base.gameObject);
						return;
					}
					if (LogFilter.logDev)
					{
						Debug.Log("NetworkManager created singleton (DontDestroyOnLoad)");
					}
					NetworkManager.singleton = this;
					if (Application.isPlaying)
					{
						Object.DontDestroyOnLoad(base.gameObject);
					}
				}
				else
				{
					if (LogFilter.logDev)
					{
						Debug.Log("NetworkManager created singleton (ForScene)");
					}
					NetworkManager.singleton = this;
				}
				if (this.m_NetworkAddress != "")
				{
					NetworkManager.s_Address = this.m_NetworkAddress;
				}
				else if (NetworkManager.s_Address != "")
				{
					this.m_NetworkAddress = NetworkManager.s_Address;
				}
			}
		}

		// Token: 0x060002E6 RID: 742 RVA: 0x0000E1B4 File Offset: 0x0000C3B4
		private void OnValidate()
		{
			if (this.m_SimulatedLatency < 1)
			{
				this.m_SimulatedLatency = 1;
			}
			if (this.m_SimulatedLatency > 500)
			{
				this.m_SimulatedLatency = 500;
			}
			if (this.m_PacketLossPercentage < 0f)
			{
				this.m_PacketLossPercentage = 0f;
			}
			if (this.m_PacketLossPercentage > 99f)
			{
				this.m_PacketLossPercentage = 99f;
			}
			if (this.m_MaxConnections <= 0)
			{
				this.m_MaxConnections = 1;
			}
			if (this.m_MaxConnections > 32000)
			{
				this.m_MaxConnections = 32000;
			}
			if (this.m_MaxBufferedPackets <= 0)
			{
				this.m_MaxBufferedPackets = 0;
			}
			if (this.m_MaxBufferedPackets > 512)
			{
				this.m_MaxBufferedPackets = 512;
				if (LogFilter.logError)
				{
					Debug.LogError("NetworkManager - MaxBufferedPackets cannot be more than " + 512);
				}
			}
			if (this.m_PlayerPrefab != null && this.m_PlayerPrefab.GetComponent<NetworkIdentity>() == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("NetworkManager - playerPrefab must have a NetworkIdentity.");
				}
				this.m_PlayerPrefab = null;
			}
			if (this.m_ConnectionConfig.MinUpdateTimeout <= 0U)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("NetworkManager MinUpdateTimeout cannot be zero or less. The value will be reset to 1 millisecond");
				}
				this.m_ConnectionConfig.MinUpdateTimeout = 1U;
			}
			if (this.m_GlobalConfig != null)
			{
				if (this.m_GlobalConfig.ThreadAwakeTimeout <= 0U)
				{
					if (LogFilter.logError)
					{
						Debug.LogError("NetworkManager ThreadAwakeTimeout cannot be zero or less. The value will be reset to 1 millisecond");
					}
					this.m_GlobalConfig.ThreadAwakeTimeout = 1U;
				}
			}
		}

		// Token: 0x060002E7 RID: 743 RVA: 0x0000E368 File Offset: 0x0000C568
		internal void RegisterServerMessages()
		{
			NetworkServer.RegisterHandler(32, new NetworkMessageDelegate(this.OnServerConnectInternal));
			NetworkServer.RegisterHandler(33, new NetworkMessageDelegate(this.OnServerDisconnectInternal));
			NetworkServer.RegisterHandler(35, new NetworkMessageDelegate(this.OnServerReadyMessageInternal));
			NetworkServer.RegisterHandler(37, new NetworkMessageDelegate(this.OnServerAddPlayerMessageInternal));
			NetworkServer.RegisterHandler(38, new NetworkMessageDelegate(this.OnServerRemovePlayerMessageInternal));
			NetworkServer.RegisterHandler(34, new NetworkMessageDelegate(this.OnServerErrorInternal));
		}

		// Token: 0x060002E8 RID: 744 RVA: 0x0000E3E8 File Offset: 0x0000C5E8
		public void SetupMigrationManager(NetworkMigrationManager man)
		{
			this.m_MigrationManager = man;
		}

		// Token: 0x060002E9 RID: 745 RVA: 0x0000E3F4 File Offset: 0x0000C5F4
		public bool StartServer(ConnectionConfig config, int maxConnections)
		{
			return this.StartServer(null, config, maxConnections);
		}

		// Token: 0x060002EA RID: 746 RVA: 0x0000E414 File Offset: 0x0000C614
		public bool StartServer()
		{
			return this.StartServer(null);
		}

		// Token: 0x060002EB RID: 747 RVA: 0x0000E430 File Offset: 0x0000C630
		public bool StartServer(MatchInfo info)
		{
			return this.StartServer(info, null, -1);
		}

		// Token: 0x060002EC RID: 748 RVA: 0x0000E450 File Offset: 0x0000C650
		private bool StartServer(MatchInfo info, ConnectionConfig config, int maxConnections)
		{
			this.InitializeSingleton();
			this.OnStartServer();
			if (this.m_RunInBackground)
			{
				Application.runInBackground = true;
			}
			NetworkCRC.scriptCRCCheck = this.scriptCRCCheck;
			NetworkServer.useWebSockets = this.m_UseWebSockets;
			if (this.m_GlobalConfig != null)
			{
				NetworkTransport.Init(this.m_GlobalConfig);
			}
			if (this.m_CustomConfig && this.m_ConnectionConfig != null && config == null)
			{
				this.m_ConnectionConfig.Channels.Clear();
				for (int i = 0; i < this.m_Channels.Count; i++)
				{
					this.m_ConnectionConfig.AddChannel(this.m_Channels[i]);
				}
				NetworkServer.Configure(this.m_ConnectionConfig, this.m_MaxConnections);
			}
			if (config != null)
			{
				NetworkServer.Configure(config, maxConnections);
			}
			if (info != null)
			{
				if (!NetworkServer.Listen(info, this.m_NetworkPort))
				{
					if (LogFilter.logError)
					{
						Debug.LogError("StartServer listen failed.");
					}
					return false;
				}
			}
			else if (this.m_ServerBindToIP && !string.IsNullOrEmpty(this.m_ServerBindAddress))
			{
				if (!NetworkServer.Listen(this.m_ServerBindAddress, this.m_NetworkPort))
				{
					if (LogFilter.logError)
					{
						Debug.LogError("StartServer listen on " + this.m_ServerBindAddress + " failed.");
					}
					return false;
				}
			}
			else if (!NetworkServer.Listen(this.m_NetworkPort))
			{
				if (LogFilter.logError)
				{
					Debug.LogError("StartServer listen failed.");
				}
				return false;
			}
			this.RegisterServerMessages();
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager StartServer port:" + this.m_NetworkPort);
			}
			this.isNetworkActive = true;
			string name = SceneManager.GetSceneAt(0).name;
			if (!string.IsNullOrEmpty(this.m_OnlineScene) && this.m_OnlineScene != name && this.m_OnlineScene != this.m_OfflineScene)
			{
				this.ServerChangeScene(this.m_OnlineScene);
			}
			else
			{
				NetworkServer.SpawnObjects();
			}
			return true;
		}

		// Token: 0x060002ED RID: 749 RVA: 0x0000E6A0 File Offset: 0x0000C8A0
		internal void RegisterClientMessages(NetworkClient client)
		{
			client.RegisterHandler(32, new NetworkMessageDelegate(this.OnClientConnectInternal));
			client.RegisterHandler(33, new NetworkMessageDelegate(this.OnClientDisconnectInternal));
			client.RegisterHandler(36, new NetworkMessageDelegate(this.OnClientNotReadyMessageInternal));
			client.RegisterHandler(34, new NetworkMessageDelegate(this.OnClientErrorInternal));
			client.RegisterHandler(39, new NetworkMessageDelegate(this.OnClientSceneInternal));
			if (this.m_PlayerPrefab != null)
			{
				ClientScene.RegisterPrefab(this.m_PlayerPrefab);
			}
			for (int i = 0; i < this.m_SpawnPrefabs.Count; i++)
			{
				GameObject gameObject = this.m_SpawnPrefabs[i];
				if (gameObject != null)
				{
					ClientScene.RegisterPrefab(gameObject);
				}
			}
		}

		// Token: 0x060002EE RID: 750 RVA: 0x0000E770 File Offset: 0x0000C970
		public void UseExternalClient(NetworkClient externalClient)
		{
			if (this.m_RunInBackground)
			{
				Application.runInBackground = true;
			}
			if (externalClient != null)
			{
				this.client = externalClient;
				this.isNetworkActive = true;
				this.RegisterClientMessages(this.client);
				this.OnStartClient(this.client);
			}
			else
			{
				this.OnStopClient();
				ClientScene.DestroyAllClientObjects();
				ClientScene.HandleClientDisconnect(this.client.connection);
				this.client = null;
				if (!string.IsNullOrEmpty(this.m_OfflineScene))
				{
					this.ClientChangeScene(this.m_OfflineScene, false);
				}
			}
			NetworkManager.s_Address = this.m_NetworkAddress;
		}

		// Token: 0x060002EF RID: 751 RVA: 0x0000E810 File Offset: 0x0000CA10
		public NetworkClient StartClient(MatchInfo info, ConnectionConfig config, int hostPort)
		{
			this.InitializeSingleton();
			this.matchInfo = info;
			if (this.m_RunInBackground)
			{
				Application.runInBackground = true;
			}
			this.isNetworkActive = true;
			if (this.m_GlobalConfig != null)
			{
				NetworkTransport.Init(this.m_GlobalConfig);
			}
			this.client = new NetworkClient();
			this.client.hostPort = hostPort;
			if (config != null)
			{
				if (config.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4 && Application.platform != RuntimePlatform.PSP2)
				{
					throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
				}
				this.client.Configure(config, 1);
			}
			else if (this.m_CustomConfig && this.m_ConnectionConfig != null)
			{
				this.m_ConnectionConfig.Channels.Clear();
				for (int i = 0; i < this.m_Channels.Count; i++)
				{
					this.m_ConnectionConfig.AddChannel(this.m_Channels[i]);
				}
				if (this.m_ConnectionConfig.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4 && Application.platform != RuntimePlatform.PSP2)
				{
					throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
				}
				this.client.Configure(this.m_ConnectionConfig, this.m_MaxConnections);
			}
			this.RegisterClientMessages(this.client);
			if (this.matchInfo != null)
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("NetworkManager StartClient match: " + this.matchInfo);
				}
				this.client.Connect(this.matchInfo);
			}
			else if (this.m_EndPoint != null)
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("NetworkManager StartClient using provided SecureTunnel");
				}
				this.client.Connect(this.m_EndPoint);
			}
			else
			{
				if (string.IsNullOrEmpty(this.m_NetworkAddress))
				{
					if (LogFilter.logError)
					{
						Debug.LogError("Must set the Network Address field in the manager");
					}
					return null;
				}
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "NetworkManager StartClient address:", this.m_NetworkAddress, " port:", this.m_NetworkPort }));
				}
				if (this.m_UseSimulator)
				{
					this.client.ConnectWithSimulator(this.m_NetworkAddress, this.m_NetworkPort, this.m_SimulatedLatency, this.m_PacketLossPercentage);
				}
				else
				{
					this.client.Connect(this.m_NetworkAddress, this.m_NetworkPort);
				}
			}
			if (this.m_MigrationManager != null)
			{
				this.m_MigrationManager.Initialize(this.client, this.matchInfo);
			}
			this.OnStartClient(this.client);
			NetworkManager.s_Address = this.m_NetworkAddress;
			return this.client;
		}

		// Token: 0x060002F0 RID: 752 RVA: 0x0000EB00 File Offset: 0x0000CD00
		public NetworkClient StartClient(MatchInfo matchInfo)
		{
			return this.StartClient(matchInfo, null);
		}

		// Token: 0x060002F1 RID: 753 RVA: 0x0000EB20 File Offset: 0x0000CD20
		public NetworkClient StartClient()
		{
			return this.StartClient(null, null);
		}

		// Token: 0x060002F2 RID: 754 RVA: 0x0000EB40 File Offset: 0x0000CD40
		public NetworkClient StartClient(MatchInfo info, ConnectionConfig config)
		{
			return this.StartClient(info, config, 0);
		}

		// Token: 0x060002F3 RID: 755 RVA: 0x0000EB60 File Offset: 0x0000CD60
		public virtual NetworkClient StartHost(ConnectionConfig config, int maxConnections)
		{
			this.OnStartHost();
			NetworkClient networkClient2;
			if (this.StartServer(config, maxConnections))
			{
				NetworkClient networkClient = this.ConnectLocalClient();
				this.OnServerConnect(networkClient.connection);
				this.OnStartClient(networkClient);
				networkClient2 = networkClient;
			}
			else
			{
				networkClient2 = null;
			}
			return networkClient2;
		}

		// Token: 0x060002F4 RID: 756 RVA: 0x0000EBAC File Offset: 0x0000CDAC
		public virtual NetworkClient StartHost(MatchInfo info)
		{
			this.OnStartHost();
			this.matchInfo = info;
			NetworkClient networkClient2;
			if (this.StartServer(info))
			{
				NetworkClient networkClient = this.ConnectLocalClient();
				this.OnStartClient(networkClient);
				networkClient2 = networkClient;
			}
			else
			{
				networkClient2 = null;
			}
			return networkClient2;
		}

		// Token: 0x060002F5 RID: 757 RVA: 0x0000EBF4 File Offset: 0x0000CDF4
		public virtual NetworkClient StartHost()
		{
			this.OnStartHost();
			NetworkClient networkClient2;
			if (this.StartServer())
			{
				NetworkClient networkClient = this.ConnectLocalClient();
				this.OnStartClient(networkClient);
				networkClient2 = networkClient;
			}
			else
			{
				networkClient2 = null;
			}
			return networkClient2;
		}

		// Token: 0x060002F6 RID: 758 RVA: 0x0000EC34 File Offset: 0x0000CE34
		private NetworkClient ConnectLocalClient()
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager StartHost port:" + this.m_NetworkPort);
			}
			this.m_NetworkAddress = "localhost";
			this.client = ClientScene.ConnectLocalServer();
			this.RegisterClientMessages(this.client);
			if (this.m_MigrationManager != null)
			{
				this.m_MigrationManager.Initialize(this.client, this.matchInfo);
			}
			return this.client;
		}

		// Token: 0x060002F7 RID: 759 RVA: 0x0000ECC4 File Offset: 0x0000CEC4
		public void StopHost()
		{
			bool active = NetworkServer.active;
			this.OnStopHost();
			this.StopServer();
			this.StopClient();
			if (this.m_MigrationManager != null)
			{
				if (active)
				{
					this.m_MigrationManager.LostHostOnHost();
				}
			}
		}

		// Token: 0x060002F8 RID: 760 RVA: 0x0000ED10 File Offset: 0x0000CF10
		public void StopServer()
		{
			if (NetworkServer.active)
			{
				this.OnStopServer();
				if (LogFilter.logDebug)
				{
					Debug.Log("NetworkManager StopServer");
				}
				this.isNetworkActive = false;
				NetworkServer.Shutdown();
				this.StopMatchMaker();
				if (!string.IsNullOrEmpty(this.m_OfflineScene))
				{
					this.ServerChangeScene(this.m_OfflineScene);
				}
				this.CleanupNetworkIdentities();
			}
		}

		// Token: 0x060002F9 RID: 761 RVA: 0x0000ED80 File Offset: 0x0000CF80
		public void StopClient()
		{
			this.OnStopClient();
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager StopClient");
			}
			this.isNetworkActive = false;
			if (this.client != null)
			{
				this.client.Disconnect();
				this.client.Shutdown();
				this.client = null;
			}
			this.StopMatchMaker();
			ClientScene.DestroyAllClientObjects();
			if (!string.IsNullOrEmpty(this.m_OfflineScene))
			{
				this.ClientChangeScene(this.m_OfflineScene, false);
			}
			this.CleanupNetworkIdentities();
		}

		// Token: 0x060002FA RID: 762 RVA: 0x0000EE0C File Offset: 0x0000D00C
		public virtual void ServerChangeScene(string newSceneName)
		{
			if (string.IsNullOrEmpty(newSceneName))
			{
				if (LogFilter.logError)
				{
					Debug.LogError("ServerChangeScene empty scene name");
				}
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("ServerChangeScene " + newSceneName);
				}
				NetworkServer.SetAllClientsNotReady();
				NetworkManager.networkSceneName = newSceneName;
				NetworkManager.s_LoadingSceneAsync = SceneManager.LoadSceneAsync(newSceneName);
				StringMessage stringMessage = new StringMessage(NetworkManager.networkSceneName);
				NetworkServer.SendToAll(39, stringMessage);
				NetworkManager.s_StartPositionIndex = 0;
				NetworkManager.s_StartPositions.Clear();
			}
		}

		// Token: 0x060002FB RID: 763 RVA: 0x0000EE98 File Offset: 0x0000D098
		private void CleanupNetworkIdentities()
		{
			foreach (NetworkIdentity networkIdentity in Resources.FindObjectsOfTypeAll<NetworkIdentity>())
			{
				networkIdentity.MarkForReset();
			}
		}

		// Token: 0x060002FC RID: 764 RVA: 0x0000EED0 File Offset: 0x0000D0D0
		internal void ClientChangeScene(string newSceneName, bool forceReload)
		{
			if (string.IsNullOrEmpty(newSceneName))
			{
				if (LogFilter.logError)
				{
					Debug.LogError("ClientChangeScene empty scene name");
				}
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("ClientChangeScene newSceneName:" + newSceneName + " networkSceneName:" + NetworkManager.networkSceneName);
				}
				if (newSceneName == NetworkManager.networkSceneName)
				{
					if (this.m_MigrationManager != null)
					{
						this.FinishLoadScene();
						return;
					}
					if (!forceReload)
					{
						this.FinishLoadScene();
						return;
					}
				}
				NetworkManager.s_LoadingSceneAsync = SceneManager.LoadSceneAsync(newSceneName);
				NetworkManager.networkSceneName = newSceneName;
			}
		}

		// Token: 0x060002FD RID: 765 RVA: 0x0000EF80 File Offset: 0x0000D180
		private void FinishLoadScene()
		{
			if (this.client != null)
			{
				if (NetworkManager.s_ClientReadyConnection != null)
				{
					this.m_ClientLoadedScene = true;
					this.OnClientConnect(NetworkManager.s_ClientReadyConnection);
					NetworkManager.s_ClientReadyConnection = null;
				}
			}
			else if (LogFilter.logDev)
			{
				Debug.Log("FinishLoadScene client is null");
			}
			if (NetworkServer.active)
			{
				NetworkServer.SpawnObjects();
				this.OnServerSceneChanged(NetworkManager.networkSceneName);
			}
			if (this.IsClientConnected() && this.client != null)
			{
				this.RegisterClientMessages(this.client);
				this.OnClientSceneChanged(this.client.connection);
			}
		}

		// Token: 0x060002FE RID: 766 RVA: 0x0000F030 File Offset: 0x0000D230
		internal static void UpdateScene()
		{
			if (!(NetworkManager.singleton == null))
			{
				if (NetworkManager.s_LoadingSceneAsync != null)
				{
					if (NetworkManager.s_LoadingSceneAsync.isDone)
					{
						if (LogFilter.logDebug)
						{
							Debug.Log("ClientChangeScene done readyCon:" + NetworkManager.s_ClientReadyConnection);
						}
						NetworkManager.singleton.FinishLoadScene();
						NetworkManager.s_LoadingSceneAsync.allowSceneActivation = true;
						NetworkManager.s_LoadingSceneAsync = null;
					}
				}
			}
		}

		// Token: 0x060002FF RID: 767 RVA: 0x0000F0B1 File Offset: 0x0000D2B1
		private void OnDestroy()
		{
			if (LogFilter.logDev)
			{
				Debug.Log("NetworkManager destroyed");
			}
		}

		// Token: 0x06000300 RID: 768 RVA: 0x0000F0CA File Offset: 0x0000D2CA
		public static void RegisterStartPosition(Transform start)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("RegisterStartPosition:" + start);
			}
			NetworkManager.s_StartPositions.Add(start);
		}

		// Token: 0x06000301 RID: 769 RVA: 0x0000F0F4 File Offset: 0x0000D2F4
		public static void UnRegisterStartPosition(Transform start)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("UnRegisterStartPosition:" + start);
			}
			NetworkManager.s_StartPositions.Remove(start);
		}

		// Token: 0x06000302 RID: 770 RVA: 0x0000F120 File Offset: 0x0000D320
		public bool IsClientConnected()
		{
			return this.client != null && this.client.isConnected;
		}

		// Token: 0x06000303 RID: 771 RVA: 0x0000F14E File Offset: 0x0000D34E
		public static void Shutdown()
		{
			if (!(NetworkManager.singleton == null))
			{
				NetworkManager.s_StartPositions.Clear();
				NetworkManager.s_StartPositionIndex = 0;
				NetworkManager.s_ClientReadyConnection = null;
				NetworkManager.singleton.StopHost();
				NetworkManager.singleton = null;
			}
		}

		// Token: 0x06000304 RID: 772 RVA: 0x0000F18C File Offset: 0x0000D38C
		internal void OnServerConnectInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnServerConnectInternal");
			}
			netMsg.conn.SetMaxDelay(this.m_MaxDelay);
			if (this.m_MaxBufferedPackets != 512)
			{
				for (int i = 0; i < NetworkServer.numChannels; i++)
				{
					netMsg.conn.SetChannelOption(i, ChannelOption.MaxPendingBuffers, this.m_MaxBufferedPackets);
				}
			}
			if (!this.m_AllowFragmentation)
			{
				for (int j = 0; j < NetworkServer.numChannels; j++)
				{
					netMsg.conn.SetChannelOption(j, ChannelOption.AllowFragmentation, 0);
				}
			}
			if (NetworkManager.networkSceneName != "" && NetworkManager.networkSceneName != this.m_OfflineScene)
			{
				StringMessage stringMessage = new StringMessage(NetworkManager.networkSceneName);
				netMsg.conn.Send(39, stringMessage);
			}
			if (this.m_MigrationManager != null)
			{
				this.m_MigrationManager.SendPeerInfo();
			}
			this.OnServerConnect(netMsg.conn);
		}

		// Token: 0x06000305 RID: 773 RVA: 0x0000F2A4 File Offset: 0x0000D4A4
		internal void OnServerDisconnectInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnServerDisconnectInternal");
			}
			if (this.m_MigrationManager != null)
			{
				this.m_MigrationManager.SendPeerInfo();
			}
			this.OnServerDisconnect(netMsg.conn);
		}

		// Token: 0x06000306 RID: 774 RVA: 0x0000F2F2 File Offset: 0x0000D4F2
		internal void OnServerReadyMessageInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnServerReadyMessageInternal");
			}
			this.OnServerReady(netMsg.conn);
		}

		// Token: 0x06000307 RID: 775 RVA: 0x0000F318 File Offset: 0x0000D518
		internal void OnServerAddPlayerMessageInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnServerAddPlayerMessageInternal");
			}
			netMsg.ReadMessage<AddPlayerMessage>(NetworkManager.s_AddPlayerMessage);
			if (NetworkManager.s_AddPlayerMessage.msgSize != 0)
			{
				NetworkReader networkReader = new NetworkReader(NetworkManager.s_AddPlayerMessage.msgData);
				this.OnServerAddPlayer(netMsg.conn, NetworkManager.s_AddPlayerMessage.playerControllerId, networkReader);
			}
			else
			{
				this.OnServerAddPlayer(netMsg.conn, NetworkManager.s_AddPlayerMessage.playerControllerId);
			}
			if (this.m_MigrationManager != null)
			{
				this.m_MigrationManager.SendPeerInfo();
			}
		}

		// Token: 0x06000308 RID: 776 RVA: 0x0000F3BC File Offset: 0x0000D5BC
		internal void OnServerRemovePlayerMessageInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnServerRemovePlayerMessageInternal");
			}
			netMsg.ReadMessage<RemovePlayerMessage>(NetworkManager.s_RemovePlayerMessage);
			PlayerController playerController;
			netMsg.conn.GetPlayerController(NetworkManager.s_RemovePlayerMessage.playerControllerId, out playerController);
			this.OnServerRemovePlayer(netMsg.conn, playerController);
			netMsg.conn.RemovePlayerController(NetworkManager.s_RemovePlayerMessage.playerControllerId);
			if (this.m_MigrationManager != null)
			{
				this.m_MigrationManager.SendPeerInfo();
			}
		}

		// Token: 0x06000309 RID: 777 RVA: 0x0000F443 File Offset: 0x0000D643
		internal void OnServerErrorInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnServerErrorInternal");
			}
			netMsg.ReadMessage<ErrorMessage>(NetworkManager.s_ErrorMessage);
			this.OnServerError(netMsg.conn, NetworkManager.s_ErrorMessage.errorCode);
		}

		// Token: 0x0600030A RID: 778 RVA: 0x0000F480 File Offset: 0x0000D680
		internal void OnClientConnectInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnClientConnectInternal");
			}
			netMsg.conn.SetMaxDelay(this.m_MaxDelay);
			string name = SceneManager.GetSceneAt(0).name;
			if (string.IsNullOrEmpty(this.m_OnlineScene) || this.m_OnlineScene == this.m_OfflineScene || name == this.m_OnlineScene)
			{
				this.m_ClientLoadedScene = false;
				this.OnClientConnect(netMsg.conn);
			}
			else
			{
				NetworkManager.s_ClientReadyConnection = netMsg.conn;
			}
		}

		// Token: 0x0600030B RID: 779 RVA: 0x0000F524 File Offset: 0x0000D724
		internal void OnClientDisconnectInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnClientDisconnectInternal");
			}
			if (this.m_MigrationManager != null)
			{
				if (this.m_MigrationManager.LostHostOnClient(netMsg.conn))
				{
					return;
				}
			}
			if (!string.IsNullOrEmpty(this.m_OfflineScene))
			{
				this.ClientChangeScene(this.m_OfflineScene, false);
			}
			if (this.matchMaker != null && this.matchInfo != null && this.matchInfo.networkId != NetworkID.Invalid && this.matchInfo.nodeId != NodeID.Invalid)
			{
				this.matchMaker.DropConnection(this.matchInfo.networkId, this.matchInfo.nodeId, this.matchInfo.domain, new NetworkMatch.BasicResponseDelegate(this.OnDropConnection));
			}
			this.OnClientDisconnect(netMsg.conn);
		}

		// Token: 0x0600030C RID: 780 RVA: 0x0000F61C File Offset: 0x0000D81C
		internal void OnClientNotReadyMessageInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnClientNotReadyMessageInternal");
			}
			ClientScene.SetNotReady();
			this.OnClientNotReady(netMsg.conn);
		}

		// Token: 0x0600030D RID: 781 RVA: 0x0000F646 File Offset: 0x0000D846
		internal void OnClientErrorInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnClientErrorInternal");
			}
			netMsg.ReadMessage<ErrorMessage>(NetworkManager.s_ErrorMessage);
			this.OnClientError(netMsg.conn, NetworkManager.s_ErrorMessage.errorCode);
		}

		// Token: 0x0600030E RID: 782 RVA: 0x0000F680 File Offset: 0x0000D880
		internal void OnClientSceneInternal(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager:OnClientSceneInternal");
			}
			string text = netMsg.reader.ReadString();
			if (this.IsClientConnected() && !NetworkServer.active)
			{
				this.ClientChangeScene(text, true);
			}
		}

		// Token: 0x0600030F RID: 783 RVA: 0x0000F6CF File Offset: 0x0000D8CF
		public virtual void OnServerConnect(NetworkConnection conn)
		{
		}

		// Token: 0x06000310 RID: 784 RVA: 0x0000F6D2 File Offset: 0x0000D8D2
		public virtual void OnServerDisconnect(NetworkConnection conn)
		{
			NetworkServer.DestroyPlayersForConnection(conn);
			if (conn.lastError != NetworkError.Ok)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("ServerDisconnected due to error: " + conn.lastError);
				}
			}
		}

		// Token: 0x06000311 RID: 785 RVA: 0x0000F70E File Offset: 0x0000D90E
		public virtual void OnServerReady(NetworkConnection conn)
		{
			if (conn.playerControllers.Count == 0)
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("Ready with no player object");
				}
			}
			NetworkServer.SetClientReady(conn);
		}

		// Token: 0x06000312 RID: 786 RVA: 0x0000F73F File Offset: 0x0000D93F
		public virtual void OnServerAddPlayer(NetworkConnection conn, short playerControllerId, NetworkReader extraMessageReader)
		{
			this.OnServerAddPlayerInternal(conn, playerControllerId);
		}

		// Token: 0x06000313 RID: 787 RVA: 0x0000F74A File Offset: 0x0000D94A
		public virtual void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
		{
			this.OnServerAddPlayerInternal(conn, playerControllerId);
		}

		// Token: 0x06000314 RID: 788 RVA: 0x0000F758 File Offset: 0x0000D958
		private void OnServerAddPlayerInternal(NetworkConnection conn, short playerControllerId)
		{
			if (this.m_PlayerPrefab == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("The PlayerPrefab is empty on the NetworkManager. Please setup a PlayerPrefab object.");
				}
			}
			else if (this.m_PlayerPrefab.GetComponent<NetworkIdentity>() == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("The PlayerPrefab does not have a NetworkIdentity. Please add a NetworkIdentity to the player prefab.");
				}
			}
			else if ((int)playerControllerId < conn.playerControllers.Count && conn.playerControllers[(int)playerControllerId].IsValid && conn.playerControllers[(int)playerControllerId].gameObject != null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("There is already a player at that playerControllerId for this connections.");
				}
			}
			else
			{
				Transform startPosition = this.GetStartPosition();
				GameObject gameObject;
				if (startPosition != null)
				{
					gameObject = Object.Instantiate<GameObject>(this.m_PlayerPrefab, startPosition.position, startPosition.rotation);
				}
				else
				{
					gameObject = Object.Instantiate<GameObject>(this.m_PlayerPrefab, Vector3.zero, Quaternion.identity);
				}
				NetworkServer.AddPlayerForConnection(conn, gameObject, playerControllerId);
			}
		}

		// Token: 0x06000315 RID: 789 RVA: 0x0000F878 File Offset: 0x0000DA78
		public Transform GetStartPosition()
		{
			if (NetworkManager.s_StartPositions.Count > 0)
			{
				for (int i = NetworkManager.s_StartPositions.Count - 1; i >= 0; i--)
				{
					if (NetworkManager.s_StartPositions[i] == null)
					{
						NetworkManager.s_StartPositions.RemoveAt(i);
					}
				}
			}
			Transform transform;
			if (this.m_PlayerSpawnMethod == PlayerSpawnMethod.Random && NetworkManager.s_StartPositions.Count > 0)
			{
				int num = Random.Range(0, NetworkManager.s_StartPositions.Count);
				transform = NetworkManager.s_StartPositions[num];
			}
			else if (this.m_PlayerSpawnMethod == PlayerSpawnMethod.RoundRobin && NetworkManager.s_StartPositions.Count > 0)
			{
				if (NetworkManager.s_StartPositionIndex >= NetworkManager.s_StartPositions.Count)
				{
					NetworkManager.s_StartPositionIndex = 0;
				}
				Transform transform2 = NetworkManager.s_StartPositions[NetworkManager.s_StartPositionIndex];
				NetworkManager.s_StartPositionIndex++;
				transform = transform2;
			}
			else
			{
				transform = null;
			}
			return transform;
		}

		// Token: 0x06000316 RID: 790 RVA: 0x0000F97A File Offset: 0x0000DB7A
		public virtual void OnServerRemovePlayer(NetworkConnection conn, PlayerController player)
		{
			if (player.gameObject != null)
			{
				NetworkServer.Destroy(player.gameObject);
			}
		}

		// Token: 0x06000317 RID: 791 RVA: 0x0000F99B File Offset: 0x0000DB9B
		public virtual void OnServerError(NetworkConnection conn, int errorCode)
		{
		}

		// Token: 0x06000318 RID: 792 RVA: 0x0000F99E File Offset: 0x0000DB9E
		public virtual void OnServerSceneChanged(string sceneName)
		{
		}

		// Token: 0x06000319 RID: 793 RVA: 0x0000F9A1 File Offset: 0x0000DBA1
		public virtual void OnClientConnect(NetworkConnection conn)
		{
			if (!this.clientLoadedScene)
			{
				ClientScene.Ready(conn);
				if (this.m_AutoCreatePlayer)
				{
					ClientScene.AddPlayer(0);
				}
			}
		}

		// Token: 0x0600031A RID: 794 RVA: 0x0000F9CC File Offset: 0x0000DBCC
		public virtual void OnClientDisconnect(NetworkConnection conn)
		{
			this.StopClient();
			if (conn.lastError != NetworkError.Ok)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("ClientDisconnected due to error: " + conn.lastError);
				}
			}
		}

		// Token: 0x0600031B RID: 795 RVA: 0x0000FA08 File Offset: 0x0000DC08
		public virtual void OnClientError(NetworkConnection conn, int errorCode)
		{
		}

		// Token: 0x0600031C RID: 796 RVA: 0x0000FA0B File Offset: 0x0000DC0B
		public virtual void OnClientNotReady(NetworkConnection conn)
		{
		}

		// Token: 0x0600031D RID: 797 RVA: 0x0000FA10 File Offset: 0x0000DC10
		public virtual void OnClientSceneChanged(NetworkConnection conn)
		{
			ClientScene.Ready(conn);
			if (this.m_AutoCreatePlayer)
			{
				bool flag = ClientScene.localPlayers.Count == 0;
				bool flag2 = false;
				for (int i = 0; i < ClientScene.localPlayers.Count; i++)
				{
					if (ClientScene.localPlayers[i].gameObject != null)
					{
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					flag = true;
				}
				if (flag)
				{
					ClientScene.AddPlayer(0);
				}
			}
		}

		// Token: 0x0600031E RID: 798 RVA: 0x0000FA9F File Offset: 0x0000DC9F
		public void StartMatchMaker()
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkManager StartMatchMaker");
			}
			this.SetMatchHost(this.m_MatchHost, this.m_MatchPort, this.m_MatchPort == 443);
		}

		// Token: 0x0600031F RID: 799 RVA: 0x0000FAD8 File Offset: 0x0000DCD8
		public void StopMatchMaker()
		{
			if (this.matchMaker != null && this.matchInfo != null && this.matchInfo.networkId != NetworkID.Invalid && this.matchInfo.nodeId != NodeID.Invalid)
			{
				this.matchMaker.DropConnection(this.matchInfo.networkId, this.matchInfo.nodeId, this.matchInfo.domain, new NetworkMatch.BasicResponseDelegate(this.OnDropConnection));
			}
			if (this.matchMaker != null)
			{
				Object.Destroy(this.matchMaker);
				this.matchMaker = null;
			}
			this.matchInfo = null;
			this.matches = null;
		}

		// Token: 0x06000320 RID: 800 RVA: 0x0000FB94 File Offset: 0x0000DD94
		public void SetMatchHost(string newHost, int port, bool https)
		{
			if (this.matchMaker == null)
			{
				this.matchMaker = base.gameObject.AddComponent<NetworkMatch>();
			}
			if (newHost == "127.0.0.1")
			{
				newHost = "localhost";
			}
			string text = "http://";
			if (https)
			{
				text = "https://";
			}
			if (newHost.StartsWith("http://"))
			{
				newHost = newHost.Replace("http://", "");
			}
			if (newHost.StartsWith("https://"))
			{
				newHost = newHost.Replace("https://", "");
			}
			this.m_MatchHost = newHost;
			this.m_MatchPort = port;
			string text2 = string.Concat(new object[] { text, this.m_MatchHost, ":", this.m_MatchPort });
			if (LogFilter.logDebug)
			{
				Debug.Log("SetMatchHost:" + text2);
			}
			this.matchMaker.baseUri = new Uri(text2);
		}

		// Token: 0x06000321 RID: 801 RVA: 0x0000FCA5 File Offset: 0x0000DEA5
		public virtual void OnStartHost()
		{
		}

		// Token: 0x06000322 RID: 802 RVA: 0x0000FCA8 File Offset: 0x0000DEA8
		public virtual void OnStartServer()
		{
		}

		// Token: 0x06000323 RID: 803 RVA: 0x0000FCAB File Offset: 0x0000DEAB
		public virtual void OnStartClient(NetworkClient client)
		{
		}

		// Token: 0x06000324 RID: 804 RVA: 0x0000FCAE File Offset: 0x0000DEAE
		public virtual void OnStopServer()
		{
		}

		// Token: 0x06000325 RID: 805 RVA: 0x0000FCB1 File Offset: 0x0000DEB1
		public virtual void OnStopClient()
		{
		}

		// Token: 0x06000326 RID: 806 RVA: 0x0000FCB4 File Offset: 0x0000DEB4
		public virtual void OnStopHost()
		{
		}

		// Token: 0x06000327 RID: 807 RVA: 0x0000FCB7 File Offset: 0x0000DEB7
		public virtual void OnMatchCreate(bool success, string extendedInfo, MatchInfo matchInfo)
		{
			if (LogFilter.logDebug)
			{
				Debug.LogFormat("NetworkManager OnMatchCreate Success:{0}, ExtendedInfo:{1}, matchInfo:{2}", new object[] { success, extendedInfo, matchInfo });
			}
			if (success)
			{
				this.StartHost(matchInfo);
			}
		}

		// Token: 0x06000328 RID: 808 RVA: 0x0000FCF8 File Offset: 0x0000DEF8
		public virtual void OnMatchList(bool success, string extendedInfo, List<MatchInfoSnapshot> matchList)
		{
			if (LogFilter.logDebug)
			{
				Debug.LogFormat("NetworkManager OnMatchList Success:{0}, ExtendedInfo:{1}, matchList.Count:{2}", new object[] { success, extendedInfo, matchList.Count });
			}
			this.matches = matchList;
		}

		// Token: 0x06000329 RID: 809 RVA: 0x0000FD44 File Offset: 0x0000DF44
		public virtual void OnMatchJoined(bool success, string extendedInfo, MatchInfo matchInfo)
		{
			if (LogFilter.logDebug)
			{
				Debug.LogFormat("NetworkManager OnMatchJoined Success:{0}, ExtendedInfo:{1}, matchInfo:{2}", new object[] { success, extendedInfo, matchInfo });
			}
			if (success)
			{
				this.StartClient(matchInfo);
			}
		}

		// Token: 0x0600032A RID: 810 RVA: 0x0000FD82 File Offset: 0x0000DF82
		public virtual void OnDestroyMatch(bool success, string extendedInfo)
		{
			if (LogFilter.logDebug)
			{
				Debug.LogFormat("NetworkManager OnDestroyMatch Success:{0}, ExtendedInfo:{1}", new object[] { success, extendedInfo });
			}
		}

		// Token: 0x0600032B RID: 811 RVA: 0x0000FDAE File Offset: 0x0000DFAE
		public virtual void OnDropConnection(bool success, string extendedInfo)
		{
			if (LogFilter.logDebug)
			{
				Debug.LogFormat("NetworkManager OnDropConnection Success:{0}, ExtendedInfo:{1}", new object[] { success, extendedInfo });
			}
		}

		// Token: 0x0600032C RID: 812 RVA: 0x0000FDDA File Offset: 0x0000DFDA
		public virtual void OnSetMatchAttributes(bool success, string extendedInfo)
		{
			if (LogFilter.logDebug)
			{
				Debug.LogFormat("NetworkManager OnSetMatchAttributes Success:{0}, ExtendedInfo:{1}", new object[] { success, extendedInfo });
			}
		}

		// Token: 0x04000159 RID: 345
		[SerializeField]
		private int m_NetworkPort = 7777;

		// Token: 0x0400015A RID: 346
		[SerializeField]
		private bool m_ServerBindToIP;

		// Token: 0x0400015B RID: 347
		[SerializeField]
		private string m_ServerBindAddress = "";

		// Token: 0x0400015C RID: 348
		[SerializeField]
		private string m_NetworkAddress = "localhost";

		// Token: 0x0400015D RID: 349
		[SerializeField]
		private bool m_DontDestroyOnLoad = true;

		// Token: 0x0400015E RID: 350
		[SerializeField]
		private bool m_RunInBackground = true;

		// Token: 0x0400015F RID: 351
		[SerializeField]
		private bool m_ScriptCRCCheck = true;

		// Token: 0x04000160 RID: 352
		[SerializeField]
		private float m_MaxDelay = 0.01f;

		// Token: 0x04000161 RID: 353
		[SerializeField]
		private LogFilter.FilterLevel m_LogLevel = LogFilter.FilterLevel.Info;

		// Token: 0x04000162 RID: 354
		[SerializeField]
		private GameObject m_PlayerPrefab;

		// Token: 0x04000163 RID: 355
		[SerializeField]
		private bool m_AutoCreatePlayer = true;

		// Token: 0x04000164 RID: 356
		[SerializeField]
		private PlayerSpawnMethod m_PlayerSpawnMethod;

		// Token: 0x04000165 RID: 357
		[SerializeField]
		private string m_OfflineScene = "";

		// Token: 0x04000166 RID: 358
		[SerializeField]
		private string m_OnlineScene = "";

		// Token: 0x04000167 RID: 359
		[SerializeField]
		private List<GameObject> m_SpawnPrefabs = new List<GameObject>();

		// Token: 0x04000168 RID: 360
		[SerializeField]
		private bool m_CustomConfig;

		// Token: 0x04000169 RID: 361
		[SerializeField]
		private int m_MaxConnections = 4;

		// Token: 0x0400016A RID: 362
		[SerializeField]
		private ConnectionConfig m_ConnectionConfig;

		// Token: 0x0400016B RID: 363
		[SerializeField]
		private GlobalConfig m_GlobalConfig;

		// Token: 0x0400016C RID: 364
		[SerializeField]
		private List<QosType> m_Channels = new List<QosType>();

		// Token: 0x0400016D RID: 365
		[SerializeField]
		private bool m_UseWebSockets;

		// Token: 0x0400016E RID: 366
		[SerializeField]
		private bool m_UseSimulator;

		// Token: 0x0400016F RID: 367
		[SerializeField]
		private int m_SimulatedLatency = 1;

		// Token: 0x04000170 RID: 368
		[SerializeField]
		private float m_PacketLossPercentage;

		// Token: 0x04000171 RID: 369
		[SerializeField]
		private int m_MaxBufferedPackets = 16;

		// Token: 0x04000172 RID: 370
		[SerializeField]
		private bool m_AllowFragmentation = true;

		// Token: 0x04000173 RID: 371
		[SerializeField]
		private string m_MatchHost = "mm.unet.unity3d.com";

		// Token: 0x04000174 RID: 372
		[SerializeField]
		private int m_MatchPort = 443;

		// Token: 0x04000175 RID: 373
		[SerializeField]
		public string matchName = "default";

		// Token: 0x04000176 RID: 374
		[SerializeField]
		public uint matchSize = 4U;

		// Token: 0x04000177 RID: 375
		private NetworkMigrationManager m_MigrationManager;

		// Token: 0x04000178 RID: 376
		private EndPoint m_EndPoint;

		// Token: 0x04000179 RID: 377
		private bool m_ClientLoadedScene;

		// Token: 0x0400017A RID: 378
		public static string networkSceneName = "";

		// Token: 0x0400017B RID: 379
		public bool isNetworkActive;

		// Token: 0x0400017C RID: 380
		public NetworkClient client;

		// Token: 0x0400017D RID: 381
		private static List<Transform> s_StartPositions = new List<Transform>();

		// Token: 0x0400017E RID: 382
		private static int s_StartPositionIndex;

		// Token: 0x0400017F RID: 383
		public MatchInfo matchInfo;

		// Token: 0x04000180 RID: 384
		public NetworkMatch matchMaker;

		// Token: 0x04000181 RID: 385
		public List<MatchInfoSnapshot> matches;

		// Token: 0x04000182 RID: 386
		public static NetworkManager singleton;

		// Token: 0x04000183 RID: 387
		private static AddPlayerMessage s_AddPlayerMessage = new AddPlayerMessage();

		// Token: 0x04000184 RID: 388
		private static RemovePlayerMessage s_RemovePlayerMessage = new RemovePlayerMessage();

		// Token: 0x04000185 RID: 389
		private static ErrorMessage s_ErrorMessage = new ErrorMessage();

		// Token: 0x04000186 RID: 390
		private static AsyncOperation s_LoadingSceneAsync;

		// Token: 0x04000187 RID: 391
		private static NetworkConnection s_ClientReadyConnection;

		// Token: 0x04000188 RID: 392
		private static string s_Address;
	}
}