using System;
using UnityEngine.Networking.NetworkSystem;

namespace UnityEngine.Networking
{
	// Token: 0x02000033 RID: 51
	[DisallowMultipleComponent]
	[AddComponentMenu("Network/NetworkAnimator")]
	[RequireComponent(typeof(NetworkIdentity))]
	[RequireComponent(typeof(Animator))]
	public class NetworkAnimator : NetworkBehaviour
	{
		// Token: 0x1700001B RID: 27
		// (get) Token: 0x060000E3 RID: 227 RVA: 0x0000981C File Offset: 0x00007A1C
		// (set) Token: 0x060000E4 RID: 228 RVA: 0x00009837 File Offset: 0x00007A37
		public Animator animator
		{
			get
			{
				return this.m_Animator;
			}
			set
			{
				this.m_Animator = value;
				this.ResetParameterOptions();
			}
		}

		// Token: 0x060000E5 RID: 229 RVA: 0x00009847 File Offset: 0x00007A47
		public void SetParameterAutoSend(int index, bool value)
		{
			if (value)
			{
				this.m_ParameterSendBits |= 1U << index;
			}
			else
			{
				this.m_ParameterSendBits &= ~(1U << index);
			}
		}

		// Token: 0x060000E6 RID: 230 RVA: 0x00009880 File Offset: 0x00007A80
		public bool GetParameterAutoSend(int index)
		{
			return (this.m_ParameterSendBits & (1U << index)) != 0U;
		}

		// Token: 0x1700001C RID: 28
		// (get) Token: 0x060000E7 RID: 231 RVA: 0x000098A8 File Offset: 0x00007AA8
		private bool sendMessagesAllowed
		{
			get
			{
				if (base.isServer)
				{
					if (!base.localPlayerAuthority)
					{
						return true;
					}
					if (base.netIdentity != null && base.netIdentity.clientAuthorityOwner == null)
					{
						return true;
					}
				}
				return base.hasAuthority;
			}
		}

		// Token: 0x060000E8 RID: 232 RVA: 0x00009917 File Offset: 0x00007B17
		internal void ResetParameterOptions()
		{
			Debug.Log("ResetParameterOptions");
			this.m_ParameterSendBits = 0U;
		}

		// Token: 0x060000E9 RID: 233 RVA: 0x0000992C File Offset: 0x00007B2C
		private void FixedUpdate()
		{
			if (this.sendMessagesAllowed)
			{
				if (this.m_ParameterWriter == null)
				{
					this.m_ParameterWriter = new NetworkWriter();
				}
				this.CheckSendRate();
				int num;
				float num2;
				if (this.CheckAnimStateChanged(out num, out num2))
				{
					AnimationMessage animationMessage = new AnimationMessage();
					animationMessage.netId = base.netId;
					animationMessage.stateHash = num;
					animationMessage.normalizedTime = num2;
					this.m_ParameterWriter.SeekZero();
					this.WriteParameters(this.m_ParameterWriter, false);
					animationMessage.parameters = this.m_ParameterWriter.ToArray();
					this.SendMessage(40, animationMessage);
				}
			}
		}

		// Token: 0x060000EA RID: 234 RVA: 0x000099D0 File Offset: 0x00007BD0
		private bool CheckAnimStateChanged(out int stateHash, out float normalizedTime)
		{
			stateHash = 0;
			normalizedTime = 0f;
			bool flag;
			if (this.m_Animator.IsInTransition(0))
			{
				AnimatorTransitionInfo animatorTransitionInfo = this.m_Animator.GetAnimatorTransitionInfo(0);
				if (animatorTransitionInfo.fullPathHash != this.m_TransitionHash)
				{
					this.m_TransitionHash = animatorTransitionInfo.fullPathHash;
					this.m_AnimationHash = 0;
					flag = true;
				}
				else
				{
					flag = false;
				}
			}
			else
			{
				AnimatorStateInfo currentAnimatorStateInfo = this.m_Animator.GetCurrentAnimatorStateInfo(0);
				if (currentAnimatorStateInfo.fullPathHash != this.m_AnimationHash)
				{
					if (this.m_AnimationHash != 0)
					{
						stateHash = currentAnimatorStateInfo.fullPathHash;
						normalizedTime = currentAnimatorStateInfo.normalizedTime;
					}
					this.m_TransitionHash = 0;
					this.m_AnimationHash = currentAnimatorStateInfo.fullPathHash;
					flag = true;
				}
				else
				{
					flag = false;
				}
			}
			return flag;
		}

