using System;
using System.Collections.Generic;
using System.ComponentModel;

namespace UnityEngine.Networking
{
	// Token: 0x02000034 RID: 52
	[RequireComponent(typeof(NetworkIdentity))]
	[AddComponentMenu("")]
	public class NetworkBehaviour : MonoBehaviour
	{
		// Token: 0x1700001D RID: 29
		// (get) Token: 0x06000100 RID: 256 RVA: 0x00008878 File Offset: 0x00006A78
		public bool localPlayerAuthority
		{
			get
			{
				return this.myView.localPlayerAuthority;
			}
		}

		// Token: 0x1700001E RID: 30
		// (get) Token: 0x06000101 RID: 257 RVA: 0x00008898 File Offset: 0x00006A98
		public bool isServer
		{
			get
			{
				return this.myView.isServer;
			}
		}

		// Token: 0x1700001F RID: 31
		// (get) Token: 0x06000102 RID: 258 RVA: 0x000088B8 File Offset: 0x00006AB8
		public bool isClient
		{
			get
			{
				return this.myView.isClient;
			}
		}

		// Token: 0x17000020 RID: 32
		// (get) Token: 0x06000103 RID: 259 RVA: 0x000088D8 File Offset: 0x00006AD8
		public bool isLocalPlayer
		{
			get
			{
				return this.myView.isLocalPlayer;
			}
		}

		// Token: 0x17000021 RID: 33
		// (get) Token: 0x06000104 RID: 260 RVA: 0x000088F8 File Offset: 0x00006AF8
		public bool hasAuthority
		{
			get
			{
				return this.myView.hasAuthority;
			}
		}

		// Token: 0x17000022 RID: 34
		// (get) Token: 0x06000105 RID: 261 RVA: 0x00008918 File Offset: 0x00006B18
		public NetworkInstanceId netId
		{
			get
			{
				return this.myView.netId;
			}
		}

		// Token: 0x17000023 RID: 35
		// (get) Token: 0x06000106 RID: 262 RVA: 0x00008938 File Offset: 0x00006B38
		public NetworkConnection connectionToServer
		{
			get
			{
				return this.myView.connectionToServer;
			}
		}

		// Token: 0x17000024 RID: 36
		// (get) Token: 0x06000107 RID: 263 RVA: 0x00008958 File Offset: 0x00006B58
		public NetworkConnection connectionToClient
		{
			get
			{
				return this.myView.connectionToClient;
			}
		}

		// Token: 0x17000025 RID: 37
		// (get) Token: 0x06000108 RID: 264 RVA: 0x00008978 File Offset: 0x00006B78
		public short playerControllerId
		{
			get
			{
				return this.myView.playerControllerId;
			}
		}

		// Token: 0x17000026 RID: 38
		// (get) Token: 0x06000109 RID: 265 RVA: 0x00008998 File Offset: 0x00006B98
		protected uint syncVarDirtyBits
		{
			get
			{
				return this.m_SyncVarDirtyBits;
			}
		}

		// Token: 0x17000027 RID: 39
		// (get) Token: 0x0600010A RID: 266 RVA: 0x000089B4 File Offset: 0x00006BB4
		// (set) Token: 0x0600010B RID: 267 RVA: 0x000089CF File Offset: 0x00006BCF
		protected bool syncVarHookGuard
		{
			get
			{
				return this.m_SyncVarGuard;
			}
			set
			{
				this.m_SyncVarGuard = value;
			}
		}

		// Token: 0x17000028 RID: 40
		// (get) Token: 0x0600010C RID: 268 RVA: 0x000089DC File Offset: 0x00006BDC
		internal NetworkIdentity netIdentity
		{
			get
			{
				return this.myView;
			}
		}

		// Token: 0x17000029 RID: 41
		// (get) Token: 0x0600010D RID: 269 RVA: 0x000089F8 File Offset: 0x00006BF8
		private NetworkIdentity myView
		{
			get
			{
				NetworkIdentity networkIdentity;
				if (this.m_MyView == null)
				{
					this.m_MyView = base.GetComponent<NetworkIdentity>();
					if (this.m_MyView == null)
					{
						if (LogFilter.logError)
						{
							Debug.LogError("There is no NetworkIdentity on this object. Please add one.");
						}
					}
					networkIdentity = this.m_MyView;
				}
				else
				{
					networkIdentity = this.m_MyView;
				}
				return networkIdentity;
			}
		}

