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

namespace UnityEngine.Networking
{
	// Token: 0x02000045 RID: 69
	[ExecuteInEditMode]
	[DisallowMultipleComponent]
	[AddComponentMenu("Network/NetworkIdentity")]
	public sealed class NetworkIdentity : MonoBehaviour
	{
		// Token: 0x17000051 RID: 81
		// (get) Token: 0x0600020C RID: 524 RVA: 0x0000BEB0 File Offset: 0x0000A0B0
		public bool isClient
		{
			get
			{
				return this.m_IsClient;
			}
		}

		// Token: 0x17000052 RID: 82
		// (get) Token: 0x0600020D RID: 525 RVA: 0x0000BECC File Offset: 0x0000A0CC
		public bool isServer
		{
			get
			{
				return this.m_IsServer && NetworkServer.active && this.m_IsServer;
			}
		}

		// Token: 0x17000053 RID: 83
		// (get) Token: 0x0600020E RID: 526 RVA: 0x0000BF08 File Offset: 0x0000A108
		public bool hasAuthority
		{
			get
			{
				return this.m_HasAuthority;
			}
		}

		// Token: 0x17000054 RID: 84
		// (get) Token: 0x0600020F RID: 527 RVA: 0x0000BF24 File Offset: 0x0000A124
		public NetworkInstanceId netId
		{
			get
			{
				return this.m_NetId;
			}
		}

		// Token: 0x17000055 RID: 85
		// (get) Token: 0x06000210 RID: 528 RVA: 0x0000BF40 File Offset: 0x0000A140
		public NetworkSceneId sceneId
		{
			get
			{
				return this.m_SceneId;
			}
		}

		// Token: 0x17000056 RID: 86
		// (get) Token: 0x06000211 RID: 529 RVA: 0x0000BF5C File Offset: 0x0000A15C
		// (set) Token: 0x06000212 RID: 530 RVA: 0x0000BF77 File Offset: 0x0000A177
		public bool serverOnly
		{
			get
			{
				return this.m_ServerOnly;
			}
			set
			{
				this.m_ServerOnly = value;
			}
		}

		// Token: 0x17000057 RID: 87
		// (get) Token: 0x06000213 RID: 531 RVA: 0x0000BF84 File Offset: 0x0000A184
		// (set) Token: 0x06000214 RID: 532 RVA: 0x0000BF9F File Offset: 0x0000A19F
		public bool localPlayerAuthority
		{
			get
			{
				return this.m_LocalPlayerAuthority;
			}
			set
			{
				this.m_LocalPlayerAuthority = value;
			}
		}

		// Token: 0x17000058 RID: 88
		// (get) Token: 0x06000215 RID: 533 RVA: 0x0000BFAC File Offset: 0x0000A1AC
		public NetworkConnection clientAuthorityOwner
		{
			get
			{
				return this.m_ClientAuthorityOwner;
			}
		}

		// Token: 0x17000059 RID: 89
		// (get) Token: 0x06000216 RID: 534 RVA: 0x0000BFC8 File Offset: 0x0000A1C8
		public NetworkHash128 assetId
		{
			get
			{
				return this.m_AssetId;
			}
		}

		// Token: 0x06000217 RID: 535 RVA: 0x0000BFE4 File Offset: 0x0000A1E4
		internal void SetDynamicAssetId(NetworkHash128 newAssetId)
		{
			if (!this.m_AssetId.IsValid() || this.m_AssetId.Equals(newAssetId))
			{
				this.m_AssetId = newAssetId;
			}
			else if (LogFilter.logWarn)
			{
				Debug.LogWarning("SetDynamicAssetId object already has an assetId <" + this.m_AssetId + ">");
			}
		}

		// Token: 0x06000218 RID: 536 RVA: 0x0000C059 File Offset: 0x0000A259
		internal void SetClientOwner(NetworkConnection conn)
		{
			if (this.m_ClientAuthorityOwner != null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("SetClientOwner m_ClientAuthorityOwner already set!");
				}
			}
			this.m_ClientAuthorityOwner = conn;
			this.m_ClientAuthorityOwner.AddOwnedObject(this);
		}

		// Token: 0x06000219 RID: 537 RVA: 0x0000C092 File Offset: 0x0000A292
		internal void ClearClientOwner()
		{
			this.m_ClientAuthorityOwner = null;
		}

