using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using UnityEngine.Networking.Match;
using UnityEngine.Networking.NetworkSystem;
using UnityEngine.Networking.Types;

namespace UnityEngine.Networking
{
	// Token: 0x02000058 RID: 88
	public sealed class NetworkServer
	{
		// Token: 0x060003BE RID: 958 RVA: 0x0001565C File Offset: 0x0001385C
		private NetworkServer()
		{
			NetworkTransport.Init();
			if (LogFilter.logDev)
			{
				Debug.Log("NetworkServer Created version " + Version.Current);
			}
			this.m_RemoveList = new HashSet<NetworkInstanceId>();
			this.m_ExternalConnections = new HashSet<int>();
			this.m_NetworkScene = new NetworkScene();
			this.m_SimpleServerSimple = new NetworkServer.ServerSimpleWrapper(this);
		}

		// Token: 0x1700009F RID: 159
		// (get) Token: 0x060003BF RID: 959 RVA: 0x000156E0 File Offset: 0x000138E0
		public static List<NetworkConnection> localConnections
		{
			get
			{
				return NetworkServer.instance.m_LocalConnectionsFakeList;
			}
		}

		// Token: 0x170000A0 RID: 160
		// (get) Token: 0x060003C0 RID: 960 RVA: 0x00015700 File Offset: 0x00013900
		public static int listenPort
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.listenPort;
			}
		}

		// Token: 0x170000A1 RID: 161
		// (get) Token: 0x060003C1 RID: 961 RVA: 0x00015724 File Offset: 0x00013924
		public static int serverHostId
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.serverHostId;
			}
		}

		// Token: 0x170000A2 RID: 162
		// (get) Token: 0x060003C2 RID: 962 RVA: 0x00015748 File Offset: 0x00013948
		public static ReadOnlyCollection<NetworkConnection> connections
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.connections;
			}
		}

		// Token: 0x170000A3 RID: 163
		// (get) Token: 0x060003C3 RID: 963 RVA: 0x0001576C File Offset: 0x0001396C
		public static Dictionary<short, NetworkMessageDelegate> handlers
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.handlers;
			}
		}

		// Token: 0x170000A4 RID: 164
		// (get) Token: 0x060003C4 RID: 964 RVA: 0x00015790 File Offset: 0x00013990
		public static HostTopology hostTopology
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.hostTopology;
			}
		}

		// Token: 0x170000A5 RID: 165
		// (get) Token: 0x060003C5 RID: 965 RVA: 0x000157B4 File Offset: 0x000139B4
		public static Dictionary<NetworkInstanceId, NetworkIdentity> objects
		{
			get
			{
				return NetworkServer.instance.m_NetworkScene.localObjects;
			}
		}

		// Token: 0x170000A6 RID: 166
		// (get) Token: 0x060003C6 RID: 966 RVA: 0x000157D8 File Offset: 0x000139D8
		// (set) Token: 0x060003C7 RID: 967 RVA: 0x000157EE File Offset: 0x000139EE
		[Obsolete("Moved to NetworkMigrationManager")]
		public static bool sendPeerInfo
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		// Token: 0x170000A7 RID: 167
		// (get) Token: 0x060003C8 RID: 968 RVA: 0x000157F4 File Offset: 0x000139F4
		// (set) Token: 0x060003C9 RID: 969 RVA: 0x0001580E File Offset: 0x00013A0E
		public static bool dontListen
		{
			get
			{
				return NetworkServer.m_DontListen;
			}
			set
			{
				NetworkServer.m_DontListen = value;
			}
		}

		// Token: 0x170000A8 RID: 168
		// (get) Token: 0x060003CA RID: 970 RVA: 0x00015818 File Offset: 0x00013A18
		// (set) Token: 0x060003CB RID: 971 RVA: 0x0001583C File Offset: 0x00013A3C
		public static bool useWebSockets
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.useWebSockets;
			}
			set
			{
				NetworkServer.instance.m_SimpleServerSimple.useWebSockets = value;
			}
		}

		// Token: 0x170000A9 RID: 169
		// (get) Token: 0x060003CC RID: 972 RVA: 0x00015850 File Offset: 0x00013A50
		internal static NetworkServer instance
		{
			get
			{
				if (NetworkServer.s_Instance == null)
				{
					object obj = NetworkServer.s_Sync;
					lock (obj)
					{
						if (NetworkServer.s_Instance == null)
						{
							NetworkServer.s_Instance = new NetworkServer();
						}
					}
				}
				return NetworkServer.s_Instance;
			}
		}

		// Token: 0x170000AA RID: 170
		// (get) Token: 0x060003CD RID: 973 RVA: 0x000158C0 File Offset: 0x00013AC0
		public static bool active
		{
			get
			{
				return NetworkServer.s_Active;
			}
		}

		// Token: 0x170000AB RID: 171
		// (get) Token: 0x060003CE RID: 974 RVA: 0x000158DC File Offset: 0x00013ADC
		public static bool localClientActive
		{
			get
			{
				return NetworkServer.instance.m_LocalClientActive;
			}
		}

		// Token: 0x170000AC RID: 172
		// (get) Token: 0x060003CF RID: 975 RVA: 0x000158FC File Offset: 0x00013AFC
		public static int numChannels
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.hostTopology.DefaultConfig.ChannelCount;
			}
		}

		// Token: 0x170000AD RID: 173
		// (get) Token: 0x060003D0 RID: 976 RVA: 0x0001592C File Offset: 0x00013B2C
		// (set) Token: 0x060003D1 RID: 977 RVA: 0x0001594B File Offset: 0x00013B4B
		public static float maxDelay
		{
			get
			{
				return NetworkServer.instance.m_MaxDelay;
			}
			set
			{
				NetworkServer.instance.InternalSetMaxDelay(value);
			}
		}

		// Token: 0x170000AE RID: 174
		// (get) Token: 0x060003D2 RID: 978 RVA: 0x0001595C File Offset: 0x00013B5C
		public static Type networkConnectionClass
		{
			get
			{
				return NetworkServer.instance.m_SimpleServerSimple.networkConnectionClass;
			}
		}

		// Token: 0x060003D3 RID: 979 RVA: 0x00015980 File Offset: 0x00013B80
		public static void SetNetworkConnectionClass<T>() where T : NetworkConnection
		{
			NetworkServer.instance.m_SimpleServerSimple.SetNetworkConnectionClass<T>();
		}

		// Token: 0x060003D4 RID: 980 RVA: 0x00015994 File Offset: 0x00013B94
		public static bool Configure(ConnectionConfig config, int maxConnections)
		{
			return NetworkServer.instance.m_SimpleServerSimple.Configure(config, maxConnections);
		}

		// Token: 0x060003D5 RID: 981 RVA: 0x000159BC File Offset: 0x00013BBC
		public static bool Configure(HostTopology topology)
		{
			return NetworkServer.instance.m_SimpleServerSimple.Configure(topology);
		}

		// Token: 0x060003D6 RID: 982 RVA: 0x000159E1 File Offset: 0x00013BE1
		public static void Reset()
		{
			NetworkTransport.Shutdown();
			NetworkTransport.Init();
			NetworkServer.s_Instance = null;
			NetworkServer.s_Active = false;
		}

		// Token: 0x060003D7 RID: 983 RVA: 0x000159FC File Offset: 0x00013BFC
		public static void Shutdown()
		{
			if (NetworkServer.s_Instance != null)
			{
				NetworkServer.s_Instance.InternalDisconnectAll();
				if (!NetworkServer.m_DontListen)
				{
					NetworkServer.s_Instance.m_SimpleServerSimple.Stop();
				}
				NetworkServer.s_Instance = null;
			}
			NetworkServer.m_DontListen = false;
			NetworkServer.s_Active = false;
		}

		// Token: 0x060003D8 RID: 984 RVA: 0x00015A5C File Offset: 0x00013C5C
		public static bool Listen(MatchInfo matchInfo, int listenPort)
		{
			bool flag;
			if (!matchInfo.usingRelay)
			{
				flag = NetworkServer.instance.InternalListen(null, listenPort);
			}
			else
			{
				NetworkServer.instance.InternalListenRelay(matchInfo.address, matchInfo.port, matchInfo.networkId, Utility.GetSourceID(), matchInfo.nodeId);
				flag = true;
			}
			return flag;
		}

		// Token: 0x060003D9 RID: 985 RVA: 0x00015AB8 File Offset: 0x00013CB8
		internal void RegisterMessageHandlers()
		{
			this.m_SimpleServerSimple.RegisterHandlerSafe(35, new NetworkMessageDelegate(NetworkServer.OnClientReadyMessage));
			this.m_SimpleServerSimple.RegisterHandlerSafe(5, new NetworkMessageDelegate(NetworkServer.OnCommandMessage));
			this.m_SimpleServerSimple.RegisterHandlerSafe(6, new NetworkMessageDelegate(NetworkTransform.HandleTransform));
			this.m_SimpleServerSimple.RegisterHandlerSafe(16, new NetworkMessageDelegate(NetworkTransformChild.HandleChildTransform));
			this.m_SimpleServerSimple.RegisterHandlerSafe(38, new NetworkMessageDelegate(NetworkServer.OnRemovePlayerMessage));
			this.m_SimpleServerSimple.RegisterHandlerSafe(40, new NetworkMessageDelegate(NetworkAnimator.OnAnimationServerMessage));
			this.m_SimpleServerSimple.RegisterHandlerSafe(41, new NetworkMessageDelegate(NetworkAnimator.OnAnimationParametersServerMessage));
			this.m_SimpleServerSimple.RegisterHandlerSafe(42, new NetworkMessageDelegate(NetworkAnimator.OnAnimationTriggerServerMessage));
			this.m_SimpleServerSimple.RegisterHandlerSafe(17, new NetworkMessageDelegate(NetworkConnection.OnFragment));
			NetworkServer.maxPacketSize = NetworkServer.hostTopology.DefaultConfig.PacketSize;
		}

		// Token: 0x060003DA RID: 986 RVA: 0x00015C52 File Offset: 0x00013E52
		public static void ListenRelay(string relayIp, int relayPort, NetworkID netGuid, SourceID sourceId, NodeID nodeId)
		{
			NetworkServer.instance.InternalListenRelay(relayIp, relayPort, netGuid, sourceId, nodeId);
		}

		// Token: 0x060003DB RID: 987 RVA: 0x00015C65 File Offset: 0x00013E65
		private void InternalListenRelay(string relayIp, int relayPort, NetworkID netGuid, SourceID sourceId, NodeID nodeId)
		{
			this.m_SimpleServerSimple.ListenRelay(relayIp, relayPort, netGuid, sourceId, nodeId);
			NetworkServer.s_Active = true;
			this.RegisterMessageHandlers();
		}

		// Token: 0x060003DC RID: 988 RVA: 0x00015C88 File Offset: 0x00013E88
		public static bool Listen(int serverPort)
		{
			return NetworkServer.instance.InternalListen(null, serverPort);
		}

		// Token: 0x060003DD RID: 989 RVA: 0x00015CAC File Offset: 0x00013EAC
		public static bool Listen(string ipAddress, int serverPort)
		{
			return NetworkServer.instance.InternalListen(ipAddress, serverPort);
		}

		// Token: 0x060003DE RID: 990 RVA: 0x00015CD0 File Offset: 0x00013ED0
		internal bool InternalListen(string ipAddress, int serverPort)
		{
			if (NetworkServer.m_DontListen)
			{
				this.m_SimpleServerSimple.Initialize();
			}
			else if (!this.m_SimpleServerSimple.Listen(ipAddress, serverPort))
			{
				return false;
			}
			NetworkServer.maxPacketSize = NetworkServer.hostTopology.DefaultConfig.PacketSize;
			NetworkServer.s_Active = true;
			this.RegisterMessageHandlers();
			return true;
		}

		// Token: 0x060003DF RID: 991 RVA: 0x00015D40 File Offset: 0x00013F40
		public static NetworkClient BecomeHost(NetworkClient oldClient, int port, MatchInfo matchInfo, int oldConnectionId, PeerInfoMessage[] peers)
		{
			return NetworkServer.instance.BecomeHostInternal(oldClient, port, matchInfo, oldConnectionId, peers);
		}

		// Token: 0x060003E0 RID: 992 RVA: 0x00015D68 File Offset: 0x00013F68
		internal NetworkClient BecomeHostInternal(NetworkClient oldClient, int port, MatchInfo matchInfo, int oldConnectionId, PeerInfoMessage[] peers)
		{
			NetworkClient networkClient;
			if (NetworkServer.s_Active)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("BecomeHost already a server.");
				}
				networkClient = null;
			}
			else if (!NetworkClient.active)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("BecomeHost NetworkClient not active.");
				}
				networkClient = null;
			}
			else
			{
				NetworkServer.Configure(NetworkServer.hostTopology);
				if (matchInfo == null)
				{
					if (LogFilter.logDev)
					{
						Debug.Log("BecomeHost Listen on " + port);
					}
					if (!NetworkServer.Listen(port))
					{
						if (LogFilter.logError)
						{
							Debug.LogError("BecomeHost bind failed.");
						}
						return null;
					}
				}
				else
				{
					if (LogFilter.logDev)
					{
						Debug.Log("BecomeHost match:" + matchInfo.networkId);
					}
					NetworkServer.ListenRelay(matchInfo.address, matchInfo.port, matchInfo.networkId, Utility.GetSourceID(), matchInfo.nodeId);
				}
				foreach (NetworkIdentity networkIdentity in ClientScene.objects.Values)
				{
					if (!(networkIdentity == null) && !(networkIdentity.gameObject == null))
					{
						NetworkIdentity.AddNetworkId(networkIdentity.netId.Value);
						this.m_NetworkScene.SetLocalObject(networkIdentity.netId, networkIdentity.gameObject, false, false);
						networkIdentity.OnStartServer(true);
					}
				}
				if (LogFilter.logDev)
				{
					Debug.Log("NetworkServer BecomeHost done. oldConnectionId:" + oldConnectionId);
				}
				this.RegisterMessageHandlers();
				if (!NetworkClient.RemoveClient(oldClient))
				{
					if (LogFilter.logError)
					{
						Debug.LogError("BecomeHost failed to remove client");
					}
				}
				if (LogFilter.logDev)
				{
					Debug.Log("BecomeHost localClient ready");
				}
				NetworkClient networkClient2 = ClientScene.ReconnectLocalServer();
				ClientScene.Ready(networkClient2.connection);
				ClientScene.SetReconnectId(oldConnectionId, peers);
				ClientScene.AddPlayer(ClientScene.readyConnection, 0);
				networkClient = networkClient2;
			}
			return networkClient;
		}

		// Token: 0x060003E1 RID: 993 RVA: 0x00015FAC File Offset: 0x000141AC
		private void InternalSetMaxDelay(float seconds)
		{
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					networkConnection.SetMaxDelay(seconds);
				}
			}
			this.m_MaxDelay = seconds;
		}

		// Token: 0x060003E2 RID: 994 RVA: 0x00015FF8 File Offset: 0x000141F8
		internal int AddLocalClient(LocalClient localClient)
		{
			int num;
			if (this.m_LocalConnectionsFakeList.Count != 0)
			{
				Debug.LogError("Local Connection already exists");
				num = -1;
			}
			else
			{
				this.m_LocalConnection = new ULocalConnectionToClient(localClient);
				this.m_LocalConnection.connectionId = 0;
				this.m_SimpleServerSimple.SetConnectionAtIndex(this.m_LocalConnection);
				this.m_LocalConnectionsFakeList.Add(this.m_LocalConnection);
				this.m_LocalConnection.InvokeHandlerNoData(32);
				num = 0;
			}
			return num;
		}

		// Token: 0x060003E3 RID: 995 RVA: 0x0001607C File Offset: 0x0001427C
		internal void RemoveLocalClient(NetworkConnection localClientConnection)
		{
			for (int i = 0; i < this.m_LocalConnectionsFakeList.Count; i++)
			{
				if (this.m_LocalConnectionsFakeList[i].connectionId == localClientConnection.connectionId)
				{
					this.m_LocalConnectionsFakeList.RemoveAt(i);
					break;
				}
			}
			if (this.m_LocalConnection != null)
			{
				this.m_LocalConnection.Disconnect();
				this.m_LocalConnection.Dispose();
				this.m_LocalConnection = null;
			}
			this.m_LocalClientActive = false;
			this.m_SimpleServerSimple.RemoveConnectionAtIndex(0);
		}

		// Token: 0x060003E4 RID: 996 RVA: 0x00016114 File Offset: 0x00014314
		internal void SetLocalObjectOnServer(NetworkInstanceId netId, GameObject obj)
		{
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[] { "SetLocalObjectOnServer ", netId, " ", obj }));
			}
			this.m_NetworkScene.SetLocalObject(netId, obj, false, true);
		}

		// Token: 0x060003E5 RID: 997 RVA: 0x0001616C File Offset: 0x0001436C
		internal void ActivateLocalClientScene()
		{
			if (!this.m_LocalClientActive)
			{
				this.m_LocalClientActive = true;
				foreach (NetworkIdentity networkIdentity in NetworkServer.objects.Values)
				{
					if (!networkIdentity.isClient)
					{
						if (LogFilter.logDev)
						{
							Debug.Log(string.Concat(new object[] { "ActivateClientScene ", networkIdentity.netId, " ", networkIdentity.gameObject }));
						}
						ClientScene.SetLocalObject(networkIdentity.netId, networkIdentity.gameObject);
						networkIdentity.OnStartClient();
					}
				}
			}
		}

		// Token: 0x060003E6 RID: 998 RVA: 0x00016248 File Offset: 0x00014448
		public static bool SendToAll(short msgType, MessageBase msg)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("Server.SendToAll msgType:" + msgType);
			}
			bool flag = true;
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					flag &= networkConnection.Send(msgType, msg);
				}
			}
			return flag;
		}

		// Token: 0x060003E7 RID: 999 RVA: 0x000162BC File Offset: 0x000144BC
		private static bool SendToObservers(GameObject contextObj, short msgType, MessageBase msg)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("Server.SendToObservers id:" + msgType);
			}
			bool flag = true;
			NetworkIdentity component = contextObj.GetComponent<NetworkIdentity>();
			bool flag2;
			if (component == null || component.observers == null)
			{
				flag2 = false;
			}
			else
			{
				int count = component.observers.Count;
				for (int i = 0; i < count; i++)
				{
					NetworkConnection networkConnection = component.observers[i];
					flag &= networkConnection.Send(msgType, msg);
				}
				flag2 = flag;
			}
			return flag2;
		}

		// Token: 0x060003E8 RID: 1000 RVA: 0x0001635C File Offset: 0x0001455C
		public static bool SendToReady(GameObject contextObj, short msgType, MessageBase msg)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("Server.SendToReady id:" + msgType);
			}
			bool flag;
			if (contextObj == null)
			{
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection networkConnection = NetworkServer.connections[i];
					if (networkConnection != null && networkConnection.isReady)
					{
						networkConnection.Send(msgType, msg);
					}
				}
				flag = true;
			}
			else
			{
				bool flag2 = true;
				NetworkIdentity component = contextObj.GetComponent<NetworkIdentity>();
				if (component == null || component.observers == null)
				{
					flag = false;
				}
				else
				{
					int count = component.observers.Count;
					for (int j = 0; j < count; j++)
					{
						NetworkConnection networkConnection2 = component.observers[j];
						if (networkConnection2.isReady)
						{
							flag2 &= networkConnection2.Send(msgType, msg);
						}
					}
					flag = flag2;
				}
			}
			return flag;
		}

		// Token: 0x060003E9 RID: 1001 RVA: 0x0001646C File Offset: 0x0001466C
		public static void SendWriterToReady(GameObject contextObj, NetworkWriter writer, int channelId)
		{
			if (writer.AsArraySegment().Count > 32767)
			{
				throw new UnityException("NetworkWriter used buffer is too big!");
			}
			NetworkServer.SendBytesToReady(contextObj, writer.AsArraySegment().Array, writer.AsArraySegment().Count, channelId);
		}

		// Token: 0x060003EA RID: 1002 RVA: 0x000164C4 File Offset: 0x000146C4
		public static void SendBytesToReady(GameObject contextObj, byte[] buffer, int numBytes, int channelId)
		{
			if (contextObj == null)
			{
				bool flag = true;
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection networkConnection = NetworkServer.connections[i];
					if (networkConnection != null && networkConnection.isReady)
					{
						if (!networkConnection.SendBytes(buffer, numBytes, channelId))
						{
							flag = false;
						}
					}
				}
				if (!flag)
				{
					if (LogFilter.logWarn)
					{
						Debug.LogWarning("SendBytesToReady failed");
					}
				}
			}
			else
			{
				NetworkIdentity component = contextObj.GetComponent<NetworkIdentity>();
				try
				{
					bool flag2 = true;
					int count = component.observers.Count;
					for (int j = 0; j < count; j++)
					{
						NetworkConnection networkConnection2 = component.observers[j];
						if (networkConnection2.isReady)
						{
							if (!networkConnection2.SendBytes(buffer, numBytes, channelId))
							{
								flag2 = false;
							}
						}
					}
					if (!flag2)
					{
						if (LogFilter.logWarn)
						{
							Debug.LogWarning("SendBytesToReady failed for " + contextObj);
						}
					}
				}
				catch (NullReferenceException)
				{
					if (LogFilter.logWarn)
					{
						Debug.LogWarning("SendBytesToReady object " + contextObj + " has not been spawned");
					}
				}
			}
		}

		// Token: 0x060003EB RID: 1003 RVA: 0x0001661C File Offset: 0x0001481C
		public static void SendBytesToPlayer(GameObject player, byte[] buffer, int numBytes, int channelId)
		{
			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 && networkConnection.playerControllers[j].gameObject == player)
						{
							networkConnection.SendBytes(buffer, numBytes, channelId);
							break;
						}
					}
				}
			}
		}

		// Token: 0x060003EC RID: 1004 RVA: 0x000166C0 File Offset: 0x000148C0
		public static bool SendUnreliableToAll(short msgType, MessageBase msg)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("Server.SendUnreliableToAll msgType:" + msgType);
			}
			bool flag = true;
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					flag &= networkConnection.SendUnreliable(msgType, msg);
				}
			}
			return flag;
		}

		// Token: 0x060003ED RID: 1005 RVA: 0x00016734 File Offset: 0x00014934
		public static bool SendUnreliableToReady(GameObject contextObj, short msgType, MessageBase msg)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("Server.SendUnreliableToReady id:" + msgType);
			}
			bool flag;
			if (contextObj == null)
			{
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection networkConnection = NetworkServer.connections[i];
					if (networkConnection != null && networkConnection.isReady)
					{
						networkConnection.SendUnreliable(msgType, msg);
					}
				}
				flag = true;
			}
			else
			{
				bool flag2 = true;
				NetworkIdentity component = contextObj.GetComponent<NetworkIdentity>();
				int count = component.observers.Count;
				for (int j = 0; j < count; j++)
				{
					NetworkConnection networkConnection2 = component.observers[j];
					if (networkConnection2.isReady)
					{
						flag2 &= networkConnection2.SendUnreliable(msgType, msg);
					}
				}
				flag = flag2;
			}
			return flag;
		}

		// Token: 0x060003EE RID: 1006 RVA: 0x00016824 File Offset: 0x00014A24
		public static bool SendByChannelToAll(short msgType, MessageBase msg, int channelId)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("Server.SendByChannelToAll id:" + msgType);
			}
			bool flag = true;
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					flag &= networkConnection.SendByChannel(msgType, msg, channelId);
				}
			}
			return flag;
		}

		// Token: 0x060003EF RID: 1007 RVA: 0x00016898 File Offset: 0x00014A98
		public static bool SendByChannelToReady(GameObject contextObj, short msgType, MessageBase msg, int channelId)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("Server.SendByChannelToReady msgType:" + msgType);
			}
			bool flag;
			if (contextObj == null)
			{
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection networkConnection = NetworkServer.connections[i];
					if (networkConnection != null && networkConnection.isReady)
					{
						networkConnection.SendByChannel(msgType, msg, channelId);
					}
				}
				flag = true;
			}
			else
			{
				bool flag2 = true;
				NetworkIdentity component = contextObj.GetComponent<NetworkIdentity>();
				int count = component.observers.Count;
				for (int j = 0; j < count; j++)
				{
					NetworkConnection networkConnection2 = component.observers[j];
					if (networkConnection2.isReady)
					{
						flag2 &= networkConnection2.SendByChannel(msgType, msg, channelId);
					}
				}
				flag = flag2;
			}
			return flag;
		}

		// Token: 0x060003F0 RID: 1008 RVA: 0x00016988 File Offset: 0x00014B88
		public static void DisconnectAll()
		{
			NetworkServer.instance.InternalDisconnectAll();
		}

		// Token: 0x060003F1 RID: 1009 RVA: 0x00016995 File Offset: 0x00014B95
		internal void InternalDisconnectAll()
		{
			this.m_SimpleServerSimple.DisconnectAllConnections();
			if (this.m_LocalConnection != null)
			{
				this.m_LocalConnection.Disconnect();
				this.m_LocalConnection.Dispose();
				this.m_LocalConnection = null;
			}
			this.m_LocalClientActive = false;
		}

		// Token: 0x060003F2 RID: 1010 RVA: 0x000169D4 File Offset: 0x00014BD4
		internal static void Update()
		{
			if (NetworkServer.s_Instance != null)
			{
				NetworkServer.s_Instance.InternalUpdate();
			}
		}

		// Token: 0x060003F3 RID: 1011 RVA: 0x000169F0 File Offset: 0x00014BF0
		private void UpdateServerObjects()
		{
			foreach (NetworkIdentity networkIdentity in NetworkServer.objects.Values)
			{
				try
				{
					networkIdentity.UNetUpdate();
				}
				catch (NullReferenceException)
				{
				}
				catch (MissingReferenceException)
				{
				}
			}
			if (this.m_RemoveListCount++ % 100 == 0)
			{
				this.CheckForNullObjects();
			}
		}

		// Token: 0x060003F4 RID: 1012 RVA: 0x00016AA4 File Offset: 0x00014CA4
		private void CheckForNullObjects()
		{
			foreach (NetworkInstanceId networkInstanceId in NetworkServer.objects.Keys)
			{
				NetworkIdentity networkIdentity = NetworkServer.objects[networkInstanceId];
				if (networkIdentity == null || networkIdentity.gameObject == null)
				{
					this.m_RemoveList.Add(networkInstanceId);
				}
			}
			if (this.m_RemoveList.Count > 0)
			{
				foreach (NetworkInstanceId networkInstanceId2 in this.m_RemoveList)
				{
					NetworkServer.objects.Remove(networkInstanceId2);
				}
				this.m_RemoveList.Clear();
			}
		}

		// Token: 0x060003F5 RID: 1013 RVA: 0x00016BAC File Offset: 0x00014DAC
		internal void InternalUpdate()
		{
			this.m_SimpleServerSimple.Update();
			if (NetworkServer.m_DontListen)
			{
				this.m_SimpleServerSimple.UpdateConnections();
			}
			this.UpdateServerObjects();
		}

		// Token: 0x060003F6 RID: 1014 RVA: 0x00016BD8 File Offset: 0x00014DD8
		private void OnConnected(NetworkConnection conn)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("Server accepted client:" + conn.connectionId);
			}
			conn.SetMaxDelay(this.m_MaxDelay);
			conn.InvokeHandlerNoData(32);
			NetworkServer.SendCrc(conn);
		}

		// Token: 0x060003F7 RID: 1015 RVA: 0x00016C28 File Offset: 0x00014E28
		private void OnDisconnected(NetworkConnection conn)
		{
			conn.InvokeHandlerNoData(33);
			for (int i = 0; i < conn.playerControllers.Count; i++)
			{
				if (conn.playerControllers[i].gameObject != null)
				{
					if (LogFilter.logWarn)
					{
						Debug.LogWarning("Player not destroyed when connection disconnected.");
					}
				}
			}
			if (LogFilter.logDebug)
			{
				Debug.Log("Server lost client:" + conn.connectionId);
			}
			conn.RemoveObservers();
			conn.Dispose();
		}

		// Token: 0x060003F8 RID: 1016 RVA: 0x00016CC3 File Offset: 0x00014EC3
		private void OnData(NetworkConnection conn, int receivedSize, int channelId)
		{
			conn.TransportReceive(this.m_SimpleServerSimple.messageBuffer, receivedSize, channelId);
		}

		// Token: 0x060003F9 RID: 1017 RVA: 0x00016CD9 File Offset: 0x00014ED9
		private void GenerateConnectError(int error)
		{
			if (LogFilter.logError)
			{
				Debug.LogError("UNet Server Connect Error: " + error);
			}
			this.GenerateError(null, error);
		}

		// Token: 0x060003FA RID: 1018 RVA: 0x00016D08 File Offset: 0x00014F08
		private void GenerateDataError(NetworkConnection conn, int error)
		{
			if (LogFilter.logError)
			{
				Debug.LogError("UNet Server Data Error: " + (NetworkError)error);
			}
			this.GenerateError(conn, error);
		}

		// Token: 0x060003FB RID: 1019 RVA: 0x00016D44 File Offset: 0x00014F44
		private void GenerateDisconnectError(NetworkConnection conn, int error)
		{
			if (LogFilter.logError)
			{
				Debug.LogError(string.Concat(new object[]
				{
					"UNet Server Disconnect Error: ",
					(NetworkError)error,
					" conn:[",
					conn,
					"]:",
					conn.connectionId
				}));
			}
			this.GenerateError(conn, error);
		}

		// Token: 0x060003FC RID: 1020 RVA: 0x00016DAC File Offset: 0x00014FAC
		private void GenerateError(NetworkConnection conn, int error)
		{
			if (NetworkServer.handlers.ContainsKey(34))
			{
				ErrorMessage errorMessage = new ErrorMessage();
				errorMessage.errorCode = error;
				NetworkWriter networkWriter = new NetworkWriter();
				errorMessage.Serialize(networkWriter);
				NetworkReader networkReader = new NetworkReader(networkWriter);
				conn.InvokeHandler(34, networkReader, 0);
			}
		}

		// Token: 0x060003FD RID: 1021 RVA: 0x00016DF9 File Offset: 0x00014FF9
		public static void RegisterHandler(short msgType, NetworkMessageDelegate handler)
		{
			NetworkServer.instance.m_SimpleServerSimple.RegisterHandler(msgType, handler);
		}

		// Token: 0x060003FE RID: 1022 RVA: 0x00016E0D File Offset: 0x0001500D
		public static void UnregisterHandler(short msgType)
		{
			NetworkServer.instance.m_SimpleServerSimple.UnregisterHandler(msgType);
		}

		// Token: 0x060003FF RID: 1023 RVA: 0x00016E20 File Offset: 0x00015020
		public static void ClearHandlers()
		{
			NetworkServer.instance.m_SimpleServerSimple.ClearHandlers();
		}

		// Token: 0x06000400 RID: 1024 RVA: 0x00016E32 File Offset: 0x00015032
		public static void ClearSpawners()
		{
			NetworkScene.ClearSpawners();
		}

		// Token: 0x06000401 RID: 1025 RVA: 0x00016E3C File Offset: 0x0001503C
		public static void GetStatsOut(out int numMsgs, out int numBufferedMsgs, out int numBytes, out int lastBufferedPerSecond)
		{
			numMsgs = 0;
			numBufferedMsgs = 0;
			numBytes = 0;
			lastBufferedPerSecond = 0;
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					int num;
					int num2;
					int num3;
					int num4;
					networkConnection.GetStatsOut(out num, out num2, out num3, out num4);
					numMsgs += num;
					numBufferedMsgs += num2;
					numBytes += num3;
					lastBufferedPerSecond += num4;
				}
			}
		}

		// Token: 0x06000402 RID: 1026 RVA: 0x00016EB0 File Offset: 0x000150B0
		public static void GetStatsIn(out int numMsgs, out int numBytes)
		{
			numMsgs = 0;
			numBytes = 0;
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					int num;
					int num2;
					networkConnection.GetStatsIn(out num, out num2);
					numMsgs += num;
					numBytes += num2;
				}
			}
		}

		// Token: 0x06000403 RID: 1027 RVA: 0x00016F0C File Offset: 0x0001510C
		public static void SendToClientOfPlayer(GameObject player, short msgType, MessageBase msg)
		{
			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 && networkConnection.playerControllers[j].gameObject == player)
						{
							networkConnection.Send(msgType, msg);
							return;
						}
					}
				}
			}
			if (LogFilter.logError)
			{
				Debug.LogError("Failed to send message to player object '" + player.name + ", not found in connection list");
				return;
			}
		}

		// Token: 0x06000404 RID: 1028 RVA: 0x00016FD0 File Offset: 0x000151D0
		public static void SendToClient(int connectionId, short msgType, MessageBase msg)
		{
			if (connectionId < NetworkServer.connections.Count)
			{
				NetworkConnection networkConnection = NetworkServer.connections[connectionId];
				if (networkConnection != null)
				{
					networkConnection.Send(msgType, msg);
					return;
				}
			}
			if (LogFilter.logError)
			{
				Debug.LogError("Failed to send message to connection ID '" + connectionId + ", not found in connection list");
			}
		}

		// Token: 0x06000405 RID: 1029 RVA: 0x00017038 File Offset: 0x00015238
		public static bool ReplacePlayerForConnection(NetworkConnection conn, GameObject player, short playerControllerId, NetworkHash128 assetId)
		{
			NetworkIdentity networkIdentity;
			if (NetworkServer.GetNetworkIdentity(player, out networkIdentity))
			{
				networkIdentity.SetDynamicAssetId(assetId);
			}
			return NetworkServer.instance.InternalReplacePlayerForConnection(conn, player, playerControllerId);
		}

		// Token: 0x06000406 RID: 1030 RVA: 0x00017070 File Offset: 0x00015270
		public static bool ReplacePlayerForConnection(NetworkConnection conn, GameObject player, short playerControllerId)
		{
			return NetworkServer.instance.InternalReplacePlayerForConnection(conn, player, playerControllerId);
		}

		// Token: 0x06000407 RID: 1031 RVA: 0x00017094 File Offset: 0x00015294
		public static bool AddPlayerForConnection(NetworkConnection conn, GameObject player, short playerControllerId, NetworkHash128 assetId)
		{
			NetworkIdentity networkIdentity;
			if (NetworkServer.GetNetworkIdentity(player, out networkIdentity))
			{
				networkIdentity.SetDynamicAssetId(assetId);
			}
			return NetworkServer.instance.InternalAddPlayerForConnection(conn, player, playerControllerId);
		}

		// Token: 0x06000408 RID: 1032 RVA: 0x000170CC File Offset: 0x000152CC
		public static bool AddPlayerForConnection(NetworkConnection conn, GameObject player, short playerControllerId)
		{
			return NetworkServer.instance.InternalAddPlayerForConnection(conn, player, playerControllerId);
		}

		// Token: 0x06000409 RID: 1033 RVA: 0x000170F0 File Offset: 0x000152F0
		internal bool InternalAddPlayerForConnection(NetworkConnection conn, GameObject playerGameObject, short playerControllerId)
		{
			NetworkIdentity networkIdentity;
			bool flag;
			if (!NetworkServer.GetNetworkIdentity(playerGameObject, out networkIdentity))
			{
				if (LogFilter.logError)
				{
					Debug.Log("AddPlayer: playerGameObject has no NetworkIdentity. Please add a NetworkIdentity to " + playerGameObject);
				}
				flag = false;
			}
			else
			{
				networkIdentity.Reset();
				if (!NetworkServer.CheckPlayerControllerIdForConnection(conn, playerControllerId))
				{
					flag = false;
				}
				else
				{
					PlayerController playerController = null;
					GameObject gameObject = null;
					if (conn.GetPlayerController(playerControllerId, out playerController))
					{
						gameObject = playerController.gameObject;
					}
					if (gameObject != null)
					{
						if (LogFilter.logError)
						{
							Debug.Log("AddPlayer: player object already exists for playerControllerId of " + playerControllerId);
						}
						flag = false;
					}
					else
					{
						PlayerController playerController2 = new PlayerController(playerGameObject, playerControllerId);
						conn.SetPlayerController(playerController2);
						networkIdentity.SetConnectionToClient(conn, playerController2.playerControllerId);
						NetworkServer.SetClientReady(conn);
						if (this.SetupLocalPlayerForConnection(conn, networkIdentity, playerController2))
						{
							flag = true;
						}
						else
						{
							if (LogFilter.logDebug)
							{
								Debug.Log(string.Concat(new object[]
								{
									"Adding new playerGameObject object netId: ",
									playerGameObject.GetComponent<NetworkIdentity>().netId,
									" asset ID ",
									playerGameObject.GetComponent<NetworkIdentity>().assetId
								}));
							}
							NetworkServer.FinishPlayerForConnection(conn, networkIdentity, playerGameObject);
							if (networkIdentity.localPlayerAuthority)
							{
								networkIdentity.SetClientOwner(conn);
							}
							flag = true;
						}
					}
				}
			}
			return flag;
		}

		// Token: 0x0600040A RID: 1034 RVA: 0x0001724C File Offset: 0x0001544C
		private static bool CheckPlayerControllerIdForConnection(NetworkConnection conn, short playerControllerId)
		{
			bool flag;
			if (playerControllerId < 0)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("AddPlayer: playerControllerId of " + playerControllerId + " is negative");
				}
				flag = false;
			}
			else if (playerControllerId > 32)
			{
				if (LogFilter.logError)
				{
					Debug.Log(string.Concat(new object[] { "AddPlayer: playerControllerId of ", playerControllerId, " is too high. max is ", 32 }));
				}
				flag = false;
			}
			else
			{
				if (playerControllerId > 16)
				{
					if (LogFilter.logWarn)
					{
						Debug.LogWarning("AddPlayer: playerControllerId of " + playerControllerId + " is unusually high");
					}
				}
				flag = true;
			}
			return flag;
		}

		// Token: 0x0600040B RID: 1035 RVA: 0x00017318 File Offset: 0x00015518
		private bool SetupLocalPlayerForConnection(NetworkConnection conn, NetworkIdentity uv, PlayerController newPlayerController)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("NetworkServer SetupLocalPlayerForConnection netID:" + uv.netId);
			}
			ULocalConnectionToClient ulocalConnectionToClient = conn as ULocalConnectionToClient;
			bool flag;
			if (ulocalConnectionToClient != null)
			{
				if (LogFilter.logDev)
				{
					Debug.Log("NetworkServer AddPlayer handling ULocalConnectionToClient");
				}
				if (uv.netId.IsEmpty())
				{
					uv.OnStartServer(true);
				}
				uv.RebuildObservers(true);
				this.SendSpawnMessage(uv, null);
				ulocalConnectionToClient.localClient.AddLocalPlayer(newPlayerController);
				uv.SetClientOwner(conn);
				uv.ForceAuthority(true);
				uv.SetLocalPlayer(newPlayerController.playerControllerId);
				flag = true;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x0600040C RID: 1036 RVA: 0x000173D0 File Offset: 0x000155D0
		private static void FinishPlayerForConnection(NetworkConnection conn, NetworkIdentity uv, GameObject playerGameObject)
		{
			if (uv.netId.IsEmpty())
			{
				NetworkServer.Spawn(playerGameObject);
			}
			conn.Send(4, new OwnerMessage
			{
				netId = uv.netId,
				playerControllerId = uv.playerControllerId
			});
		}

		// Token: 0x0600040D RID: 1037 RVA: 0x00017420 File Offset: 0x00015620
		internal bool InternalReplacePlayerForConnection(NetworkConnection conn, GameObject playerGameObject, short playerControllerId)
		{
			NetworkIdentity networkIdentity;
			bool flag;
			if (!NetworkServer.GetNetworkIdentity(playerGameObject, out networkIdentity))
			{
				if (LogFilter.logError)
				{
					Debug.LogError("ReplacePlayer: playerGameObject has no NetworkIdentity. Please add a NetworkIdentity to " + playerGameObject);
				}
				flag = false;
			}
			else if (!NetworkServer.CheckPlayerControllerIdForConnection(conn, playerControllerId))
			{
				flag = false;
			}
			else
			{
				if (LogFilter.logDev)
				{
					Debug.Log("NetworkServer ReplacePlayer");
				}
				PlayerController playerController;
				if (conn.GetPlayerController(playerControllerId, out playerController))
				{
					playerController.unetView.SetNotLocalPlayer();
					playerController.unetView.ClearClientOwner();
				}
				PlayerController playerController2 = new PlayerController(playerGameObject, playerControllerId);
				conn.SetPlayerController(playerController2);
				networkIdentity.SetConnectionToClient(conn, playerController2.playerControllerId);
				if (LogFilter.logDev)
				{
					Debug.Log("NetworkServer ReplacePlayer setup local");
				}
				if (this.SetupLocalPlayerForConnection(conn, networkIdentity, playerController2))
				{
					flag = true;
				}
				else
				{
					if (LogFilter.logDebug)
					{
						Debug.Log(string.Concat(new object[]
						{
							"Replacing playerGameObject object netId: ",
							playerGameObject.GetComponent<NetworkIdentity>().netId,
							" asset ID ",
							playerGameObject.GetComponent<NetworkIdentity>().assetId
						}));
					}
					NetworkServer.FinishPlayerForConnection(conn, networkIdentity, playerGameObject);
					if (networkIdentity.localPlayerAuthority)
					{
						networkIdentity.SetClientOwner(conn);
					}
					flag = true;
				}
			}
			return flag;
		}

		// Token: 0x0600040E RID: 1038 RVA: 0x0001756C File Offset: 0x0001576C
		private static bool GetNetworkIdentity(GameObject go, out NetworkIdentity view)
		{
			view = go.GetComponent<NetworkIdentity>();
			bool flag;
			if (view == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("UNET failure. GameObject doesn't have NetworkIdentity.");
				}
				flag = false;
			}
			else
			{
				flag = true;
			}
			return flag;
		}

		// Token: 0x0600040F RID: 1039 RVA: 0x000175B5 File Offset: 0x000157B5
		public static void SetClientReady(NetworkConnection conn)
		{
			NetworkServer.instance.SetClientReadyInternal(conn);
		}

		// Token: 0x06000410 RID: 1040 RVA: 0x000175C4 File Offset: 0x000157C4
		internal void SetClientReadyInternal(NetworkConnection conn)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("SetClientReadyInternal for conn:" + conn.connectionId);
			}
			if (conn.isReady)
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("SetClientReady conn " + conn.connectionId + " already ready");
				}
			}
			else
			{
				if (conn.playerControllers.Count == 0)
				{
					if (LogFilter.logDebug)
					{
						Debug.LogWarning("Ready with no player object");
					}
				}
				conn.isReady = true;
				ULocalConnectionToClient ulocalConnectionToClient = conn as ULocalConnectionToClient;
				if (ulocalConnectionToClient != null)
				{
					if (LogFilter.logDev)
					{
						Debug.Log("NetworkServer Ready handling ULocalConnectionToClient");
					}
					foreach (NetworkIdentity networkIdentity in NetworkServer.objects.Values)
					{
						if (networkIdentity != null && networkIdentity.gameObject != null)
						{
							bool flag = networkIdentity.OnCheckObserver(conn);
							if (flag)
							{
								networkIdentity.AddObserver(conn);
							}
							if (!networkIdentity.isClient)
							{
								if (LogFilter.logDev)
								{
									Debug.Log("LocalClient.SetSpawnObject calling OnStartClient");
								}
								networkIdentity.OnStartClient();
							}
						}
					}
				}
				else
				{
					if (LogFilter.logDebug)
					{
						Debug.Log(string.Concat(new object[]
						{
							"Spawning ",
							NetworkServer.objects.Count,
							" objects for conn ",
							conn.connectionId
						}));
					}
					ObjectSpawnFinishedMessage objectSpawnFinishedMessage = new ObjectSpawnFinishedMessage();
					objectSpawnFinishedMessage.state = 0U;
					conn.Send(12, objectSpawnFinishedMessage);
					foreach (NetworkIdentity networkIdentity2 in NetworkServer.objects.Values)
					{
						if (networkIdentity2 == null)
						{
							if (LogFilter.logWarn)
							{
								Debug.LogWarning("Invalid object found in server local object list (null NetworkIdentity).");
							}
						}
						else if (networkIdentity2.gameObject.activeSelf)
						{
							if (LogFilter.logDebug)
							{
								Debug.Log(string.Concat(new object[]
								{
									"Sending spawn message for current server objects name='",
									networkIdentity2.gameObject.name,
									"' netId=",
									networkIdentity2.netId
								}));
							}
							bool flag2 = networkIdentity2.OnCheckObserver(conn);
							if (flag2)
							{
								networkIdentity2.AddObserver(conn);
							}
						}
					}
					objectSpawnFinishedMessage.state = 1U;
					conn.Send(12, objectSpawnFinishedMessage);
				}
			}
		}

		// Token: 0x06000411 RID: 1041 RVA: 0x000178A8 File Offset: 0x00015AA8
		internal static void ShowForConnection(NetworkIdentity uv, NetworkConnection conn)
		{
			if (conn.isReady)
			{
				NetworkServer.instance.SendSpawnMessage(uv, conn);
			}
		}

		// Token: 0x06000412 RID: 1042 RVA: 0x000178C4 File Offset: 0x00015AC4
		internal static void HideForConnection(NetworkIdentity uv, NetworkConnection conn)
		{
			conn.Send(13, new ObjectDestroyMessage
			{
				netId = uv.netId
			});
		}

		// Token: 0x06000413 RID: 1043 RVA: 0x000178F0 File Offset: 0x00015AF0
		public static void SetAllClientsNotReady()
		{
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					NetworkServer.SetClientNotReady(networkConnection);
				}
			}
		}

		// Token: 0x06000414 RID: 1044 RVA: 0x00017935 File Offset: 0x00015B35
		public static void SetClientNotReady(NetworkConnection conn)
		{
			NetworkServer.instance.InternalSetClientNotReady(conn);
		}

		// Token: 0x06000415 RID: 1045 RVA: 0x00017944 File Offset: 0x00015B44
		internal void InternalSetClientNotReady(NetworkConnection conn)
		{
			if (conn.isReady)
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("PlayerNotReady " + conn);
				}
				conn.isReady = false;
				conn.RemoveObservers();
				NotReadyMessage notReadyMessage = new NotReadyMessage();
				conn.Send(36, notReadyMessage);
			}
		}

		// Token: 0x06000416 RID: 1046 RVA: 0x00017998 File Offset: 0x00015B98
		private static void OnClientReadyMessage(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("Default handler for ready message from " + netMsg.conn);
			}
			NetworkServer.SetClientReady(netMsg.conn);
		}

		// Token: 0x06000417 RID: 1047 RVA: 0x000179C8 File Offset: 0x00015BC8
		private static void OnRemovePlayerMessage(NetworkMessage netMsg)
		{
			netMsg.ReadMessage<RemovePlayerMessage>(NetworkServer.s_RemovePlayerMessage);
			PlayerController playerController = null;
			netMsg.conn.GetPlayerController(NetworkServer.s_RemovePlayerMessage.playerControllerId, out playerController);
			if (playerController != null)
			{
				netMsg.conn.RemovePlayerController(NetworkServer.s_RemovePlayerMessage.playerControllerId);
				NetworkServer.Destroy(playerController.gameObject);
			}
			else if (LogFilter.logError)
			{
				Debug.LogError("Received remove player message but could not find the player ID: " + NetworkServer.s_RemovePlayerMessage.playerControllerId);
			}
		}

		// Token: 0x06000418 RID: 1048 RVA: 0x00017A54 File Offset: 0x00015C54
		private static void OnCommandMessage(NetworkMessage netMsg)
		{
			int num = (int)netMsg.reader.ReadPackedUInt32();
			NetworkInstanceId networkInstanceId = netMsg.reader.ReadNetworkId();
			GameObject gameObject = NetworkServer.FindLocalObject(networkInstanceId);
			if (gameObject == null)
			{
				if (LogFilter.logWarn)
				{
					Debug.LogWarning("Instance not found when handling Command message [netId=" + networkInstanceId + "]");
				}
			}
			else
			{
				NetworkIdentity component = gameObject.GetComponent<NetworkIdentity>();
				if (component == null)
				{
					if (LogFilter.logWarn)
					{
						Debug.LogWarning("NetworkIdentity deleted when handling Command message [netId=" + networkInstanceId + "]");
					}
				}
				else
				{
					bool flag = false;
					for (int i = 0; i < netMsg.conn.playerControllers.Count; i++)
					{
						PlayerController playerController = netMsg.conn.playerControllers[i];
						if (playerController.gameObject != null && playerController.gameObject.GetComponent<NetworkIdentity>().netId == component.netId)
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						if (component.clientAuthorityOwner != netMsg.conn)
						{
							if (LogFilter.logWarn)
							{
								Debug.LogWarning("Command for object without authority [netId=" + networkInstanceId + "]");
							}
							return;
						}
					}
					if (LogFilter.logDev)
					{
						Debug.Log(string.Concat(new object[] { "OnCommandMessage for netId=", networkInstanceId, " conn=", netMsg.conn }));
					}
					component.HandleCommand(num, netMsg.reader);
				}
			}
		}

		// Token: 0x06000419 RID: 1049 RVA: 0x00017C04 File Offset: 0x00015E04
		internal void SpawnObject(GameObject obj)
		{
			NetworkIdentity networkIdentity;
			if (!NetworkServer.active)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("SpawnObject for " + obj + ", NetworkServer is not active. Cannot spawn objects without an active server.");
				}
			}
			else if (!NetworkServer.GetNetworkIdentity(obj, out networkIdentity))
			{
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "SpawnObject ", obj, " has no NetworkIdentity. Please add a NetworkIdentity to ", obj }));
				}
			}
			else
			{
				networkIdentity.Reset();
				networkIdentity.OnStartServer(false);
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "SpawnObject instance ID ", networkIdentity.netId, " asset ID ", networkIdentity.assetId }));
				}
				networkIdentity.RebuildObservers(true);
			}
		}

		// Token: 0x0600041A RID: 1050 RVA: 0x00017CE8 File Offset: 0x00015EE8
		internal void SendSpawnMessage(NetworkIdentity uv, NetworkConnection conn)
		{
			if (!uv.serverOnly)
			{
				if (uv.sceneId.IsEmpty())
				{
					ObjectSpawnMessage objectSpawnMessage = new ObjectSpawnMessage();
					objectSpawnMessage.netId = uv.netId;
					objectSpawnMessage.assetId = uv.assetId;
					objectSpawnMessage.position = uv.transform.position;
					objectSpawnMessage.rotation = uv.transform.rotation;
					NetworkWriter networkWriter = new NetworkWriter();
					uv.UNetSerializeAllVars(networkWriter);
					if (networkWriter.Position > 0)
					{
						objectSpawnMessage.payload = networkWriter.ToArray();
					}
					if (conn != null)
					{
						conn.Send(3, objectSpawnMessage);
					}
					else
					{
						NetworkServer.SendToReady(uv.gameObject, 3, objectSpawnMessage);
					}
				}
				else
				{
					ObjectSpawnSceneMessage objectSpawnSceneMessage = new ObjectSpawnSceneMessage();
					objectSpawnSceneMessage.netId = uv.netId;
					objectSpawnSceneMessage.sceneId = uv.sceneId;
					objectSpawnSceneMessage.position = uv.transform.position;
					NetworkWriter networkWriter2 = new NetworkWriter();
					uv.UNetSerializeAllVars(networkWriter2);
					if (networkWriter2.Position > 0)
					{
						objectSpawnSceneMessage.payload = networkWriter2.ToArray();
					}
					if (conn != null)
					{
						conn.Send(10, objectSpawnSceneMessage);
					}
					else
					{
						NetworkServer.SendToReady(uv.gameObject, 3, objectSpawnSceneMessage);
					}
				}
			}
		}

		// Token: 0x0600041B RID: 1051 RVA: 0x00017E30 File Offset: 0x00016030
		public static void DestroyPlayersForConnection(NetworkConnection conn)
		{
			if (conn.playerControllers.Count == 0)
			{
				if (LogFilter.logWarn)
				{
					Debug.LogWarning("Empty player list given to NetworkServer.Destroy(), nothing to do.");
				}
			}
			else
			{
				if (conn.clientOwnedObjects != null)
				{
					HashSet<NetworkInstanceId> hashSet = new HashSet<NetworkInstanceId>(conn.clientOwnedObjects);
					foreach (NetworkInstanceId networkInstanceId in hashSet)
					{
						GameObject gameObject = NetworkServer.FindLocalObject(networkInstanceId);
						if (gameObject != null)
						{
							NetworkServer.DestroyObject(gameObject);
						}
					}
				}
				for (int i = 0; i < conn.playerControllers.Count; i++)
				{
					PlayerController playerController = conn.playerControllers[i];
					if (playerController.IsValid)
					{
						if (!(playerController.unetView == null))
						{
							NetworkServer.DestroyObject(playerController.unetView, true);
						}
						playerController.gameObject = null;
					}
				}
				conn.playerControllers.Clear();
			}
		}

		// Token: 0x0600041C RID: 1052 RVA: 0x00017F60 File Offset: 0x00016160
		private static void UnSpawnObject(GameObject obj)
		{
			NetworkIdentity networkIdentity;
			if (obj == null)
			{
				if (LogFilter.logDev)
				{
					Debug.Log("NetworkServer UnspawnObject is null");
				}
			}
			else if (NetworkServer.GetNetworkIdentity(obj, out networkIdentity))
			{
				NetworkServer.UnSpawnObject(networkIdentity);
			}
		}

		// Token: 0x0600041D RID: 1053 RVA: 0x00017FAE File Offset: 0x000161AE
		private static void UnSpawnObject(NetworkIdentity uv)
		{
			NetworkServer.DestroyObject(uv, false);
		}

		// Token: 0x0600041E RID: 1054 RVA: 0x00017FB8 File Offset: 0x000161B8
		private static void DestroyObject(GameObject obj)
		{
			NetworkIdentity networkIdentity;
			if (obj == null)
			{
				if (LogFilter.logDev)
				{
					Debug.Log("NetworkServer DestroyObject is null");
				}
			}
			else if (NetworkServer.GetNetworkIdentity(obj, out networkIdentity))
			{
				NetworkServer.DestroyObject(networkIdentity, true);
			}
		}

		// Token: 0x0600041F RID: 1055 RVA: 0x00018008 File Offset: 0x00016208
		private static void DestroyObject(NetworkIdentity uv, bool destroyServerObject)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("DestroyObject instance:" + uv.netId);
			}
			if (NetworkServer.objects.ContainsKey(uv.netId))
			{
				NetworkServer.objects.Remove(uv.netId);
			}
			if (uv.clientAuthorityOwner != null)
			{
				uv.clientAuthorityOwner.RemoveOwnedObject(uv);
			}
			ObjectDestroyMessage objectDestroyMessage = new ObjectDestroyMessage();
			objectDestroyMessage.netId = uv.netId;
			NetworkServer.SendToObservers(uv.gameObject, 1, objectDestroyMessage);
			uv.ClearObservers();
			if (NetworkClient.active && NetworkServer.instance.m_LocalClientActive)
			{
				uv.OnNetworkDestroy();
				ClientScene.SetLocalObject(objectDestroyMessage.netId, null);
			}
			if (destroyServerObject)
			{
				Object.Destroy(uv.gameObject);
			}
			uv.MarkForReset();
		}

		// Token: 0x06000420 RID: 1056 RVA: 0x000180E9 File Offset: 0x000162E9
		public static void ClearLocalObjects()
		{
			NetworkServer.objects.Clear();
		}

		// Token: 0x06000421 RID: 1057 RVA: 0x000180F6 File Offset: 0x000162F6
		public static void Spawn(GameObject obj)
		{
			if (NetworkServer.VerifyCanSpawn(obj))
			{
				NetworkServer.instance.SpawnObject(obj);
			}
		}

		// Token: 0x06000422 RID: 1058 RVA: 0x00018118 File Offset: 0x00016318
		private static bool CheckForPrefab(GameObject obj)
		{
			return false;
		}

		// Token: 0x06000423 RID: 1059 RVA: 0x00018130 File Offset: 0x00016330
		private static bool VerifyCanSpawn(GameObject obj)
		{
			bool flag;
			if (NetworkServer.CheckForPrefab(obj))
			{
				Debug.LogErrorFormat("GameObject {0} is a prefab, it can't be spawned. This will cause errors in builds.", new object[] { obj.name });
				flag = false;
			}
			else
			{
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000424 RID: 1060 RVA: 0x00018174 File Offset: 0x00016374
		public static bool SpawnWithClientAuthority(GameObject obj, GameObject player)
		{
			NetworkIdentity component = player.GetComponent<NetworkIdentity>();
			bool flag;
			if (component == null)
			{
				Debug.LogError("SpawnWithClientAuthority player object has no NetworkIdentity");
				flag = false;
			}
			else if (component.connectionToClient == null)
			{
				Debug.LogError("SpawnWithClientAuthority player object is not a player.");
				flag = false;
			}
			else
			{
				flag = NetworkServer.SpawnWithClientAuthority(obj, component.connectionToClient);
			}
			return flag;
		}

		// Token: 0x06000425 RID: 1061 RVA: 0x000181D8 File Offset: 0x000163D8
		public static bool SpawnWithClientAuthority(GameObject obj, NetworkConnection conn)
		{
			bool flag;
			if (!conn.isReady)
			{
				Debug.LogError("SpawnWithClientAuthority NetworkConnection is not ready!");
				flag = false;
			}
			else
			{
				NetworkServer.Spawn(obj);
				NetworkIdentity component = obj.GetComponent<NetworkIdentity>();
				flag = !(component == null) && component.isServer && component.AssignClientAuthority(conn);
			}
			return flag;
		}

		// Token: 0x06000426 RID: 1062 RVA: 0x00018240 File Offset: 0x00016440
		public static bool SpawnWithClientAuthority(GameObject obj, NetworkHash128 assetId, NetworkConnection conn)
		{
			NetworkServer.Spawn(obj, assetId);
			NetworkIdentity component = obj.GetComponent<NetworkIdentity>();
			return !(component == null) && component.isServer && component.AssignClientAuthority(conn);
		}

		// Token: 0x06000427 RID: 1063 RVA: 0x0001828C File Offset: 0x0001648C
		public static void Spawn(GameObject obj, NetworkHash128 assetId)
		{
			if (NetworkServer.VerifyCanSpawn(obj))
			{
				NetworkIdentity networkIdentity;
				if (NetworkServer.GetNetworkIdentity(obj, out networkIdentity))
				{
					networkIdentity.SetDynamicAssetId(assetId);
				}
				NetworkServer.instance.SpawnObject(obj);
			}
		}

		// Token: 0x06000428 RID: 1064 RVA: 0x000182CC File Offset: 0x000164CC
		public static void Destroy(GameObject obj)
		{
			NetworkServer.DestroyObject(obj);
		}

		// Token: 0x06000429 RID: 1065 RVA: 0x000182D5 File Offset: 0x000164D5
		public static void UnSpawn(GameObject obj)
		{
			NetworkServer.UnSpawnObject(obj);
		}

		// Token: 0x0600042A RID: 1066 RVA: 0x000182E0 File Offset: 0x000164E0
		internal bool InvokeBytes(ULocalConnectionToServer conn, byte[] buffer, int numBytes, int channelId)
		{
			NetworkReader networkReader = new NetworkReader(buffer);
			networkReader.ReadInt16();
			short num = networkReader.ReadInt16();
			bool flag;
			if (NetworkServer.handlers.ContainsKey(num) && this.m_LocalConnection != null)
			{
				this.m_LocalConnection.InvokeHandler(num, networkReader, channelId);
				flag = true;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x0600042B RID: 1067 RVA: 0x00018340 File Offset: 0x00016540
		internal bool InvokeHandlerOnServer(ULocalConnectionToServer conn, short msgType, MessageBase msg, int channelId)
		{
			bool flag;
			if (NetworkServer.handlers.ContainsKey(msgType) && this.m_LocalConnection != null)
			{
				NetworkWriter networkWriter = new NetworkWriter();
				msg.Serialize(networkWriter);
				NetworkReader networkReader = new NetworkReader(networkWriter);
				this.m_LocalConnection.InvokeHandler(msgType, networkReader, channelId);
				flag = true;
			}
			else
			{
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "Local invoke: Failed to find local connection to invoke handler on [connectionId=", conn.connectionId, "] for MsgId:", msgType }));
				}
				flag = false;
			}
			return flag;
		}

		// Token: 0x0600042C RID: 1068 RVA: 0x000183E0 File Offset: 0x000165E0
		public static GameObject FindLocalObject(NetworkInstanceId netId)
		{
			return NetworkServer.instance.m_NetworkScene.FindLocalObject(netId);
		}

		// Token: 0x0600042D RID: 1069 RVA: 0x00018408 File Offset: 0x00016608
		public static Dictionary<short, NetworkConnection.PacketStat> GetConnectionStats()
		{
			Dictionary<short, NetworkConnection.PacketStat> dictionary = new Dictionary<short, NetworkConnection.PacketStat>();
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					foreach (short num in networkConnection.packetStats.Keys)
					{
						if (dictionary.ContainsKey(num))
						{
							NetworkConnection.PacketStat packetStat = dictionary[num];
							packetStat.count += networkConnection.packetStats[num].count;
							packetStat.bytes += networkConnection.packetStats[num].bytes;
							dictionary[num] = packetStat;
						}
						else
						{
							dictionary[num] = new NetworkConnection.PacketStat(networkConnection.packetStats[num]);
						}
					}
				}
			}
			return dictionary;
		}

		// Token: 0x0600042E RID: 1070 RVA: 0x00018528 File Offset: 0x00016728
		public static void ResetConnectionStats()
		{
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					networkConnection.ResetStats();
				}
			}
		}

		// Token: 0x0600042F RID: 1071 RVA: 0x00018570 File Offset: 0x00016770
		public static bool AddExternalConnection(NetworkConnection conn)
		{
			return NetworkServer.instance.AddExternalConnectionInternal(conn);
		}

		// Token: 0x06000430 RID: 1072 RVA: 0x00018590 File Offset: 0x00016790
		private bool AddExternalConnectionInternal(NetworkConnection conn)
		{
			bool flag;
			if (conn.connectionId < 0)
			{
				flag = false;
			}
			else if (conn.connectionId < NetworkServer.connections.Count && NetworkServer.connections[conn.connectionId] != null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("AddExternalConnection failed, already connection for id:" + conn.connectionId);
				}
				flag = false;
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("AddExternalConnection external connection " + conn.connectionId);
				}
				this.m_SimpleServerSimple.SetConnectionAtIndex(conn);
				this.m_ExternalConnections.Add(conn.connectionId);
				conn.InvokeHandlerNoData(32);
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000431 RID: 1073 RVA: 0x0001865F File Offset: 0x0001685F
		public static void RemoveExternalConnection(int connectionId)
		{
			NetworkServer.instance.RemoveExternalConnectionInternal(connectionId);
		}

		// Token: 0x06000432 RID: 1074 RVA: 0x00018670 File Offset: 0x00016870
		private bool RemoveExternalConnectionInternal(int connectionId)
		{
			bool flag;
			if (!this.m_ExternalConnections.Contains(connectionId))
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RemoveExternalConnection failed, no connection for id:" + connectionId);
				}
				flag = false;
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("RemoveExternalConnection external connection " + connectionId);
				}
				NetworkConnection networkConnection = this.m_SimpleServerSimple.FindConnection(connectionId);
				if (networkConnection != null)
				{
					networkConnection.RemoveObservers();
				}
				this.m_SimpleServerSimple.RemoveConnectionAtIndex(connectionId);
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000433 RID: 1075 RVA: 0x0001870C File Offset: 0x0001690C
		public static bool SpawnObjects()
		{
			if (NetworkServer.active)
			{
				foreach (NetworkIdentity networkIdentity in Resources.FindObjectsOfTypeAll<NetworkIdentity>())
				{
					if (networkIdentity.gameObject.hideFlags != HideFlags.NotEditable && networkIdentity.gameObject.hideFlags != HideFlags.HideAndDontSave)
					{
						if (!networkIdentity.sceneId.IsEmpty())
						{
							if (LogFilter.logDebug)
							{
								Debug.Log(string.Concat(new object[]
								{
									"SpawnObjects sceneId:",
									networkIdentity.sceneId,
									" name:",
									networkIdentity.gameObject.name
								}));
							}
							networkIdentity.Reset();
							networkIdentity.gameObject.SetActive(true);
						}
					}
				}
				NetworkIdentity[] array;
				foreach (NetworkIdentity networkIdentity2 in array)
				{
					if (networkIdentity2.gameObject.hideFlags != HideFlags.NotEditable && networkIdentity2.gameObject.hideFlags != HideFlags.HideAndDontSave)
					{
						if (!networkIdentity2.sceneId.IsEmpty())
						{
							if (!networkIdentity2.isServer)
							{
								if (!(networkIdentity2.gameObject == null))
								{
									NetworkServer.Spawn(networkIdentity2.gameObject);
									networkIdentity2.ForceAuthority(true);
								}
							}
						}
					}
				}
			}
			return true;
		}

		// Token: 0x06000434 RID: 1076 RVA: 0x0001888C File Offset: 0x00016A8C
		private static void SendCrc(NetworkConnection targetConnection)
		{
			if (NetworkCRC.singleton != null)
			{
				if (NetworkCRC.scriptCRCCheck)
				{
					CRCMessage crcmessage = new CRCMessage();
					List<CRCMessageEntry> list = new List<CRCMessageEntry>();
					foreach (string text in NetworkCRC.singleton.scripts.Keys)
					{
						list.Add(new CRCMessageEntry
						{
							name = text,
							channel = (byte)NetworkCRC.singleton.scripts[text]
						});
					}
					crcmessage.scripts = list.ToArray();
					targetConnection.Send(14, crcmessage);
				}
			}
		}

		// Token: 0x06000435 RID: 1077 RVA: 0x00018960 File Offset: 0x00016B60
		[Obsolete("moved to NetworkMigrationManager")]
		public void SendNetworkInfo(NetworkConnection targetConnection)
		{
		}

		// Token: 0x040001B8 RID: 440
		private static bool s_Active;

		// Token: 0x040001B9 RID: 441
		private static volatile NetworkServer s_Instance;

		// Token: 0x040001BA RID: 442
		private static object s_Sync = new Object();

		// Token: 0x040001BB RID: 443
		private static bool m_DontListen;

		// Token: 0x040001BC RID: 444
		private bool m_LocalClientActive;

		// Token: 0x040001BD RID: 445
		private List<NetworkConnection> m_LocalConnectionsFakeList = new List<NetworkConnection>();

		// Token: 0x040001BE RID: 446
		private ULocalConnectionToClient m_LocalConnection = null;

		// Token: 0x040001BF RID: 447
		private NetworkScene m_NetworkScene;

		// Token: 0x040001C0 RID: 448
		private HashSet<int> m_ExternalConnections;

		// Token: 0x040001C1 RID: 449
		private NetworkServer.ServerSimpleWrapper m_SimpleServerSimple;

		// Token: 0x040001C2 RID: 450
		private float m_MaxDelay = 0.1f;

		// Token: 0x040001C3 RID: 451
		private HashSet<NetworkInstanceId> m_RemoveList;

		// Token: 0x040001C4 RID: 452
		private int m_RemoveListCount;

		// Token: 0x040001C5 RID: 453
		private const int k_RemoveListInterval = 100;

		// Token: 0x040001C6 RID: 454
		internal static ushort maxPacketSize;

		// Token: 0x040001C7 RID: 455
		private static RemovePlayerMessage s_RemovePlayerMessage = new RemovePlayerMessage();

		// Token: 0x02000059 RID: 89
		private class ServerSimpleWrapper : NetworkServerSimple
		{
			// Token: 0x06000437 RID: 1079 RVA: 0x000194F6 File Offset: 0x000176F6
			public ServerSimpleWrapper(NetworkServer server)
			{
				this.m_Server = server;
			}

			// Token: 0x06000438 RID: 1080 RVA: 0x00019506 File Offset: 0x00017706
			public override void OnConnectError(int connectionId, byte error)
			{
				this.m_Server.GenerateConnectError((int)error);
			}

			// Token: 0x06000439 RID: 1081 RVA: 0x00019515 File Offset: 0x00017715
			public override void OnDataError(NetworkConnection conn, byte error)
			{
				this.m_Server.GenerateDataError(conn, (int)error);
			}

			// Token: 0x0600043A RID: 1082 RVA: 0x00019525 File Offset: 0x00017725
			public override void OnDisconnectError(NetworkConnection conn, byte error)
			{
				this.m_Server.GenerateDisconnectError(conn, (int)error);
			}

			// Token: 0x0600043B RID: 1083 RVA: 0x00019535 File Offset: 0x00017735
			public override void OnConnected(NetworkConnection conn)
			{
				this.m_Server.OnConnected(conn);
			}

			// Token: 0x0600043C RID: 1084 RVA: 0x00019544 File Offset: 0x00017744
			public override void OnDisconnected(NetworkConnection conn)
			{
				this.m_Server.OnDisconnected(conn);
			}

			// Token: 0x0600043D RID: 1085 RVA: 0x00019553 File Offset: 0x00017753
			public override void OnData(NetworkConnection conn, int receivedSize, int channelId)
			{
				this.m_Server.OnData(conn, receivedSize, channelId);
			}

			// Token: 0x040001D1 RID: 465
			private NetworkServer m_Server;
		}
	}
}