+scripts

1 files changed, 643 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XUtliPoolLib/XAnimator.cs b/Client/Assets/Scripts/XUtliPoolLib/XAnimator.cs
new file mode 100644
index 00000000..507e9275
--- /dev/null
+++ b/Client/Assets/Scripts/XUtliPoolLib/XAnimator.cs
@@ -0,0 +1,643 @@
+using System;

+using System.Collections.Generic;

+using UnityEngine;

+

+namespace XUtliPoolLib

+{

+	public class XAnimator

+	{

+		public bool IsLoaded

+		{

+			get

+			{

+				return this.m_LoadStatus == 2;

+			}

+		}

+

+		private bool IsInLoadFinish

+		{

+			get

+			{

+				return this.m_LoadStatus == 1;

+			}

+		}

+

+		public float speed

+		{

+			get

+			{

+				return this.m_speed;

+			}

+			set

+			{

+				this.m_speed = value;

+				bool isLoaded = this.IsLoaded;

+				if (isLoaded)

+				{

+					XAnimator.SyncSpeed(this);

+				}

+				else

+				{

+					this.SetCbFlag(XAnimator.ECallbackCmd.ESyncSpeed, true);

+				}

+			}

+		}

+

+		public bool enabled

+		{

+			get

+			{

+				return this.m_enable;

+			}

+			set

+			{

+				this.m_enable = value;

+				bool isLoaded = this.IsLoaded;

+				if (isLoaded)

+				{

+					XAnimator.SyncEnable(this);

+				}

+				else

+				{

+					this.SetCbFlag(XAnimator.ECallbackCmd.ESyncEnable, true);

+				}

+			}

+		}

+

+		public string StateName

+		{

+			get

+			{

+				return this.m_stateName;

+			}

+		}

+

+		public AnimatorCullingMode cullingMode

+		{

+			set

+			{

+				this.m_cullingMode = value;

+				bool isLoaded = this.IsLoaded;

+				if (isLoaded)

+				{

+					XAnimator.SyncAnimationCullingMode(this);

+				}

+			}

+		}

+

+		private short m_LoadStatus = 0;

+

+		public XGameObject xGameObject = null;

+

+		private Animator m_Ator = null;

+

+		private AnimatorOverrideController m_overrideController = null;

+

+		private AnimatorCullingMode m_cullingMode = (AnimatorCullingMode)1;

+

+		private bool m_delayPlay = false;

+

+		private bool m_crossFade = false;

+

+		private string m_stateName = "";

+

+		private int m_playLayer = 0;

+

+		private float m_normalizedTime = float.NegativeInfinity;

+

+		private float m_value = 0f;

+

+		private string m_triggerName = "";

+

+		private float m_speed = 1f;

+

+		private bool m_enable = true;

+

+		private Dictionary<string, float> m_FloatCache = null;

+

+		private int m_LoadFinishCbFlag = 0;

+

+		private static AnimLoadCallback SyncTriggerCmd = new AnimLoadCallback(XAnimator.SyncTrigger);

+

+		private static AnimLoadCallback SyncSetFloatCmd = new AnimLoadCallback(XAnimator.SyncSetFloat);

+

+		private static AnimLoadCallback SyncSpeedCmd = new AnimLoadCallback(XAnimator.SyncSpeed);

+

+		private static AnimLoadCallback SyncEnableCmd = new AnimLoadCallback(XAnimator.SyncEnable);

+

+		private static AnimLoadCallback[] loadCallbacks = null;

+

+		private Dictionary<string, XAnimator.AminInfo> m_Clips = new Dictionary<string, XAnimator.AminInfo>();

+

+		public static bool debug = false;

+

+		private enum ECallbackCmd

+		{

+			ESyncEnable = 1,

+			ESyncSpeed,

+			ESyncTrigger = 4,

+			ESyncSetFloat = 8

+		}

+

+		private struct AminInfo

+		{

+			public XAnimationClip xclip;

+

+			public string clipKey;

+

+			public string clipPath;

+		}

+

+		public XAnimator()

+		{

+			bool flag = XAnimator.loadCallbacks == null;

+			if (flag)

+			{

+				XAnimator.loadCallbacks = new AnimLoadCallback[]

+				{

+					XAnimator.SyncEnableCmd,

+					XAnimator.SyncSpeedCmd,

+					XAnimator.SyncTriggerCmd,

+					XAnimator.SyncSetFloatCmd

+				};

+			}

+		}

+

+		private void SetCbFlag(XAnimator.ECallbackCmd cmd, bool add)

+		{

+			int num = XFastEnumIntEqualityComparer<XAnimator.ECallbackCmd>.ToInt(cmd);

+			if (add)

+			{

+				this.m_LoadFinishCbFlag |= num;

+			}

+			else

+			{

+				this.m_LoadFinishCbFlag &= ~num;

+			}

+		}

+

+		private bool IsCbFlag(int index)

+		{

+			int num = 1 << index;

+			return (this.m_LoadFinishCbFlag & num) != 0;

+		}

+

+		private void CacheFloatValue(string name, float value)

+		{

+			bool flag = this.m_FloatCache == null;

+			if (flag)

+			{

+				this.m_FloatCache = DictionaryPool<string, float>.Get();

+			}

+			this.m_FloatCache[name] = value;

+		}

+

+		public void Init(GameObject gameObject)

+		{

+			this.m_LoadStatus = 1;

+			this.m_Ator = ((gameObject != null) ? gameObject.GetComponent<Animator>() : null);

+			bool flag = this.m_Ator != null;

+			if (flag)

+			{

+				this.m_Ator.enabled = true;

+				bool flag2 = this.m_Ator.runtimeAnimatorController is AnimatorOverrideController;

+				if (flag2)

+				{

+					this.m_overrideController = (this.m_Ator.runtimeAnimatorController as AnimatorOverrideController);

+				}

+				else

+				{

+					this.m_overrideController = new AnimatorOverrideController();

+					this.m_overrideController.runtimeAnimatorController = this.m_Ator.runtimeAnimatorController;

+					this.m_Ator.runtimeAnimatorController = this.m_overrideController;

+				}

+				foreach (KeyValuePair<string, XAnimator.AminInfo> keyValuePair in this.m_Clips)

+				{

+					XAnimator.AminInfo value = keyValuePair.Value;

+					bool flag3 = value.xclip != null;

+					if (flag3)

+					{

+						this.SyncOverrideAnim(value.clipKey, value.xclip);

+					}

+				}

+				this.m_Ator.cullingMode = 0;

+				this.m_Ator.Rebind();

+				for (int i = 0; i < XAnimator.loadCallbacks.Length; i++)

+				{

+					bool flag4 = this.IsCbFlag(i);

+					if (flag4)

+					{

+						AnimLoadCallback animLoadCallback = XAnimator.loadCallbacks[i];

+						animLoadCallback(this);

+					}

+				}

+			}

+			this.m_LoadFinishCbFlag = 0;

+			this.m_LoadStatus = 2;

+		}

+

+		public bool IsSame(Animator ator)

+		{

+			return this.m_Ator == ator;

+		}

+

+		public bool IsAnimStateValid()

+		{

+			bool flag = !this.IsLoaded;

+			bool result;

+			if (flag)

+			{

+				result = false;

+			}

+			else

+			{

+				bool flag2 = string.IsNullOrEmpty(this.m_stateName);

+				result = !flag2;

+			}

+			return result;

+		}

+

+		public void Reset()

+		{

+			bool flag = this.m_Ator != null;

+			if (flag)

+			{

+				this.m_Ator.cullingMode =(AnimatorCullingMode) 1;

+				this.m_Ator.enabled = false;

+				this.m_Ator = null;

+			}

+			bool flag2 = this.m_overrideController != null;

+			if (flag2)

+			{

+				foreach (AnimationClipPair animationClipPair in this.m_overrideController.clips)

+				{

+					bool flag3 = animationClipPair.overrideClip != null;

+					if (flag3)

+					{

+						this.m_overrideController[animationClipPair.originalClip.name] = null;

+					}

+				}

+				this.m_overrideController = null;

+			}

+			foreach (KeyValuePair<string, XAnimator.AminInfo> keyValuePair in this.m_Clips)

+			{

+				XAnimator.AminInfo value = keyValuePair.Value;

+				bool flag4 = value.xclip != null;

+				if (flag4)

+				{

+					XSingleton<XResourceLoaderMgr>.singleton.UnSafeDestroyShareResource(value.clipPath, ".anim", value.xclip, false);

+				}

+			}

+			this.m_Clips.Clear();

+			this.m_cullingMode = (AnimatorCullingMode) 1;

+			this.m_delayPlay = false;

+			this.m_stateName = "";

+			this.m_value = -1f;

+			this.m_playLayer = -1;

+			this.m_normalizedTime = float.NegativeInfinity;

+			this.m_triggerName = "";

+			this.m_LoadStatus = 0;

+			this.m_LoadFinishCbFlag = 0;

+			this.xGameObject = null;

+		}

+

+		public void SetStateMachine(IAnimStateMachine stateMachine)

+		{

+		}

+

+		private void SyncOverrideAnim(string key, XAnimationClip xclip)

+		{

+			bool flag = this.m_Ator != null;

+			if (flag)

+			{

+				bool flag2 = XAnimator.debug;

+				if (flag2)

+				{

+					XSingleton<XDebug>.singleton.AddWarningLog2("GO:{0} OverrideAnim {1}", new object[]

+					{

+						this.xGameObject.Name,

+						key

+					});

+				}

+				this.m_overrideController[key] = ((xclip != null) ? xclip.clip : null);

+			}

+		}

+

+		public void OverrideAnim(string key, string clipPath, OverrideAnimCallback overrideAnim = null, bool forceOverride = false)

+		{

+			bool flag = clipPath == null;

+			if (flag)

+			{

+				clipPath = "";

+			}

+			bool flag2 = this.m_Ator == null && this.IsLoaded;

+			if (!flag2)

+			{

+				XAnimator.AminInfo aminInfo;

+				bool flag3 = this.m_Clips.TryGetValue(key, out aminInfo);

+				if (flag3)

+				{

+					bool flag4 = aminInfo.clipPath == clipPath;

+					if (flag4)

+					{

+						bool flag5 = forceOverride && this.IsLoaded;

+						if (flag5)

+						{

+							this.SyncOverrideAnim(key, aminInfo.xclip);

+						}

+						bool flag6 = overrideAnim != null;

+						if (flag6)

+						{

+							overrideAnim(aminInfo.xclip);

+						}

+						return;

+					}

+					bool flag7 = aminInfo.xclip != null;

+					if (flag7)

+					{

+						XSingleton<XResourceLoaderMgr>.singleton.UnSafeDestroyShareResource("", ".anim", aminInfo.xclip, false);

+						aminInfo.xclip = null;

+					}

+				}

+				else

+				{

+					aminInfo.clipKey = key;

+				}

+				aminInfo.clipPath = clipPath;

+				aminInfo.xclip = (string.IsNullOrEmpty(clipPath) ? null : XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(clipPath, true, false));

+				this.m_Clips[key] = aminInfo;

+				bool isLoaded = this.IsLoaded;

+				if (isLoaded)

+				{

+					this.SyncOverrideAnim(key, aminInfo.xclip);

+				}

+				bool flag8 = overrideAnim != null;

+				if (flag8)

+				{

+					overrideAnim(aminInfo.xclip);

+				}

+			}

+		}

+

+		public void SetAnimLoadCallback(string key, OverrideAnimCallback overrideAnim)

+		{

+			bool flag = this.m_Ator == null && this.IsLoaded;

+			if (!flag)

+			{

+				bool flag2 = overrideAnim != null;

+				if (flag2)

+				{

+					XAnimator.AminInfo aminInfo;

+					bool flag3 = this.m_Clips.TryGetValue(key, out aminInfo);

+					if (flag3)

+					{

+						bool flag4 = aminInfo.xclip != null;

+						if (flag4)

+						{

+							overrideAnim(aminInfo.xclip);

+						}

+					}

+				}

+			}

+		}

+

+		public static void SyncAnimationCullingMode(XAnimator ator)

+		{

+			bool flag = ator != null && ator.m_Ator != null;

+			if (flag)

+			{

+				ator.m_Ator.cullingMode = ator.m_cullingMode;

+			}

+		}

+

+		private static void SyncTrigger(XAnimator ator)

+		{

+			bool flag = ator != null && ator.m_Ator != null && !string.IsNullOrEmpty(ator.m_triggerName);

+			if (flag)

+			{

+				bool flag2 = XAnimator.debug;

+				if (flag2)

+				{

+					XSingleton<XDebug>.singleton.AddWarningLog2("GO:{0} trigger {1}", new object[]

+					{

+						ator.xGameObject.Name,

+						ator.m_triggerName

+					});

+				}

+				ator.m_Ator.SetTrigger(ator.m_triggerName);

+			}

+		}

+

+		private static void SyncSetFloat(XAnimator ator)

+		{

+			bool flag = ator != null && ator.m_Ator != null;

+			if (flag)

+			{

+				bool flag2 = ator.m_FloatCache != null;

+				if (flag2)

+				{

+					Dictionary<string, float>.Enumerator enumerator = ator.m_FloatCache.GetEnumerator();

+					while (enumerator.MoveNext())

+					{

+						bool flag3 = XAnimator.debug;

+						KeyValuePair<string, float> keyValuePair;

+						if (flag3)

+						{

+							XDebug singleton = XSingleton<XDebug>.singleton;

+							string format = "GO:{0} SetFloat {1}";

+							object[] array = new object[2];

+							array[0] = ator.xGameObject.Name;

+							int num = 1;

+							keyValuePair = enumerator.Current;

+							array[num] = keyValuePair.Key;

+							singleton.AddWarningLog2(format, array);

+						}

+						Animator ator2 = ator.m_Ator;

+						keyValuePair = enumerator.Current;

+						string key = keyValuePair.Key;

+						keyValuePair = enumerator.Current;

+						ator2.SetFloat(key, keyValuePair.Value);

+					}

+					DictionaryPool<string, float>.Release(ator.m_FloatCache);

+					ator.m_FloatCache = null;

+				}

+			}

+		}

+

+		private static void SyncSpeed(XAnimator ator)

+		{

+			bool flag = ator != null && ator.m_Ator != null;

+			if (flag)

+			{

+				ator.m_Ator.speed = ator.m_speed;

+			}

+		}

+

+		private static void SyncEnable(XAnimator ator)

+		{

+			bool flag = ator != null && ator.m_Ator != null;

+			if (flag)

+			{

+				ator.m_Ator.enabled = ator.m_enable;

+			}

+		}

+

+		public static void Update(XAnimator ator)

+		{

+			XAnimator.SyncAnimationCullingMode(ator);

+			bool delayPlay = ator.m_delayPlay;

+			if (delayPlay)

+			{

+				ator.RealPlay();

+			}

+		}

+

+		public void RealPlay()

+		{

+			this.m_delayPlay = false;

+			bool flag = this.m_Ator != null;

+			if (flag)

+			{

+				bool crossFade = this.m_crossFade;

+				if (crossFade)

+				{

+					bool flag2 = XAnimator.debug;

+					if (flag2)

+					{

+						XSingleton<XDebug>.singleton.AddWarningLog2("GO:{0} crossFade {1} {2}", new object[]

+						{

+							this.xGameObject.Name,

+							this.m_stateName,

+							this.m_Ator.IsInTransition(0)

+						});

+					}

+					this.m_Ator.CrossFade(this.m_stateName, this.m_value, this.m_playLayer, this.m_normalizedTime);

+				}

+				else

+				{

+					bool flag3 = XAnimator.debug;

+					if (flag3)

+					{

+						XSingleton<XDebug>.singleton.AddWarningLog2("GO:{0} play {1}", new object[]

+						{

+							this.xGameObject.Name,

+							this.m_stateName

+						});

+					}

+					this.m_Ator.Play(this.m_stateName, this.m_playLayer, this.m_normalizedTime);

+				}

+			}

+		}

+

+		public void Play(string stateName, int layer, float normalizedTime)

+		{

+			this.m_stateName = stateName;

+			this.m_playLayer = layer;

+			this.m_normalizedTime = normalizedTime;

+			this.m_crossFade = false;

+			bool flag = this.IsAnimStateValid();

+			if (flag)

+			{

+				this.RealPlay();

+			}

+			else

+			{

+				this.m_delayPlay = true;

+			}

+		}

+

+		public void Play(string stateName, int layer)

+		{

+			this.m_stateName = stateName;

+			this.m_playLayer = layer;

+			this.m_normalizedTime = float.NegativeInfinity;

+			this.m_crossFade = false;

+			bool flag = this.IsAnimStateValid();

+			if (flag)

+			{

+				this.RealPlay();

+			}

+			else

+			{

+				this.m_delayPlay = true;

+			}

+		}

+

+		public void CrossFade(string stateName, float transitionDuration, int layer, float normalizedTime)

+		{

+			this.m_stateName = stateName;

+			this.m_value = transitionDuration;

+			this.m_playLayer = layer;

+			this.m_normalizedTime = normalizedTime;

+			this.m_crossFade = true;

+			bool flag = this.IsAnimStateValid();

+			if (flag)

+			{

+				this.RealPlay();

+			}

+			else

+			{

+				this.m_delayPlay = true;

+			}

+		}

+

+		public void SetTrigger(string name)

+		{

+			this.m_triggerName = name;

+			bool isLoaded = this.IsLoaded;

+			if (isLoaded)

+			{

+				XAnimator.SyncTrigger(this);

+			}

+			else

+			{

+				this.SetCbFlag(XAnimator.ECallbackCmd.ESyncTrigger, true);

+			}

+		}

+

+		public void ResetTrigger()

+		{

+			bool isLoaded = this.IsLoaded;

+			if (isLoaded)

+			{

+				XAnimator.SyncTrigger(this);

+			}

+			else

+			{

+				this.SetCbFlag(XAnimator.ECallbackCmd.ESyncTrigger, true);

+			}

+		}

+

+		public bool IsInTransition(int layerIndex)

+		{

+			return !(this.m_Ator == null) && this.m_Ator.IsInTransition(layerIndex);

+		}

+

+		public void SetFloat(string name, float value)

+		{

+			bool isLoaded = this.IsLoaded;

+			if (isLoaded)

+			{

+				bool flag = this.m_Ator != null;

+				if (flag)

+				{

+					this.m_Ator.SetFloat(name, value);

+				}

+			}

+			else

+			{

+				this.CacheFloatValue(name, value);

+				this.SetCbFlag(XAnimator.ECallbackCmd.ESyncSetFloat, true);

+			}

+		}

+

+		public void EnableRootMotion(bool enable)

+		{

+			bool flag = this.m_Ator != null;

+			if (flag)

+			{

+				this.m_Ator.applyRootMotion = enable;

+			}

+		}

+	}

+}