		// Token: 0x0600021A RID: 538 RVA: 0x0000C09C File Offset: 0x0000A29C
		internal void ForceAuthority(bool authority)
		{
			if (this.m_HasAuthority != authority)
			{
				this.m_HasAuthority = authority;
				if (authority)
				{
					this.OnStartAuthority();
				}
				else
				{
					this.OnStopAuthority();
				}
			}
		}

		// Token: 0x1700005A RID: 90
		// (get) Token: 0x0600021B RID: 539 RVA: 0x0000C0D4 File Offset: 0x0000A2D4
		public bool isLocalPlayer
		{
			get
			{
				return this.m_IsLocalPlayer;
			}
		}

		// Token: 0x1700005B RID: 91
		// (get) Token: 0x0600021C RID: 540 RVA: 0x0000C0F0 File Offset: 0x0000A2F0
		public short playerControllerId
		{
			get
			{
				return this.m_PlayerId;
			}
		}

		// Token: 0x1700005C RID: 92
		// (get) Token: 0x0600021D RID: 541 RVA: 0x0000C10C File Offset: 0x0000A30C
		public NetworkConnection connectionToServer
		{
			get
			{
				return this.m_ConnectionToServer;
			}
		}

		// Token: 0x1700005D RID: 93
		// (get) Token: 0x0600021E RID: 542 RVA: 0x0000C128 File Offset: 0x0000A328
		public NetworkConnection connectionToClient
		{
			get
			{
				return this.m_ConnectionToClient;
			}
		}

		// Token: 0x1700005E RID: 94
		// (get) Token: 0x0600021F RID: 543 RVA: 0x0000C144 File Offset: 0x0000A344
		public ReadOnlyCollection<NetworkConnection> observers
		{
			get
			{
				ReadOnlyCollection<NetworkConnection> readOnlyCollection;
				if (this.m_Observers == null)
				{
					readOnlyCollection = null;
				}
				else
				{
					readOnlyCollection = new ReadOnlyCollection<NetworkConnection>(this.m_Observers);
				}
				return readOnlyCollection;
			}
		}

		// Token: 0x06000220 RID: 544 RVA: 0x0000C178 File Offset: 0x0000A378
		internal static NetworkInstanceId GetNextNetworkId()
		{
			uint num = NetworkIdentity.s_NextNetworkId;
			NetworkIdentity.s_NextNetworkId += 1U;
			return new NetworkInstanceId(num);
		}

		// Token: 0x06000221 RID: 545 RVA: 0x0000C1A5 File Offset: 0x0000A3A5
		private void CacheBehaviours()
		{
			if (this.m_NetworkBehaviours == null)
			{
				this.m_NetworkBehaviours = base.GetComponents<NetworkBehaviour>();
			}
		}

		// Token: 0x06000222 RID: 546 RVA: 0x0000C1C1 File Offset: 0x0000A3C1
		internal static void AddNetworkId(uint id)
		{
			if (id >= NetworkIdentity.s_NextNetworkId)
			{
				NetworkIdentity.s_NextNetworkId = id + 1U;
			}
		}

		// Token: 0x06000223 RID: 547 RVA: 0x0000C1D9 File Offset: 0x0000A3D9
		internal void SetNetworkInstanceId(NetworkInstanceId newNetId)
		{
			this.m_NetId = newNetId;
			if (newNetId.Value == 0U)
			{
				this.m_IsServer = false;
			}
		}

		// Token: 0x06000224 RID: 548 RVA: 0x0000C1F8 File Offset: 0x0000A3F8
		public void ForceSceneId(int newSceneId)
		{
			this.m_SceneId = new NetworkSceneId((uint)newSceneId);
		}

		// Token: 0x06000225 RID: 549 RVA: 0x0000C207 File Offset: 0x0000A407
		internal void UpdateClientServer(bool isClientFlag, bool isServerFlag)
		{
			this.m_IsClient = this.m_IsClient || isClientFlag;
			this.m_IsServer = this.m_IsServer || isServerFlag;
		}

		// Token: 0x06000226 RID: 550 RVA: 0x0000C226 File Offset: 0x0000A426
		internal void SetNotLocalPlayer()
		{
			this.m_IsLocalPlayer = false;
			if (!NetworkServer.active || !NetworkServer.localClientActive)
			{
				this.m_HasAuthority = false;
			}
		}