		// Token: 0x060000EB RID: 235 RVA: 0x00009AA0 File Offset: 0x00007CA0
		private void CheckSendRate()
		{
			if (this.sendMessagesAllowed && this.GetNetworkSendInterval() != 0f && this.m_SendTimer < Time.time)
			{
				this.m_SendTimer = Time.time + this.GetNetworkSendInterval();
				AnimationParametersMessage animationParametersMessage = new AnimationParametersMessage();
				animationParametersMessage.netId = base.netId;
				this.m_ParameterWriter.SeekZero();
				this.WriteParameters(this.m_ParameterWriter, true);
				animationParametersMessage.parameters = this.m_ParameterWriter.ToArray();
				this.SendMessage(41, animationParametersMessage);
			}
		}

		// Token: 0x060000EC RID: 236 RVA: 0x00009B31 File Offset: 0x00007D31
		private void SendMessage(short type, MessageBase msg)
		{
			if (base.isServer)
			{
				NetworkServer.SendToReady(base.gameObject, type, msg);
			}
			else if (ClientScene.readyConnection != null)
			{
				ClientScene.readyConnection.Send(type, msg);
			}
		}

		// Token: 0x060000ED RID: 237 RVA: 0x00009B70 File Offset: 0x00007D70
		private void SetSendTrackingParam(string p, int i)
		{
			p = "Sent Param: " + p;
			if (i == 0)
			{
				this.param0 = p;
			}
			if (i == 1)
			{
				this.param1 = p;
			}
			if (i == 2)
			{
				this.param2 = p;
			}
			if (i == 3)
			{
				this.param3 = p;
			}
			if (i == 4)
			{
				this.param4 = p;
			}
			if (i == 5)
			{
				this.param5 = p;
			}
		}

		// Token: 0x060000EE RID: 238 RVA: 0x00009BE0 File Offset: 0x00007DE0
		private void SetRecvTrackingParam(string p, int i)
		{
			p = "Recv Param: " + p;
			if (i == 0)
			{
				this.param0 = p;
			}
			if (i == 1)
			{
				this.param1 = p;
			}
			if (i == 2)
			{
				this.param2 = p;
			}
			if (i == 3)
			{
				this.param3 = p;
			}
			if (i == 4)
			{
				this.param4 = p;
			}
			if (i == 5)
			{
				this.param5 = p;
			}
		}

		// Token: 0x060000EF RID: 239 RVA: 0x00009C4E File Offset: 0x00007E4E
		internal void HandleAnimMsg(AnimationMessage msg, NetworkReader reader)
		{
			if (!base.hasAuthority)
			{
				if (msg.stateHash != 0)
				{
					this.m_Animator.Play(msg.stateHash, 0, msg.normalizedTime);
				}
				this.ReadParameters(reader, false);
			}
		}

		// Token: 0x060000F0 RID: 240 RVA: 0x00009C8E File Offset: 0x00007E8E
		internal void HandleAnimParamsMsg(AnimationParametersMessage msg, NetworkReader reader)
		{
			if (!base.hasAuthority)
			{
				this.ReadParameters(reader, true);
			}
		}

		// Token: 0x060000F1 RID: 241 RVA: 0x00009CA9 File Offset: 0x00007EA9
		internal void HandleAnimTriggerMsg(int hash)
		{
			this.m_Animator.SetTrigger(hash);
		}