		// Token: 0x0600010E RID: 270 RVA: 0x00008A68 File Offset: 0x00006C68
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected void SendCommandInternal(NetworkWriter writer, int channelId, string cmdName)
		{
			if (!this.isLocalPlayer && !this.hasAuthority)
			{
				if (LogFilter.logWarn)
				{
					Debug.LogWarning("Trying to send command for object without authority.");
				}
			}
			else if (ClientScene.readyConnection == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("Send command attempted with no client running [client=" + this.connectionToServer + "].");
				}
			}
			else
			{
				writer.FinishMessage();
				ClientScene.readyConnection.SendWriter(writer, channelId);
			}
		}

		// Token: 0x0600010F RID: 271 RVA: 0x00008AF4 File Offset: 0x00006CF4
		[EditorBrowsable(EditorBrowsableState.Never)]
		public virtual bool InvokeCommand(int cmdHash, NetworkReader reader)
		{
			return this.InvokeCommandDelegate(cmdHash, reader);
		}

		// Token: 0x06000110 RID: 272 RVA: 0x00008B1F File Offset: 0x00006D1F
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected void SendRPCInternal(NetworkWriter writer, int channelId, string rpcName)
		{
			if (!this.isServer)
			{
				if (LogFilter.logWarn)
				{
					Debug.LogWarning("ClientRpc call on un-spawned object");
				}
			}
			else
			{
				writer.FinishMessage();
				NetworkServer.SendWriterToReady(base.gameObject, writer, channelId);
			}
		}

		// Token: 0x06000111 RID: 273 RVA: 0x00008B5C File Offset: 0x00006D5C
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected void SendTargetRPCInternal(NetworkConnection conn, NetworkWriter writer, int channelId, string rpcName)
		{
			if (!this.isServer)
			{
				if (LogFilter.logWarn)
				{
					Debug.LogWarning("TargetRpc call on un-spawned object");
				}
			}
			else
			{
				writer.FinishMessage();
				conn.SendWriter(writer, channelId);
			}
		}

		// Token: 0x06000112 RID: 274 RVA: 0x00008B98 File Offset: 0x00006D98
		[EditorBrowsable(EditorBrowsableState.Never)]
		public virtual bool InvokeRPC(int cmdHash, NetworkReader reader)
		{
			return this.InvokeRpcDelegate(cmdHash, reader);
		}

		// Token: 0x06000113 RID: 275 RVA: 0x00008BC3 File Offset: 0x00006DC3
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected void SendEventInternal(NetworkWriter writer, int channelId, string eventName)
		{
			if (!NetworkServer.active)
			{
				if (LogFilter.logWarn)
				{
					Debug.LogWarning("SendEvent no server?");
				}
			}
			else
			{
				writer.FinishMessage();
				NetworkServer.SendWriterToReady(base.gameObject, writer, channelId);
			}
		}

		// Token: 0x06000114 RID: 276 RVA: 0x00008C00 File Offset: 0x00006E00
		[EditorBrowsable(EditorBrowsableState.Never)]
		public virtual bool InvokeSyncEvent(int cmdHash, NetworkReader reader)
		{
			return this.InvokeSyncEventDelegate(cmdHash, reader);
		}

		// Token: 0x06000115 RID: 277 RVA: 0x00008C2C File Offset: 0x00006E2C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public virtual bool InvokeSyncList(int cmdHash, NetworkReader reader)
		{
			return this.InvokeSyncListDelegate(cmdHash, reader);
		}