		// Token: 0x06000227 RID: 551 RVA: 0x0000C251 File Offset: 0x0000A451
		internal void RemoveObserverInternal(NetworkConnection conn)
		{
			if (this.m_Observers != null)
			{
				this.m_Observers.Remove(conn);
				this.m_ObserverConnections.Remove(conn.connectionId);
			}
		}

		// Token: 0x06000228 RID: 552 RVA: 0x0000C280 File Offset: 0x0000A480
		private void OnDestroy()
		{
			if (this.m_IsServer && NetworkServer.active)
			{
				NetworkServer.Destroy(base.gameObject);
			}
		}

		// Token: 0x06000229 RID: 553 RVA: 0x0000C2A8 File Offset: 0x0000A4A8
		internal void OnStartServer(bool allowNonZeroNetId)
		{
			if (!this.m_IsServer)
			{
				this.m_IsServer = true;
				if (this.m_LocalPlayerAuthority)
				{
					this.m_HasAuthority = false;
				}
				else
				{
					this.m_HasAuthority = true;
				}
				this.m_Observers = new List<NetworkConnection>();
				this.m_ObserverConnections = new HashSet<int>();
				this.CacheBehaviours();
				if (this.netId.IsEmpty())
				{
					this.m_NetId = NetworkIdentity.GetNextNetworkId();
				}
				else if (!allowNonZeroNetId)
				{
					if (LogFilter.logError)
					{
						Debug.LogError(string.Concat(new object[] { "Object has non-zero netId ", this.netId, " for ", base.gameObject }));
					}
					return;
				}
				if (LogFilter.logDev)
				{
					Debug.Log(string.Concat(new object[] { "OnStartServer ", base.gameObject, " GUID:", this.netId }));
				}
				NetworkServer.instance.SetLocalObjectOnServer(this.netId, base.gameObject);
				for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
				{
					NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
					try
					{
						networkBehaviour.OnStartServer();
					}
					catch (Exception ex)
					{
						Debug.LogError("Exception in OnStartServer:" + ex.Message + " " + ex.StackTrace);
					}
				}
				if (NetworkClient.active && NetworkServer.localClientActive)
				{
					ClientScene.SetLocalObject(this.netId, base.gameObject);
					this.OnStartClient();
				}
				if (this.m_HasAuthority)
				{
					this.OnStartAuthority();
				}
			}
		}