		// Token: 0x060000F2 RID: 242 RVA: 0x00009CB8 File Offset: 0x00007EB8
		private void WriteParameters(NetworkWriter writer, bool autoSend)
		{
			for (int i = 0; i < this.m_Animator.parameters.Length; i++)
			{
				if (!autoSend || this.GetParameterAutoSend(i))
				{
					AnimatorControllerParameter animatorControllerParameter = this.m_Animator.parameters[i];
					if (animatorControllerParameter.type == AnimatorControllerParameterType.Int)
					{
						writer.WritePackedUInt32((uint)this.m_Animator.GetInteger(animatorControllerParameter.nameHash));
						this.SetSendTrackingParam(animatorControllerParameter.name + ":" + this.m_Animator.GetInteger(animatorControllerParameter.nameHash), i);
					}
					if (animatorControllerParameter.type == AnimatorControllerParameterType.Float)
					{
						writer.Write(this.m_Animator.GetFloat(animatorControllerParameter.nameHash));
						this.SetSendTrackingParam(animatorControllerParameter.name + ":" + this.m_Animator.GetFloat(animatorControllerParameter.nameHash), i);
					}
					if (animatorControllerParameter.type == AnimatorControllerParameterType.Bool)
					{
						writer.Write(this.m_Animator.GetBool(animatorControllerParameter.nameHash));
						this.SetSendTrackingParam(animatorControllerParameter.name + ":" + this.m_Animator.GetBool(animatorControllerParameter.nameHash), i);
					}
				}
			}
		}

		// Token: 0x060000F3 RID: 243 RVA: 0x00009E04 File Offset: 0x00008004
		private void ReadParameters(NetworkReader reader, bool autoSend)
		{
			for (int i = 0; i < this.m_Animator.parameters.Length; i++)
			{
				if (!autoSend || this.GetParameterAutoSend(i))
				{
					AnimatorControllerParameter animatorControllerParameter = this.m_Animator.parameters[i];
					if (animatorControllerParameter.type == AnimatorControllerParameterType.Int)
					{
						int num = (int)reader.ReadPackedUInt32();
						this.m_Animator.SetInteger(animatorControllerParameter.nameHash, num);
						this.SetRecvTrackingParam(animatorControllerParameter.name + ":" + num, i);
					}
					if (animatorControllerParameter.type == AnimatorControllerParameterType.Float)
					{
						float num2 = reader.ReadSingle();
						this.m_Animator.SetFloat(animatorControllerParameter.nameHash, num2);
						this.SetRecvTrackingParam(animatorControllerParameter.name + ":" + num2, i);
					}
					if (animatorControllerParameter.type == AnimatorControllerParameterType.Bool)
					{
						bool flag = reader.ReadBoolean();
						this.m_Animator.SetBool(animatorControllerParameter.nameHash, flag);
						this.SetRecvTrackingParam(animatorControllerParameter.name + ":" + flag, i);
					}
				}
			}
		}