		// Token: 0x06000116 RID: 278 RVA: 0x00008C58 File Offset: 0x00006E58
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected static void RegisterCommandDelegate(Type invokeClass, int cmdHash, NetworkBehaviour.CmdDelegate func)
		{
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				NetworkBehaviour.Invoker invoker = new NetworkBehaviour.Invoker();
				invoker.invokeType = NetworkBehaviour.UNetInvokeType.Command;
				invoker.invokeClass = invokeClass;
				invoker.invokeFunction = func;
				NetworkBehaviour.s_CmdHandlerDelegates[cmdHash] = invoker;
				if (LogFilter.logDev)
				{
					Debug.Log(string.Concat(new object[]
					{
						"RegisterCommandDelegate hash:",
						cmdHash,
						" ",
						func.GetMethodName()
					}));
				}
			}
		}

		// Token: 0x06000117 RID: 279 RVA: 0x00008CE4 File Offset: 0x00006EE4
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected static void RegisterRpcDelegate(Type invokeClass, int cmdHash, NetworkBehaviour.CmdDelegate func)
		{
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				NetworkBehaviour.Invoker invoker = new NetworkBehaviour.Invoker();
				invoker.invokeType = NetworkBehaviour.UNetInvokeType.ClientRpc;
				invoker.invokeClass = invokeClass;
				invoker.invokeFunction = func;
				NetworkBehaviour.s_CmdHandlerDelegates[cmdHash] = invoker;
				if (LogFilter.logDev)
				{
					Debug.Log(string.Concat(new object[]
					{
						"RegisterRpcDelegate hash:",
						cmdHash,
						" ",
						func.GetMethodName()
					}));
				}
			}
		}

		// Token: 0x06000118 RID: 280 RVA: 0x00008D70 File Offset: 0x00006F70
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected static void RegisterEventDelegate(Type invokeClass, int cmdHash, NetworkBehaviour.CmdDelegate func)
		{
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				NetworkBehaviour.Invoker invoker = new NetworkBehaviour.Invoker();
				invoker.invokeType = NetworkBehaviour.UNetInvokeType.SyncEvent;
				invoker.invokeClass = invokeClass;
				invoker.invokeFunction = func;
				NetworkBehaviour.s_CmdHandlerDelegates[cmdHash] = invoker;
				if (LogFilter.logDev)
				{
					Debug.Log(string.Concat(new object[]
					{
						"RegisterEventDelegate hash:",
						cmdHash,
						" ",
						func.GetMethodName()
					}));
				}
			}
		}

		// Token: 0x06000119 RID: 281 RVA: 0x00008DFC File Offset: 0x00006FFC
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected static void RegisterSyncListDelegate(Type invokeClass, int cmdHash, NetworkBehaviour.CmdDelegate func)
		{
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				NetworkBehaviour.Invoker invoker = new NetworkBehaviour.Invoker();
				invoker.invokeType = NetworkBehaviour.UNetInvokeType.SyncList;
				invoker.invokeClass = invokeClass;
				invoker.invokeFunction = func;
				NetworkBehaviour.s_CmdHandlerDelegates[cmdHash] = invoker;
				if (LogFilter.logDev)
				{
					Debug.Log(string.Concat(new object[]
					{
						"RegisterSyncListDelegate hash:",
						cmdHash,
						" ",
						func.GetMethodName()
					}));
				}
			}
		}

		// Token: 0x0600011A RID: 282 RVA: 0x00008E88 File Offset: 0x00007088
		internal static string GetInvoker(int cmdHash)
		{
			string text;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				text = null;
			}
			else
			{
				NetworkBehaviour.Invoker invoker = NetworkBehaviour.s_CmdHandlerDelegates[cmdHash];
				text = invoker.DebugString();
			}
			return text;
		}

		// Token: 0x0600011B RID: 283 RVA: 0x00008EC8 File Offset: 0x000070C8
		internal static bool GetInvokerForHashCommand(int cmdHash, out Type invokeClass, out NetworkBehaviour.CmdDelegate invokeFunction)
		{
			return NetworkBehaviour.GetInvokerForHash(cmdHash, NetworkBehaviour.UNetInvokeType.Command, out invokeClass, out invokeFunction);
		}

		// Token: 0x0600011C RID: 284 RVA: 0x00008EE8 File Offset: 0x000070E8
		internal static bool GetInvokerForHashClientRpc(int cmdHash, out Type invokeClass, out NetworkBehaviour.CmdDelegate invokeFunction)
		{
			return NetworkBehaviour.GetInvokerForHash(cmdHash, NetworkBehaviour.UNetInvokeType.ClientRpc, out invokeClass, out invokeFunction);
		}

		// Token: 0x0600011D RID: 285 RVA: 0x00008F08 File Offset: 0x00007108
		internal static bool GetInvokerForHashSyncList(int cmdHash, out Type invokeClass, out NetworkBehaviour.CmdDelegate invokeFunction)
		{
			return NetworkBehaviour.GetInvokerForHash(cmdHash, NetworkBehaviour.UNetInvokeType.SyncList, out invokeClass, out invokeFunction);
		}

		// Token: 0x0600011E RID: 286 RVA: 0x00008F28 File Offset: 0x00007128
		internal static bool GetInvokerForHashSyncEvent(int cmdHash, out Type invokeClass, out NetworkBehaviour.CmdDelegate invokeFunction)
		{
			return NetworkBehaviour.GetInvokerForHash(cmdHash, NetworkBehaviour.UNetInvokeType.SyncEvent, out invokeClass, out invokeFunction);
		}

		// Token: 0x0600011F RID: 287 RVA: 0x00008F48 File Offset: 0x00007148
		private static bool GetInvokerForHash(int cmdHash, NetworkBehaviour.UNetInvokeType invokeType, out Type invokeClass, out NetworkBehaviour.CmdDelegate invokeFunction)
		{
			NetworkBehaviour.Invoker invoker = null;
			bool flag;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.TryGetValue(cmdHash, out invoker))
			{
				if (LogFilter.logDev)
				{
					Debug.Log("GetInvokerForHash hash:" + cmdHash + " not found");
				}
				invokeClass = null;
				invokeFunction = null;
				flag = false;
			}
			else if (invoker == null)
			{
				if (LogFilter.logDev)
				{
					Debug.Log("GetInvokerForHash hash:" + cmdHash + " invoker null");
				}
				invokeClass = null;
				invokeFunction = null;
				flag = false;
			}
			else if (invoker.invokeType != invokeType)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("GetInvokerForHash hash:" + cmdHash + " mismatched invokeType");
				}
				invokeClass = null;
				invokeFunction = null;
				flag = false;
			}
			else
			{
				invokeClass = invoker.invokeClass;
				invokeFunction = invoker.invokeFunction;
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000120 RID: 288 RVA: 0x00009030 File Offset: 0x00007230
		internal static void DumpInvokers()
		{
			Debug.Log("DumpInvokers size:" + NetworkBehaviour.s_CmdHandlerDelegates.Count);
			foreach (KeyValuePair<int, NetworkBehaviour.Invoker> keyValuePair in NetworkBehaviour.s_CmdHandlerDelegates)
			{
				Debug.Log(string.Concat(new object[]
				{
					"  Invoker:",
					keyValuePair.Value.invokeClass,
					":",
					keyValuePair.Value.invokeFunction.GetMethodName(),
					" ",
					keyValuePair.Value.invokeType,
					" ",
					keyValuePair.Key
				}));
			}
		}

		// Token: 0x06000121 RID: 289 RVA: 0x0000911C File Offset: 0x0000731C
		internal bool ContainsCommandDelegate(int cmdHash)
		{
			return NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash);
		}

		// Token: 0x06000122 RID: 290 RVA: 0x0000913C File Offset: 0x0000733C
		internal bool InvokeCommandDelegate(int cmdHash, NetworkReader reader)
		{
			bool flag;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				flag = false;
			}
			else
			{
				NetworkBehaviour.Invoker invoker = NetworkBehaviour.s_CmdHandlerDelegates[cmdHash];
				if (invoker.invokeType != NetworkBehaviour.UNetInvokeType.Command)
				{
					flag = false;
				}
				else
				{
					if (base.GetType() != invoker.invokeClass)
					{
						if (!base.GetType().IsSubclassOf(invoker.invokeClass))
						{
							return false;
						}
					}
					invoker.invokeFunction(this, reader);
					flag = true;
				}
			}
			return flag;
		}

		// Token: 0x06000123 RID: 291 RVA: 0x000091D0 File Offset: 0x000073D0
		internal bool InvokeRpcDelegate(int cmdHash, NetworkReader reader)
		{
			bool flag;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				flag = false;
			}
			else
			{
				NetworkBehaviour.Invoker invoker = NetworkBehaviour.s_CmdHandlerDelegates[cmdHash];
				if (invoker.invokeType != NetworkBehaviour.UNetInvokeType.ClientRpc)
				{
					flag = false;
				}
				else
				{
					if (base.GetType() != invoker.invokeClass)
					{
						if (!base.GetType().IsSubclassOf(invoker.invokeClass))
						{
							return false;
						}
					}
					invoker.invokeFunction(this, reader);
					flag = true;
				}
			}
			return flag;
		}

		// Token: 0x06000124 RID: 292 RVA: 0x00009264 File Offset: 0x00007464
		internal bool InvokeSyncEventDelegate(int cmdHash, NetworkReader reader)
		{
			bool flag;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				flag = false;
			}
			else
			{
				NetworkBehaviour.Invoker invoker = NetworkBehaviour.s_CmdHandlerDelegates[cmdHash];
				if (invoker.invokeType != NetworkBehaviour.UNetInvokeType.SyncEvent)
				{
					flag = false;
				}
				else
				{
					invoker.invokeFunction(this, reader);
					flag = true;
				}
			}
			return flag;
		}

		// Token: 0x06000125 RID: 293 RVA: 0x000092C0 File Offset: 0x000074C0
		internal bool InvokeSyncListDelegate(int cmdHash, NetworkReader reader)
		{
			bool flag;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				flag = false;
			}
			else
			{
				NetworkBehaviour.Invoker invoker = NetworkBehaviour.s_CmdHandlerDelegates[cmdHash];
				if (invoker.invokeType != NetworkBehaviour.UNetInvokeType.SyncList)
				{
					flag = false;
				}
				else if (base.GetType() != invoker.invokeClass)
				{
					flag = false;
				}
				else
				{
					invoker.invokeFunction(this, reader);
					flag = true;
				}
			}
			return flag;
		}

		// Token: 0x06000126 RID: 294 RVA: 0x00009334 File Offset: 0x00007534
		internal static string GetCmdHashHandlerName(int cmdHash)
		{
			string text;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				text = cmdHash.ToString();
			}
			else
			{
				NetworkBehaviour.Invoker invoker = NetworkBehaviour.s_CmdHandlerDelegates[cmdHash];
				text = invoker.invokeType + ":" + invoker.invokeFunction.GetMethodName();
			}
			return text;
		}

		// Token: 0x06000127 RID: 295 RVA: 0x0000939C File Offset: 0x0000759C
		private static string GetCmdHashPrefixName(int cmdHash, string prefix)
		{
			string text;
			if (!NetworkBehaviour.s_CmdHandlerDelegates.ContainsKey(cmdHash))
			{
				text = cmdHash.ToString();
			}
			else
			{
				NetworkBehaviour.Invoker invoker = NetworkBehaviour.s_CmdHandlerDelegates[cmdHash];
				string text2 = invoker.invokeFunction.GetMethodName();
				int num = text2.IndexOf(prefix);
				if (num > -1)
				{
					text2 = text2.Substring(prefix.Length);
				}
				text = text2;
			}
			return text;
		}

		// Token: 0x06000128 RID: 296 RVA: 0x0000940C File Offset: 0x0000760C
		internal static string GetCmdHashCmdName(int cmdHash)
		{
			return NetworkBehaviour.GetCmdHashPrefixName(cmdHash, "InvokeCmd");
		}

		// Token: 0x06000129 RID: 297 RVA: 0x0000942C File Offset: 0x0000762C
		internal static string GetCmdHashRpcName(int cmdHash)
		{
			return NetworkBehaviour.GetCmdHashPrefixName(cmdHash, "InvokeRpc");
		}

		// Token: 0x0600012A RID: 298 RVA: 0x0000944C File Offset: 0x0000764C
		internal static string GetCmdHashEventName(int cmdHash)
		{
			return NetworkBehaviour.GetCmdHashPrefixName(cmdHash, "InvokeSyncEvent");
		}

		// Token: 0x0600012B RID: 299 RVA: 0x0000946C File Offset: 0x0000766C
		internal static string GetCmdHashListName(int cmdHash)
		{
			return NetworkBehaviour.GetCmdHashPrefixName(cmdHash, "InvokeSyncList");
		}

		// Token: 0x0600012C RID: 300 RVA: 0x0000948C File Offset: 0x0000768C
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected void SetSyncVarGameObject(GameObject newGameObject, ref GameObject gameObjectField, uint dirtyBit, ref NetworkInstanceId netIdField)
		{
			if (!this.m_SyncVarGuard)
			{
				NetworkInstanceId networkInstanceId = default(NetworkInstanceId);
				if (newGameObject != null)
				{
					NetworkIdentity component = newGameObject.GetComponent<NetworkIdentity>();
					if (component != null)
					{
						networkInstanceId = component.netId;
						if (networkInstanceId.IsEmpty())
						{
							if (LogFilter.logWarn)
							{
								Debug.LogWarning("SetSyncVarGameObject GameObject " + newGameObject + " has a zero netId. Maybe it is not spawned yet?");
							}
						}
					}
				}
				NetworkInstanceId networkInstanceId2 = default(NetworkInstanceId);
				if (gameObjectField != null)
				{
					networkInstanceId2 = gameObjectField.GetComponent<NetworkIdentity>().netId;
				}
				if (networkInstanceId != networkInstanceId2)
				{
					if (LogFilter.logDev)
					{
						Debug.Log(string.Concat(new object[]
						{
							"SetSyncVar GameObject ",
							base.GetType().Name,
							" bit [",
							dirtyBit,
							"] netfieldId:",
							networkInstanceId2,
							"->",
							networkInstanceId
						}));
					}
					this.SetDirtyBit(dirtyBit);
					gameObjectField = newGameObject;
					netIdField = networkInstanceId;
				}
			}
		}

		// Token: 0x0600012D RID: 301 RVA: 0x000095B4 File Offset: 0x000077B4
		[EditorBrowsable(EditorBrowsableState.Never)]
		protected void SetSyncVar<T>(T value, ref T fieldValue, uint dirtyBit)
		{
			bool flag = false;
			if (value == null)
			{
				if (fieldValue != null)
				{
					flag = true;
				}
			}
			else
			{
				flag = !value.Equals(fieldValue);
			}
			if (flag)
			{
				if (LogFilter.logDev)
				{
					Debug.Log(string.Concat(new object[]
					{
						"SetSyncVar ",
						base.GetType().Name,
						" bit [",
						dirtyBit,
						"] ",
						fieldValue,
						"->",
						value
					}));
				}
				this.SetDirtyBit(dirtyBit);
				fieldValue = value;
			}
		}

		// Token: 0x0600012E RID: 302 RVA: 0x00009686 File Offset: 0x00007886
		public void SetDirtyBit(uint dirtyBit)
		{
			this.m_SyncVarDirtyBits |= dirtyBit;
		}

		// Token: 0x0600012F RID: 303 RVA: 0x00009697 File Offset: 0x00007897
		public void ClearAllDirtyBits()
		{
			this.m_LastSendTime = Time.time;
			this.m_SyncVarDirtyBits = 0U;
		}

		// Token: 0x06000130 RID: 304 RVA: 0x000096AC File Offset: 0x000078AC
		internal int GetDirtyChannel()
		{
			if (Time.time - this.m_LastSendTime > this.GetNetworkSendInterval())
			{
				if (this.m_SyncVarDirtyBits != 0U)
				{
					return this.GetNetworkChannel();
				}
			}
			return -1;
		}

		// Token: 0x06000131 RID: 305 RVA: 0x000096F4 File Offset: 0x000078F4
		public virtual bool OnSerialize(NetworkWriter writer, bool initialState)
		{
			if (!initialState)
			{
				writer.WritePackedUInt32(0U);
			}
			return false;
		}

		// Token: 0x06000132 RID: 306 RVA: 0x00009719 File Offset: 0x00007919
		public virtual void OnDeserialize(NetworkReader reader, bool initialState)
		{
			if (!initialState)
			{
				reader.ReadPackedUInt32();
			}
		}

		// Token: 0x06000133 RID: 307 RVA: 0x0000972B File Offset: 0x0000792B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public virtual void PreStartClient()
		{
		}

		// Token: 0x06000134 RID: 308 RVA: 0x0000972E File Offset: 0x0000792E
		public virtual void OnNetworkDestroy()
		{
		}

		// Token: 0x06000135 RID: 309 RVA: 0x00009731 File Offset: 0x00007931
		public virtual void OnStartServer()
		{
		}

		// Token: 0x06000136 RID: 310 RVA: 0x00009734 File Offset: 0x00007934
		public virtual void OnStartClient()
		{
		}

		// Token: 0x06000137 RID: 311 RVA: 0x00009737 File Offset: 0x00007937
		public virtual void OnStartLocalPlayer()
		{
		}

		// Token: 0x06000138 RID: 312 RVA: 0x0000973A File Offset: 0x0000793A
		public virtual void OnStartAuthority()
		{
		}

		// Token: 0x06000139 RID: 313 RVA: 0x0000973D File Offset: 0x0000793D
		public virtual void OnStopAuthority()
		{
		}

		// Token: 0x0600013A RID: 314 RVA: 0x00009740 File Offset: 0x00007940
		public virtual bool OnRebuildObservers(HashSet<NetworkConnection> observers, bool initialize)
		{
			return false;
		}

		// Token: 0x0600013B RID: 315 RVA: 0x00009756 File Offset: 0x00007956
		public virtual void OnSetLocalVisibility(bool vis)
		{
		}

		// Token: 0x0600013C RID: 316 RVA: 0x0000975C File Offset: 0x0000795C
		public virtual bool OnCheckObserver(NetworkConnection conn)
		{
			return true;
		}

		// Token: 0x0600013D RID: 317 RVA: 0x00009774 File Offset: 0x00007974
		public virtual int GetNetworkChannel()
		{
			return 0;
		}

		// Token: 0x0600013E RID: 318 RVA: 0x0000978C File Offset: 0x0000798C
		public virtual float GetNetworkSendInterval()
		{
			return 0.1f;
		}

		// Token: 0x040000B5 RID: 181
		private uint m_SyncVarDirtyBits;

		// Token: 0x040000B6 RID: 182
		private float m_LastSendTime;

		// Token: 0x040000B7 RID: 183
		private bool m_SyncVarGuard;

		// Token: 0x040000B8 RID: 184
		private const float k_DefaultSendInterval = 0.1f;

		// Token: 0x040000B9 RID: 185
		private NetworkIdentity m_MyView;

		// Token: 0x040000BA RID: 186
		private static Dictionary<int, NetworkBehaviour.Invoker> s_CmdHandlerDelegates = new Dictionary<int, NetworkBehaviour.Invoker>();

		// Token: 0x02000035 RID: 53
		// (Invoke) Token: 0x06000141 RID: 321
		public delegate void CmdDelegate(NetworkBehaviour obj, NetworkReader reader);

		// Token: 0x02000036 RID: 54
		// (Invoke) Token: 0x06000145 RID: 325
		protected delegate void EventDelegate(List<Delegate> targets, NetworkReader reader);

		// Token: 0x02000037 RID: 55
		protected enum UNetInvokeType
		{
			// Token: 0x040000BC RID: 188
			Command,
			// Token: 0x040000BD RID: 189
			ClientRpc,
			// Token: 0x040000BE RID: 190
			SyncEvent,
			// Token: 0x040000BF RID: 191
			SyncList
		}

		// Token: 0x02000038 RID: 56
		protected class Invoker
		{
			// Token: 0x06000149 RID: 329 RVA: 0x000097BC File Offset: 0x000079BC
			public string DebugString()
			{
				return string.Concat(new object[]
				{
					this.invokeType,
					":",
					this.invokeClass,
					":",
					this.invokeFunction.GetMethodName()
				});
			}

			// Token: 0x040000C0 RID: 192
			public NetworkBehaviour.UNetInvokeType invokeType;

			// Token: 0x040000C1 RID: 193
			public Type invokeClass;

			// Token: 0x040000C2 RID: 194
			public NetworkBehaviour.CmdDelegate invokeFunction;
		}
	}
}