		// Token: 0x0600022A RID: 554 RVA: 0x0000C48C File Offset: 0x0000A68C
		internal void OnStartClient()
		{
			if (!this.m_IsClient)
			{
				this.m_IsClient = true;
			}
			this.CacheBehaviours();
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[] { "OnStartClient ", base.gameObject, " GUID:", this.netId, " localPlayerAuthority:", this.localPlayerAuthority }));
			}
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				try
				{
					networkBehaviour.PreStartClient();
					networkBehaviour.OnStartClient();
				}
				catch (Exception ex)
				{
					Debug.LogError("Exception in OnStartClient:" + ex.Message + " " + ex.StackTrace);
				}
			}
		}

		// Token: 0x0600022B RID: 555 RVA: 0x0000C57C File Offset: 0x0000A77C
		internal void OnStartAuthority()
		{
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				try
				{
					networkBehaviour.OnStartAuthority();
				}
				catch (Exception ex)
				{
					Debug.LogError("Exception in OnStartAuthority:" + ex.Message + " " + ex.StackTrace);
				}
			}
		}

		// Token: 0x0600022C RID: 556 RVA: 0x0000C5F4 File Offset: 0x0000A7F4
		internal void OnStopAuthority()
		{
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				try
				{
					networkBehaviour.OnStopAuthority();
				}
				catch (Exception ex)
				{
					Debug.LogError("Exception in OnStopAuthority:" + ex.Message + " " + ex.StackTrace);
				}
			}
		}

		// Token: 0x0600022D RID: 557 RVA: 0x0000C66C File Offset: 0x0000A86C
		internal void OnSetLocalVisibility(bool vis)
		{
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				try
				{
					networkBehaviour.OnSetLocalVisibility(vis);
				}
				catch (Exception ex)
				{
					Debug.LogError("Exception in OnSetLocalVisibility:" + ex.Message + " " + ex.StackTrace);
				}
			}
		}

		// Token: 0x0600022E RID: 558 RVA: 0x0000C6E4 File Offset: 0x0000A8E4
		internal bool OnCheckObserver(NetworkConnection conn)
		{
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				try
				{
					if (!networkBehaviour.OnCheckObserver(conn))
					{
						return false;
					}
				}
				catch (Exception ex)
				{
					Debug.LogError("Exception in OnCheckObserver:" + ex.Message + " " + ex.StackTrace);
				}
			}
			return true;
		}

		// Token: 0x0600022F RID: 559 RVA: 0x0000C770 File Offset: 0x0000A970
		internal void UNetSerializeAllVars(NetworkWriter writer)
		{
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				networkBehaviour.OnSerialize(writer, true);
			}
		}

		// Token: 0x06000230 RID: 560 RVA: 0x0000C7AC File Offset: 0x0000A9AC
		internal void HandleClientAuthority(bool authority)
		{
			if (!this.localPlayerAuthority)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("HandleClientAuthority " + base.gameObject + " does not have localPlayerAuthority");
				}
			}
			else
			{
				this.ForceAuthority(authority);
			}
		}

		// Token: 0x06000231 RID: 561 RVA: 0x0000C7F8 File Offset: 0x0000A9F8
		private bool GetInvokeComponent(int cmdHash, Type invokeClass, out NetworkBehaviour invokeComponent)
		{
			NetworkBehaviour networkBehaviour = null;
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour2 = this.m_NetworkBehaviours[i];
				if (networkBehaviour2.GetType() == invokeClass || networkBehaviour2.GetType().IsSubclassOf(invokeClass))
				{
					networkBehaviour = networkBehaviour2;
					break;
				}
			}
			bool flag;
			if (networkBehaviour == null)
			{
				string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "Found no behaviour for incoming [", cmdHashHandlerName, "] on ", base.gameObject, ",  the server and client should have the same NetworkBehaviour instances [netId=", this.netId, "]." }));
				}
				invokeComponent = null;
				flag = false;
			}
			else
			{
				invokeComponent = networkBehaviour;
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000232 RID: 562 RVA: 0x0000C8D4 File Offset: 0x0000AAD4
		internal void HandleSyncEvent(int cmdHash, NetworkReader reader)
		{
			Type type;
			NetworkBehaviour.CmdDelegate cmdDelegate;
			NetworkBehaviour networkBehaviour;
			if (base.gameObject == null)
			{
				string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "SyncEvent [", cmdHashHandlerName, "] received for deleted object [netId=", this.netId, "]" }));
				}
			}
			else if (!NetworkBehaviour.GetInvokerForHashSyncEvent(cmdHash, out type, out cmdDelegate))
			{
				string cmdHashHandlerName2 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "Found no receiver for incoming [", cmdHashHandlerName2, "] on ", base.gameObject, ",  the server and client should have the same NetworkBehaviour instances [netId=", this.netId, "]." }));
				}
			}
			else if (!this.GetInvokeComponent(cmdHash, type, out networkBehaviour))
			{
				string cmdHashHandlerName3 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "SyncEvent [", cmdHashHandlerName3, "] handler not found [netId=", this.netId, "]" }));
				}
			}
			else
			{
				cmdDelegate(networkBehaviour, reader);
			}
		}

		// Token: 0x06000233 RID: 563 RVA: 0x0000CA2C File Offset: 0x0000AC2C
		internal void HandleSyncList(int cmdHash, NetworkReader reader)
		{
			Type type;
			NetworkBehaviour.CmdDelegate cmdDelegate;
			NetworkBehaviour networkBehaviour;
			if (base.gameObject == null)
			{
				string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "SyncList [", cmdHashHandlerName, "] received for deleted object [netId=", this.netId, "]" }));
				}
			}
			else if (!NetworkBehaviour.GetInvokerForHashSyncList(cmdHash, out type, out cmdDelegate))
			{
				string cmdHashHandlerName2 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "Found no receiver for incoming [", cmdHashHandlerName2, "] on ", base.gameObject, ",  the server and client should have the same NetworkBehaviour instances [netId=", this.netId, "]." }));
				}
			}
			else if (!this.GetInvokeComponent(cmdHash, type, out networkBehaviour))
			{
				string cmdHashHandlerName3 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "SyncList [", cmdHashHandlerName3, "] handler not found [netId=", this.netId, "]" }));
				}
			}
			else
			{
				cmdDelegate(networkBehaviour, reader);
			}
		}

		// Token: 0x06000234 RID: 564 RVA: 0x0000CB84 File Offset: 0x0000AD84
		internal void HandleCommand(int cmdHash, NetworkReader reader)
		{
			Type type;
			NetworkBehaviour.CmdDelegate cmdDelegate;
			NetworkBehaviour networkBehaviour;
			if (base.gameObject == null)
			{
				string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "Command [", cmdHashHandlerName, "] received for deleted object [netId=", this.netId, "]" }));
				}
			}
			else if (!NetworkBehaviour.GetInvokerForHashCommand(cmdHash, out type, out cmdDelegate))
			{
				string cmdHashHandlerName2 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "Found no receiver for incoming [", cmdHashHandlerName2, "] on ", base.gameObject, ",  the server and client should have the same NetworkBehaviour instances [netId=", this.netId, "]." }));
				}
			}
			else if (!this.GetInvokeComponent(cmdHash, type, out networkBehaviour))
			{
				string cmdHashHandlerName3 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "Command [", cmdHashHandlerName3, "] handler not found [netId=", this.netId, "]" }));
				}
			}
			else
			{
				cmdDelegate(networkBehaviour, reader);
			}
		}

		// Token: 0x06000235 RID: 565 RVA: 0x0000CCDC File Offset: 0x0000AEDC
		internal void HandleRPC(int cmdHash, NetworkReader reader)
		{
			Type type;
			NetworkBehaviour.CmdDelegate cmdDelegate;
			NetworkBehaviour networkBehaviour;
			if (base.gameObject == null)
			{
				string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "ClientRpc [", cmdHashHandlerName, "] received for deleted object [netId=", this.netId, "]" }));
				}
			}
			else if (!NetworkBehaviour.GetInvokerForHashClientRpc(cmdHash, out type, out cmdDelegate))
			{
				string cmdHashHandlerName2 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "Found no receiver for incoming [", cmdHashHandlerName2, "] on ", base.gameObject, ",  the server and client should have the same NetworkBehaviour instances [netId=", this.netId, "]." }));
				}
			}
			else if (!this.GetInvokeComponent(cmdHash, type, out networkBehaviour))
			{
				string cmdHashHandlerName3 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
				if (LogFilter.logWarn)
				{
					Debug.LogWarning(string.Concat(new object[] { "ClientRpc [", cmdHashHandlerName3, "] handler not found [netId=", this.netId, "]" }));
				}
			}
			else
			{
				cmdDelegate(networkBehaviour, reader);
			}
		}

		// Token: 0x06000236 RID: 566 RVA: 0x0000CE34 File Offset: 0x0000B034
		internal void UNetUpdate()
		{
			uint num = 0U;
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				int dirtyChannel = networkBehaviour.GetDirtyChannel();
				if (dirtyChannel != -1)
				{
					num |= 1U << dirtyChannel;
				}
			}
			if (num != 0U)
			{
				int j = 0;
				while (j < NetworkServer.numChannels)
				{
					if ((num & (1U << j)) != 0U)
					{
						NetworkIdentity.s_UpdateWriter.StartMessage(8);
						NetworkIdentity.s_UpdateWriter.Write(this.netId);
						bool flag = false;
						for (int k = 0; k < this.m_NetworkBehaviours.Length; k++)
						{
							short position = NetworkIdentity.s_UpdateWriter.Position;
							NetworkBehaviour networkBehaviour2 = this.m_NetworkBehaviours[k];
							if (networkBehaviour2.GetDirtyChannel() != j)
							{
								networkBehaviour2.OnSerialize(NetworkIdentity.s_UpdateWriter, false);
							}
							else
							{
								if (networkBehaviour2.OnSerialize(NetworkIdentity.s_UpdateWriter, false))
								{
									networkBehaviour2.ClearAllDirtyBits();
									flag = true;
								}
								if (NetworkIdentity.s_UpdateWriter.Position - position > (short)NetworkServer.maxPacketSize)
								{
									if (LogFilter.logWarn)
									{
										Debug.LogWarning(string.Concat(new object[]
										{
											"Large state update of ",
											(int)(NetworkIdentity.s_UpdateWriter.Position - position),
											" bytes for netId:",
											this.netId,
											" from script:",
											networkBehaviour2
										}));
									}
								}
							}
						}
						if (flag)
						{
							NetworkIdentity.s_UpdateWriter.FinishMessage();
							NetworkServer.SendWriterToReady(base.gameObject, NetworkIdentity.s_UpdateWriter, j);
						}
					}
					IL_197:
					j++;
					continue;
					goto IL_197;
				}
			}
		}

		// Token: 0x06000237 RID: 567 RVA: 0x0000CFEC File Offset: 0x0000B1EC
		internal void OnUpdateVars(NetworkReader reader, bool initialState)
		{
			if (initialState && this.m_NetworkBehaviours == null)
			{
				this.m_NetworkBehaviours = base.GetComponents<NetworkBehaviour>();
			}
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				networkBehaviour.OnDeserialize(reader, initialState);
			}
		}

		// Token: 0x06000238 RID: 568 RVA: 0x0000D048 File Offset: 0x0000B248
		internal void SetLocalPlayer(short localPlayerControllerId)
		{
			this.m_IsLocalPlayer = true;
			this.m_PlayerId = localPlayerControllerId;
			bool hasAuthority = this.m_HasAuthority;
			if (this.localPlayerAuthority)
			{
				this.m_HasAuthority = true;
			}
			for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
				networkBehaviour.OnStartLocalPlayer();
				if (this.localPlayerAuthority && !hasAuthority)
				{
					networkBehaviour.OnStartAuthority();
				}
			}
		}

		// Token: 0x06000239 RID: 569 RVA: 0x0000D0C2 File Offset: 0x0000B2C2
		internal void SetConnectionToServer(NetworkConnection conn)
		{
			this.m_ConnectionToServer = conn;
		}

		// Token: 0x0600023A RID: 570 RVA: 0x0000D0CC File Offset: 0x0000B2CC
		internal void SetConnectionToClient(NetworkConnection conn, short newPlayerControllerId)
		{
			this.m_PlayerId = newPlayerControllerId;
			this.m_ConnectionToClient = conn;
		}

		// Token: 0x0600023B RID: 571 RVA: 0x0000D0E0 File Offset: 0x0000B2E0
		internal void OnNetworkDestroy()
		{
			int num = 0;
			while (this.m_NetworkBehaviours != null && num < this.m_NetworkBehaviours.Length)
			{
				NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[num];
				networkBehaviour.OnNetworkDestroy();
				num++;
			}
			this.m_IsServer = false;
		}

		// Token: 0x0600023C RID: 572 RVA: 0x0000D12C File Offset: 0x0000B32C
		internal void ClearObservers()
		{
			if (this.m_Observers != null)
			{
				int count = this.m_Observers.Count;
				for (int i = 0; i < count; i++)
				{
					NetworkConnection networkConnection = this.m_Observers[i];
					networkConnection.RemoveFromVisList(this, true);
				}
				this.m_Observers.Clear();
				this.m_ObserverConnections.Clear();
			}
		}

		// Token: 0x0600023D RID: 573 RVA: 0x0000D194 File Offset: 0x0000B394
		internal void AddObserver(NetworkConnection conn)
		{
			if (this.m_Observers == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("AddObserver for " + base.gameObject + " observer list is null");
				}
			}
			else if (this.m_ObserverConnections.Contains(conn.connectionId))
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "Duplicate observer ", conn.address, " added for ", base.gameObject }));
				}
			}
			else
			{
				if (LogFilter.logDev)
				{
					Debug.Log(string.Concat(new object[] { "Added observer ", conn.address, " added for ", base.gameObject }));
				}
				this.m_Observers.Add(conn);
				this.m_ObserverConnections.Add(conn.connectionId);
				conn.AddToVisList(this);
			}
		}

		// Token: 0x0600023E RID: 574 RVA: 0x0000D296 File Offset: 0x0000B496
		internal void RemoveObserver(NetworkConnection conn)
		{
			if (this.m_Observers != null)
			{
				this.m_Observers.Remove(conn);
				this.m_ObserverConnections.Remove(conn.connectionId);
				conn.RemoveFromVisList(this, false);
			}
		}

		// Token: 0x0600023F RID: 575 RVA: 0x0000D2D0 File Offset: 0x0000B4D0
		public void RebuildObservers(bool initialize)
		{
			if (this.m_Observers != null)
			{
				bool flag = false;
				bool flag2 = false;
				HashSet<NetworkConnection> hashSet = new HashSet<NetworkConnection>();
				HashSet<NetworkConnection> hashSet2 = new HashSet<NetworkConnection>(this.m_Observers);
				for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
				{
					NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
					flag2 |= networkBehaviour.OnRebuildObservers(hashSet, initialize);
				}
				if (!flag2)
				{
					if (initialize)
					{
						for (int j = 0; j < NetworkServer.connections.Count; j++)
						{
							NetworkConnection networkConnection = NetworkServer.connections[j];
							if (networkConnection != null)
							{
								if (networkConnection.isReady)
								{
									this.AddObserver(networkConnection);
								}
							}
						}
						for (int k = 0; k < NetworkServer.localConnections.Count; k++)
						{
							NetworkConnection networkConnection2 = NetworkServer.localConnections[k];
							if (networkConnection2 != null)
							{
								if (networkConnection2.isReady)
								{
									this.AddObserver(networkConnection2);
								}
							}
						}
					}
				}
				else
				{
					foreach (NetworkConnection networkConnection3 in hashSet)
					{
						if (networkConnection3 != null)
						{
							if (!networkConnection3.isReady)
							{
								if (LogFilter.logWarn)
								{
									Debug.LogWarning(string.Concat(new object[] { "Observer is not ready for ", base.gameObject, " ", networkConnection3 }));
								}
							}
							else if (initialize || !hashSet2.Contains(networkConnection3))
							{
								networkConnection3.AddToVisList(this);
								if (LogFilter.logDebug)
								{
									Debug.Log(string.Concat(new object[] { "New Observer for ", base.gameObject, " ", networkConnection3 }));
								}
								flag = true;
							}
						}
					}
					foreach (NetworkConnection networkConnection4 in hashSet2)
					{
						if (!hashSet.Contains(networkConnection4))
						{
							networkConnection4.RemoveFromVisList(this, false);
							if (LogFilter.logDebug)
							{
								Debug.Log(string.Concat(new object[] { "Removed Observer for ", base.gameObject, " ", networkConnection4 }));
							}
							flag = true;
						}
					}
					if (initialize)
					{
						for (int l = 0; l < NetworkServer.localConnections.Count; l++)
						{
							if (!hashSet.Contains(NetworkServer.localConnections[l]))
							{
								this.OnSetLocalVisibility(false);
							}
						}
					}
					if (flag)
					{
						this.m_Observers = new List<NetworkConnection>(hashSet);
						this.m_ObserverConnections.Clear();
						for (int m = 0; m < this.m_Observers.Count; m++)
						{
							this.m_ObserverConnections.Add(this.m_Observers[m].connectionId);
						}
					}
				}
			}
		}

		// Token: 0x06000240 RID: 576 RVA: 0x0000D62C File Offset: 0x0000B82C
		public bool RemoveClientAuthority(NetworkConnection conn)
		{
			bool flag;
			if (!this.isServer)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RemoveClientAuthority can only be call on the server for spawned objects.");
				}
				flag = false;
			}
			else if (this.connectionToClient != null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RemoveClientAuthority cannot remove authority for a player object");
				}
				flag = false;
			}
			else if (this.m_ClientAuthorityOwner == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RemoveClientAuthority for " + base.gameObject + " has no clientAuthority owner.");
				}
				flag = false;
			}
			else if (this.m_ClientAuthorityOwner != conn)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RemoveClientAuthority for " + base.gameObject + " has different owner.");
				}
				flag = false;
			}
			else
			{
				this.m_ClientAuthorityOwner.RemoveOwnedObject(this);
				this.m_ClientAuthorityOwner = null;
				this.ForceAuthority(true);
				conn.Send(15, new ClientAuthorityMessage
				{
					netId = this.netId,
					authority = false
				});
				if (NetworkIdentity.clientAuthorityCallback != null)
				{
					NetworkIdentity.clientAuthorityCallback(conn, this, false);
				}
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000241 RID: 577 RVA: 0x0000D760 File Offset: 0x0000B960
		public bool AssignClientAuthority(NetworkConnection conn)
		{
			bool flag;
			if (!this.isServer)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("AssignClientAuthority can only be call on the server for spawned objects.");
				}
				flag = false;
			}
			else if (!this.localPlayerAuthority)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("AssignClientAuthority can only be used for NetworkIdentity component with LocalPlayerAuthority set.");
				}
				flag = false;
			}
			else if (this.m_ClientAuthorityOwner != null && conn != this.m_ClientAuthorityOwner)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("AssignClientAuthority for " + base.gameObject + " already has an owner. Use RemoveClientAuthority() first.");
				}
				flag = false;
			}
			else if (conn == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("AssignClientAuthority for " + base.gameObject + " owner cannot be null. Use RemoveClientAuthority() instead.");
				}
				flag = false;
			}
			else
			{
				this.m_ClientAuthorityOwner = conn;
				this.m_ClientAuthorityOwner.AddOwnedObject(this);
				this.ForceAuthority(false);
				conn.Send(15, new ClientAuthorityMessage
				{
					netId = this.netId,
					authority = true
				});
				if (NetworkIdentity.clientAuthorityCallback != null)
				{
					NetworkIdentity.clientAuthorityCallback(conn, this, true);
				}
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000242 RID: 578 RVA: 0x0000D897 File Offset: 0x0000BA97
		internal void MarkForReset()
		{
			this.m_Reset = true;
		}

		// Token: 0x06000243 RID: 579 RVA: 0x0000D8A4 File Offset: 0x0000BAA4
		internal void Reset()
		{
			if (this.m_Reset)
			{
				this.m_Reset = false;
				this.m_IsServer = false;
				this.m_IsClient = false;
				this.m_HasAuthority = false;
				this.m_NetId = NetworkInstanceId.Zero;
				this.m_IsLocalPlayer = false;
				this.m_ConnectionToServer = null;
				this.m_ConnectionToClient = null;
				this.m_PlayerId = -1;
				this.m_NetworkBehaviours = null;
				this.ClearObservers();
				this.m_ClientAuthorityOwner = null;
			}
		}

		// Token: 0x06000244 RID: 580 RVA: 0x0000D919 File Offset: 0x0000BB19
		internal static void UNetStaticUpdate()
		{
			NetworkServer.Update();
			NetworkClient.UpdateClients();
			NetworkManager.UpdateScene();
		}

		// Token: 0x0400012D RID: 301
		[SerializeField]
		private NetworkSceneId m_SceneId;

		// Token: 0x0400012E RID: 302
		[SerializeField]
		private NetworkHash128 m_AssetId;

		// Token: 0x0400012F RID: 303
		[SerializeField]
		private bool m_ServerOnly;

		// Token: 0x04000130 RID: 304
		[SerializeField]
		private bool m_LocalPlayerAuthority;

		// Token: 0x04000131 RID: 305
		private bool m_IsClient;

		// Token: 0x04000132 RID: 306
		private bool m_IsServer;

		// Token: 0x04000133 RID: 307
		private bool m_HasAuthority;

		// Token: 0x04000134 RID: 308
		private NetworkInstanceId m_NetId;

		// Token: 0x04000135 RID: 309
		private bool m_IsLocalPlayer;

		// Token: 0x04000136 RID: 310
		private NetworkConnection m_ConnectionToServer;

		// Token: 0x04000137 RID: 311
		private NetworkConnection m_ConnectionToClient;

		// Token: 0x04000138 RID: 312
		private short m_PlayerId = -1;

		// Token: 0x04000139 RID: 313
		private NetworkBehaviour[] m_NetworkBehaviours;

		// Token: 0x0400013A RID: 314
		private HashSet<int> m_ObserverConnections;

		// Token: 0x0400013B RID: 315
		private List<NetworkConnection> m_Observers;

		// Token: 0x0400013C RID: 316
		private NetworkConnection m_ClientAuthorityOwner;

		// Token: 0x0400013D RID: 317
		private bool m_Reset = false;

		// Token: 0x0400013E RID: 318
		private static uint s_NextNetworkId = 1U;

		// Token: 0x0400013F RID: 319
		private static NetworkWriter s_UpdateWriter = new NetworkWriter();

		// Token: 0x04000140 RID: 320
		public static NetworkIdentity.ClientAuthorityCallback clientAuthorityCallback;

		// Token: 0x02000046 RID: 70
		// (Invoke) Token: 0x06000247 RID: 583
		public delegate void ClientAuthorityCallback(NetworkConnection conn, NetworkIdentity uv, bool authorityState);
	}
}