		// Token: 0x060000F4 RID: 244 RVA: 0x00009F28 File Offset: 0x00008128
		public override bool OnSerialize(NetworkWriter writer, bool forceAll)
		{
			bool flag;
			if (forceAll)
			{
				if (this.m_Animator.IsInTransition(0))
				{
					AnimatorStateInfo nextAnimatorStateInfo = this.m_Animator.GetNextAnimatorStateInfo(0);
					writer.Write(nextAnimatorStateInfo.fullPathHash);
					writer.Write(nextAnimatorStateInfo.normalizedTime);
				}
				else
				{
					AnimatorStateInfo currentAnimatorStateInfo = this.m_Animator.GetCurrentAnimatorStateInfo(0);
					writer.Write(currentAnimatorStateInfo.fullPathHash);
					writer.Write(currentAnimatorStateInfo.normalizedTime);
				}
				this.WriteParameters(writer, false);
				flag = true;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x060000F5 RID: 245 RVA: 0x00009FBC File Offset: 0x000081BC
		public override void OnDeserialize(NetworkReader reader, bool initialState)
		{
			if (initialState)
			{
				int num = reader.ReadInt32();
				float num2 = reader.ReadSingle();
				this.ReadParameters(reader, false);
				this.m_Animator.Play(num, 0, num2);
			}
		}

		// Token: 0x060000F6 RID: 246 RVA: 0x00009FF6 File Offset: 0x000081F6
		public void SetTrigger(string triggerName)
		{
			this.SetTrigger(Animator.StringToHash(triggerName));
		}

		// Token: 0x060000F7 RID: 247 RVA: 0x0000A008 File Offset: 0x00008208
		public void SetTrigger(int hash)
		{
			AnimationTriggerMessage animationTriggerMessage = new AnimationTriggerMessage();
			animationTriggerMessage.netId = base.netId;
			animationTriggerMessage.hash = hash;
			if (base.hasAuthority && base.localPlayerAuthority)
			{
				if (NetworkClient.allClients.Count > 0)
				{
					NetworkConnection readyConnection = ClientScene.readyConnection;
					if (readyConnection != null)
					{
						readyConnection.Send(42, animationTriggerMessage);
					}
				}
			}
			else if (base.isServer && !base.localPlayerAuthority)
			{
				NetworkServer.SendToReady(base.gameObject, 42, animationTriggerMessage);
			}
		}

		// Token: 0x060000F8 RID: 248 RVA: 0x0000A09C File Offset: 0x0000829C
		internal static void OnAnimationServerMessage(NetworkMessage netMsg)
		{
			netMsg.ReadMessage<AnimationMessage>(NetworkAnimator.s_AnimationMessage);
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[]
				{
					"OnAnimationMessage for netId=",
					NetworkAnimator.s_AnimationMessage.netId,
					" conn=",
					netMsg.conn
				}));
			}
			GameObject gameObject = NetworkServer.FindLocalObject(NetworkAnimator.s_AnimationMessage.netId);
			if (!(gameObject == null))
			{
				NetworkAnimator component = gameObject.GetComponent<NetworkAnimator>();
				if (component != null)
				{
					NetworkReader networkReader = new NetworkReader(NetworkAnimator.s_AnimationMessage.parameters);
					component.HandleAnimMsg(NetworkAnimator.s_AnimationMessage, networkReader);
					NetworkServer.SendToReady(gameObject, 40, NetworkAnimator.s_AnimationMessage);
				}
			}
		}

