+scripts

1 files changed, 376 insertions, 0 deletions

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

+using System.Collections.Generic;

+using UILib;

+using UnityEngine;

+

+namespace XUtliPoolLib

+{

+	public class XUIPool

+	{

+		public int TplWidth { get; set; }

+

+		public int TplHeight { get; set; }

+

+		public Vector3 TplPos { get; set; }

+

+		public bool IsValid

+		{

+			get

+			{

+				return this._tpl != null;

+			}

+		}

+

+		public int ActiveCount

+		{

+			get

+			{

+				return this._ActiveCount;

+			}

+		}

+

+		public static int _far_far_away = 1000;

+

+		public GameObject _tpl;

+

+		protected List<GameObject> _pool = new List<GameObject>();

+

+		protected List<bool> _used = new List<bool>();

+

+		protected Stack<int> _ToBeRemoved = new Stack<int>();

+

+		protected bool _bEffectiveMode = true;

+

+		public IXUITool _uiTool = null;

+

+		private int _ActiveCount;

+

+		public XUIPool(IXUITool uiTool)

+		{

+			this._uiTool = uiTool;

+		}

+

+		public void SetupPool(GameObject parent, GameObject tpl, uint Count, bool bEffectiveMode = true)

+		{

+			this._pool.Clear();

+			this._used.Clear();

+			this._ToBeRemoved.Clear();

+			this._tpl = tpl;

+			this._bEffectiveMode = bEffectiveMode;

+			this._ActiveCount = 0;

+			IXUISprite ixuisprite = this._tpl.GetComponent("XUISprite") as IXUISprite;

+			IXUILabel ixuilabel = this._tpl.GetComponent("XUILabel") as IXUILabel;

+			bool flag = ixuisprite != null;

+			if (flag)

+			{

+				this.TplWidth = ixuisprite.spriteWidth;

+				this.TplHeight = ixuisprite.spriteHeight;

+			}

+			else

+			{

+				bool flag2 = ixuilabel != null;

+				if (flag2)

+				{

+					this.TplWidth = ixuilabel.spriteWidth;

+					this.TplHeight = ixuilabel.spriteHeight;

+				}

+				else

+				{

+					this.TplWidth = 0;

+					this.TplHeight = 0;

+				}

+			}

+			bool flag3 = !bEffectiveMode;

+			if (flag3)

+			{

+				this.ReturnAllDisable();

+			}

+			this.TplPos = this._tpl.transform.localPosition;

+			Transform parent2 = (parent == null) ? this._tpl.transform.parent : parent.transform;

+			int num = 0;

+			while ((long)num < (long)((ulong)Count))

+			{

+				GameObject gameObject = XCommon.Instantiate<GameObject>(this._tpl);

+				gameObject.transform.parent = parent2;

+				gameObject.transform.localScale = Vector3.one;

+				gameObject.name = "item" + num;

+				bool bEffectiveMode2 = this._bEffectiveMode;

+				if (bEffectiveMode2)

+				{

+					gameObject.transform.localPosition = Vector3.one * (float)XUIPool._far_far_away;

+				}

+				else

+				{

+					gameObject.transform.localPosition = this._tpl.transform.localPosition;

+					this.MakeGameObjectEnabled(gameObject, false);

+				}

+				this._pool.Add(gameObject);

+				this._used.Add(false);

+				num++;

+			}

+			bool bEffectiveMode3 = this._bEffectiveMode;

+			if (bEffectiveMode3)

+			{

+				this._tpl.transform.parent = parent2;

+				this._tpl.transform.localPosition = Vector3.one * (float)XUIPool._far_far_away;

+			}

+			else

+			{

+				this._tpl.transform.parent = parent2;

+				this.MakeGameObjectEnabled(this._tpl, false);

+			}

+		}

+

+		public GameObject FetchGameObject(bool fadeIn = false)

+		{

+			this._ActiveCount++;

+			bool flag = this._ToBeRemoved.Count > 0;

+			GameObject result;

+			if (flag)

+			{

+				int index = this._ToBeRemoved.Pop();

+				this.CheckFadeIn(fadeIn, this._pool[index]);

+				result = this._pool[index];

+			}

+			else

+			{

+				for (int i = 0; i < this._pool.Count; i++)

+				{

+					bool flag2 = !this._used[i];

+					if (flag2)

+					{

+						bool flag3 = !this._bEffectiveMode;

+						if (flag3)

+						{

+							this.MakeGameObjectEnabled(this._pool[i], true);

+						}

+						this._used[i] = true;

+						this.CheckFadeIn(fadeIn, this._pool[i]);

+						return this._pool[i];

+					}

+				}

+				int count = this._pool.Count;

+				bool flag4 = !this._bEffectiveMode;

+				if (flag4)

+				{

+					this.MakeGameObjectEnabled(this._tpl, true);

+				}

+				for (int j = 0; j < (count + 1) / 2; j++)

+				{

+					GameObject gameObject = XCommon.Instantiate<GameObject>(this._tpl);

+					gameObject.transform.parent = this._tpl.transform.parent;

+					gameObject.transform.localScale = Vector3.one;

+					gameObject.name = "item" + this._pool.Count;

+					bool bEffectiveMode = this._bEffectiveMode;

+					if (bEffectiveMode)

+					{

+						gameObject.transform.localPosition = Vector3.one * (float)XUIPool._far_far_away;

+					}

+					else

+					{

+						gameObject.transform.localPosition = this._tpl.transform.localPosition;

+						this.MakeGameObjectEnabled(gameObject, false);

+					}

+					this._pool.Add(gameObject);

+					this._used.Add(false);

+				}

+				bool flag5 = !this._bEffectiveMode;

+				if (flag5)

+				{

+					this.MakeGameObjectEnabled(this._tpl, false);

+				}

+				this._used[count] = true;

+				this.MakeGameObjectEnabled(this._pool[count], true);

+				this.CheckFadeIn(fadeIn, this._pool[count]);

+				result = this._pool[count];

+			}

+			return result;

+		}

+

+		private void CheckFadeIn(bool fadeIn, GameObject go)

+		{

+			bool flag = !fadeIn;

+			if (!flag)

+			{

+				IXTweenFadeIn ixtweenFadeIn = go.GetComponent("TweenFadeIn") as IXTweenFadeIn;

+				bool flag2 = ixtweenFadeIn == null;

+				if (flag2)

+				{

+					XSingleton<XDebug>.singleton.AddErrorLog("Tpl haven't FadeIn Component but Fetch try to get it.", null, null, null, null, null);

+				}

+				else

+				{

+					ixtweenFadeIn.PlayFadeIn();

+				}

+			}

+		}

+

+		public void FakeReturnAll()

+		{

+			this._ToBeRemoved.Clear();

+			for (int i = this._used.Count - 1; i >= 0; i--)

+			{

+				bool flag = this._used[i];

+				if (flag)

+				{

+					this._ToBeRemoved.Push(i);

+				}

+			}

+			this._ActiveCount = 0;

+		}

+

+		public void ActualReturnAll(bool bChangeParent = false)

+		{

+			while (this._ToBeRemoved.Count > 0)

+			{

+				int index = this._ToBeRemoved.Pop();

+				this._DisableGameObject(this._pool[index], bChangeParent);

+				this._used[index] = false;

+			}

+		}

+

+		public void ReturnAll(bool bChangeParent = false)

+		{

+			for (int i = 0; i < this._pool.Count; i++)

+			{

+				GameObject go = this._pool[i];

+				this._DisableGameObject(go, bChangeParent);

+			}

+			for (int j = 0; j < this._used.Count; j++)

+			{

+				this._used[j] = false;

+			}

+			this._ActiveCount = 0;

+		}

+

+		public void ReturnAllDisable()

+		{

+			for (int i = 0; i < this._pool.Count; i++)

+			{

+				bool flag = !this._pool[i].activeSelf;

+				if (flag)

+				{

+					bool flag2 = i < this._used.Count;

+					if (flag2)

+					{

+						this._used[i] = false;

+					}

+					this._ActiveCount--;

+				}

+			}

+		}

+

+		public void ReturnInstance(GameObject go, bool bChangeParent = false)

+		{

+			this._DisableGameObject(go, bChangeParent);

+			int num = -1;

+			for (int i = 0; i < this._pool.Count; i++)

+			{

+				bool flag = this._pool[i] == go;

+				if (flag)

+				{

+					num = i;

+					break;

+				}

+			}

+			bool flag2 = num > -1 && num < this._used.Count;

+			if (flag2)

+			{

+				this._used[num] = false;

+			}

+			this._ActiveCount--;

+		}

+

+		public void ReturnAny(int count, bool bChangeParent = false)

+		{

+			int num = 0;

+			while (num < this._pool.Count && count > 0)

+			{

+				bool flag = this._used[num];

+				if (flag)

+				{

+					this._used[num] = false;

+					this._DisableGameObject(this._pool[num], bChangeParent);

+					this._ActiveCount--;

+					count--;

+				}

+				num++;

+			}

+		}

+

+		private void _DisableGameObject(GameObject go, bool bChangeParent)

+		{

+			if (bChangeParent)

+			{

+				go.transform.parent = this._tpl.transform.parent;

+			}

+			bool bEffectiveMode = this._bEffectiveMode;

+			if (bEffectiveMode)

+			{

+				go.transform.localPosition = Vector3.one * (float)XUIPool._far_far_away;

+			}

+			else

+			{

+				this.MakeGameObjectEnabled(go, false);

+			}

+		}

+

+		public void GetActiveList(List<GameObject> ret)

+		{

+			int i = 0;

+			int count = this._pool.Count;

+			while (i < count)

+			{

+				GameObject gameObject = this._pool[i];

+				bool bEffectiveMode = this._bEffectiveMode;

+				if (bEffectiveMode)

+				{

+					bool flag = gameObject.transform.localPosition.x < (float)XUIPool._far_far_away;

+					if (flag)

+					{

+						ret.Add(gameObject);

+					}

+				}

+				else

+				{

+					bool activeInHierarchy = gameObject.activeInHierarchy;

+					if (activeInHierarchy)

+					{

+						ret.Add(gameObject);

+					}

+				}

+				i++;

+			}

+		}

+

+		protected void MakeGameObjectEnabled(GameObject go, bool enabled)

+		{

+			go.SetActive(enabled);

+		}

+

+		public void PlayFadeInWithActiveList()

+		{

+			List<GameObject> list = ListPool<GameObject>.Get();

+			this.GetActiveList(list);

+			bool flag = list.Count != 0;

+			if (flag)

+			{

+				IXTweenFadeIn ixtweenFadeIn = list[0].GetComponent("TweenFadeIn") as IXTweenFadeIn;

+				bool flag2 = ixtweenFadeIn == null;

+				if (flag2)

+				{

+					XSingleton<XDebug>.singleton.AddErrorLog("Tpl ActiveList haven't FadeIn Component but Fetch try to get it.", null, null, null, null, null);

+				}

+				else

+				{

+					ixtweenFadeIn.ResetGroupDelay();

+					for (int i = 0; i < list.Count; i++)

+					{

+						this.CheckFadeIn(true, list[i]);

+					}

+				}

+			}

+			ListPool<GameObject>.Release(list);

+		}

+	}

+}