		// Token: 0x060000F9 RID: 249 RVA: 0x0000A160 File Offset: 0x00008360
		internal static void OnAnimationParametersServerMessage(NetworkMessage netMsg)
		{
			netMsg.ReadMessage<AnimationParametersMessage>(NetworkAnimator.s_AnimationParametersMessage);
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[]
				{
					"OnAnimationParametersMessage for netId=",
					NetworkAnimator.s_AnimationParametersMessage.netId,
					" conn=",
					netMsg.conn
				}));
			}
			GameObject gameObject = NetworkServer.FindLocalObject(NetworkAnimator.s_AnimationParametersMessage.netId);
			if (!(gameObject == null))
			{
				NetworkAnimator component = gameObject.GetComponent<NetworkAnimator>();
				if (component != null)
				{
					NetworkReader networkReader = new NetworkReader(NetworkAnimator.s_AnimationParametersMessage.parameters);
					component.HandleAnimParamsMsg(NetworkAnimator.s_AnimationParametersMessage, networkReader);
					NetworkServer.SendToReady(gameObject, 41, NetworkAnimator.s_AnimationParametersMessage);
				}
			}
		}

		// Token: 0x060000FA RID: 250 RVA: 0x0000A224 File Offset: 0x00008424
		internal static void OnAnimationTriggerServerMessage(NetworkMessage netMsg)
		{
			netMsg.ReadMessage<AnimationTriggerMessage>(NetworkAnimator.s_AnimationTriggerMessage);
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[]
				{
					"OnAnimationTriggerMessage for netId=",
					NetworkAnimator.s_AnimationTriggerMessage.netId,
					" conn=",
					netMsg.conn
				}));
			}
			GameObject gameObject = NetworkServer.FindLocalObject(NetworkAnimator.s_AnimationTriggerMessage.netId);
			if (!(gameObject == null))
			{
				NetworkAnimator component = gameObject.GetComponent<NetworkAnimator>();
				if (component != null)
				{
					component.HandleAnimTriggerMsg(NetworkAnimator.s_AnimationTriggerMessage.hash);
					NetworkServer.SendToReady(gameObject, 42, NetworkAnimator.s_AnimationTriggerMessage);
				}
			}
		}

		// Token: 0x060000FB RID: 251 RVA: 0x0000A2DC File Offset: 0x000084DC
		internal static void OnAnimationClientMessage(NetworkMessage netMsg)
		{
			netMsg.ReadMessage<AnimationMessage>(NetworkAnimator.s_AnimationMessage);
			GameObject gameObject = ClientScene.FindLocalObject(NetworkAnimator.s_AnimationMessage.netId);
			if (!(gameObject == null))
			{
				NetworkAnimator component = gameObject.GetComponent<NetworkAnimator>();
				if (component != null)
				{
					NetworkReader networkReader = new NetworkReader(NetworkAnimator.s_AnimationMessage.parameters);
					component.HandleAnimMsg(NetworkAnimator.s_AnimationMessage, networkReader);
				}
			}
		}

		// Token: 0x060000FC RID: 252 RVA: 0x0000A348 File Offset: 0x00008548
		internal static void OnAnimationParametersClientMessage(NetworkMessage netMsg)
		{
			netMsg.ReadMessage<AnimationParametersMessage>(NetworkAnimator.s_AnimationParametersMessage);
			GameObject gameObject = ClientScene.FindLocalObject(NetworkAnimator.s_AnimationParametersMessage.netId);
			if (!(gameObject == null))
			{
				NetworkAnimator component = gameObject.GetComponent<NetworkAnimator>();
				if (component != null)
				{
					NetworkReader networkReader = new NetworkReader(NetworkAnimator.s_AnimationParametersMessage.parameters);
					component.HandleAnimParamsMsg(NetworkAnimator.s_AnimationParametersMessage, networkReader);
				}
			}
		}

		// Token: 0x060000FD RID: 253 RVA: 0x0000A3B4 File Offset: 0x000085B4
		internal static void OnAnimationTriggerClientMessage(NetworkMessage netMsg)
		{
			netMsg.ReadMessage<AnimationTriggerMessage>(NetworkAnimator.s_AnimationTriggerMessage);
			GameObject gameObject = ClientScene.FindLocalObject(NetworkAnimator.s_AnimationTriggerMessage.netId);
			if (!(gameObject == null))
			{
				NetworkAnimator component = gameObject.GetComponent<NetworkAnimator>();
				if (component != null)
				{
					component.HandleAnimTriggerMsg(NetworkAnimator.s_AnimationTriggerMessage.hash);
				}
			}
		}

		// Token: 0x040000A6 RID: 166
		[SerializeField]
		private Animator m_Animator;

		// Token: 0x040000A7 RID: 167
		[SerializeField]
		private uint m_ParameterSendBits;

		// Token: 0x040000A8 RID: 168
		private static AnimationMessage s_AnimationMessage = new AnimationMessage();

		// Token: 0x040000A9 RID: 169
		private static AnimationParametersMessage s_AnimationParametersMessage = new AnimationParametersMessage();

		// Token: 0x040000AA RID: 170
		private static AnimationTriggerMessage s_AnimationTriggerMessage = new AnimationTriggerMessage();

		// Token: 0x040000AB RID: 171
		private int m_AnimationHash;

		// Token: 0x040000AC RID: 172
		private int m_TransitionHash;

		// Token: 0x040000AD RID: 173
		private NetworkWriter m_ParameterWriter;

		// Token: 0x040000AE RID: 174
		private float m_SendTimer;

		// Token: 0x040000AF RID: 175
		public string param0;

		// Token: 0x040000B0 RID: 176
		public string param1;

		// Token: 0x040000B1 RID: 177
		public string param2;

		// Token: 0x040000B2 RID: 178
		public string param3;

		// Token: 0x040000B3 RID: 179
		public string param4;

		// Token: 0x040000B4 RID: 180
		public string param5;
	}
}