bingo 项目提交

Assets/BingoSun/Scripts/Shung/ShungH/ShungTik.cs

@@ -0,0 +1,174 @@
+using System;
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace BingoBrain.Core
+{
+    public class ShungTik
+    {
+        private Transform m_releaseRoot;
+        private Transform m_getRoot;
+        private Action<GameObject> m_onNew;
+        private Action<GameObject> m_onGet;
+        private Action<GameObject> m_onRelease;
+
+        private Dictionary<string, Shungbass> m_pools = new();
+
+        public int CountAll
+        {
+            get
+            {
+                int countAll = 0;
+                foreach (Shungbass poolItem in m_pools.Values)
+                {
+                    countAll += poolItem.CountAll;
+                }
+
+                return countAll;
+            }
+        }
+
+        public int CountInactive
+        {
+            get
+            {
+                int countInactive = 0;
+                foreach (Shungbass poolItem in m_pools.Values)
+                {
+                    countInactive += poolItem.CountInactive;
+                }
+
+                return countInactive;
+            }
+        }
+
+        public int CountActive
+        {
+            get
+            {
+                int countActive = 0;
+                foreach (Shungbass poolItem in m_pools.Values)
+                {
+                    countActive += poolItem.CountActive;
+                }
+
+                return countActive;
+            }
+        }
+
+        public void InitRoot(Transform releaseRoot = null, Transform getRoot = null)
+        {
+            m_releaseRoot = releaseRoot;
+            m_getRoot = getRoot;
+        }
+
+        public void InitCallBack(Action<GameObject> onNew, Action<GameObject> onGet, Action<GameObject> onRelease)
+        {
+            m_onNew = onNew;
+            m_onGet = onGet;
+            m_onRelease = onRelease;
+        }
+
+
+
+
+        public GameObject Get(string prefabPath, string assetName)
+        {
+            var poolName = $"{prefabPath} | {assetName}";
+            if (!m_pools.ContainsKey(poolName))
+            {
+                RegisterNew(prefabPath, assetName);
+            }
+
+            Shungbass pool = m_pools[poolName];
+            return pool.Get();
+        }
+
+
+
+
+        public void Release(string prefabPath, GameObject obj)
+        {
+            Shungbass pool = null;
+            if (m_pools.TryGetValue(prefabPath, out pool))
+            {
+                pool.Release(obj);
+            }
+        }
+
+
+
+
+        public void Release(GameObject obj)
+        {
+            Shungbass pool = null;
+            foreach (Shungbass poolItem in m_pools.Values)
+            {
+                if (poolItem.Contains(obj))
+                {
+                    pool = poolItem;
+                    break;
+                }
+            }
+
+            pool.Release(obj);
+        }
+
+
+
+
+        public void ReleaseAll()
+        {
+            foreach (Shungbass poolItem in m_pools.Values)
+            {
+                poolItem.ReleaseAll();
+            }
+        }
+
+
+
+
+        private void RegisterNew(string prefabPath, string assetName)
+        {
+            Shungbass pool = new Shungbass();
+            pool.Init(prefabPath, assetName, m_releaseRoot, m_getRoot);
+            pool.InitCallBack(m_onNew, m_onGet, m_onRelease);
+            m_pools.Add($"{prefabPath} | {assetName}", pool);
+        }
+
+
+
+
+        public void ClearPool(string prefabPath)
+        {
+            Shungbass pool = null;
+            if (m_pools.TryGetValue(prefabPath, out pool))
+            {
+                pool.Clear();
+                m_pools.Remove(prefabPath);
+            }
+        }
+
+
+
+
+        public void Clear()
+        {
+            foreach (Shungbass pool in m_pools.Values)
+            {
+                pool.Clear();
+            }
+
+            m_pools.Clear();
+        }
+
+
+
+
+        public void Dispose()
+        {
+            Clear();
+            m_pools = null;
+        }
+    }
+}

Assets/BingoSun/Scripts/Shung/ShungH/ShungTik.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bee36af719023d5418e02e67aa18ba0f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BingoSun/Scripts/Shung/ShungH/Shungbass.cs

@@ -0,0 +1,220 @@
+using System;
+using UnityEngine;
+using BingoBrain.Asset;
+using System.Collections.Generic;
+
+namespace BingoBrain.Core
+{
+    public class Shungbass
+    {
+        private Transform m_prefabRoot;
+        private Transform m_releaseRoot;
+        private Transform m_getRoot;
+
+        private Action<GameObject> m_onNew;
+        private Action<GameObject> m_onGet;
+        private Action<GameObject> m_onRelease;
+
+        private List<GameObject> m_objects;
+        private GameObject m_prefab;
+
+        public int CountAll { get; private set; }
+        public int CountInactive { get; private set; }
+
+        public int CountActive
+        {
+            get { return CountAll - CountInactive; }
+        }
+
+        public void Init(string prefabPath, string assetName, Transform releaseRoot = null, Transform getRoot = null)
+        {
+            m_objects = new List<GameObject>();
+            m_prefab = BetKit.Instance.LoadGameObject(prefabPath, assetName);
+
+            m_prefabRoot = m_prefab.transform.parent;
+            m_releaseRoot = releaseRoot;
+            m_getRoot = getRoot;
+        }
+
+        public void Init(GameObject prefab, Transform releaseRoot = null, Transform getRoot = null)
+        {
+            m_objects = new List<GameObject>();
+            m_prefab = prefab;
+
+            m_prefabRoot = m_prefab.transform.parent;
+            m_releaseRoot = releaseRoot;
+            m_getRoot = getRoot;
+        }
+
+        public void InitCallBack(Action<GameObject> onNew, Action<GameObject> onGet, Action<GameObject> onRelease)
+        {
+            m_onNew = onNew;
+            m_onGet = onGet;
+            m_onRelease = onRelease;
+        }
+
+
+
+
+        public GameObject Get()
+        {
+            GameObject obj = null;
+            for (int i = m_objects.Count - 1; i >= 0; i--)
+            {
+                GameObject objItem = m_objects[i];
+                if (!objItem)
+                {
+                    m_objects.Remove(objItem);
+                    CountAll--;
+                    continue;
+                }
+
+                if (!objItem.activeSelf)
+                {
+                    obj = objItem;
+                    CountInactive--;
+                    break;
+                }
+            }
+
+            if (obj == null)
+            {
+                obj = Uvsjk.Instantiate(m_prefab);
+                m_objects.Add(obj);
+                CountAll++;
+
+                if (m_onNew != null)
+                {
+                    m_onNew(obj);
+                }
+            }
+
+            if (m_getRoot)
+            {
+                obj.transform.SetParent(m_getRoot, false);
+            }
+            else
+            {
+                if (m_prefabRoot)
+                {
+                    obj.transform.SetParent(m_prefabRoot, false);
+                }
+            }
+
+            if (m_onGet != null)
+            {
+                m_onGet(obj);
+            }
+
+            obj.SetActive(true);
+            return obj;
+        }
+
+
+
+
+        public void Release(GameObject obj)
+        {
+            if (Contains(obj))
+            {
+                if (m_releaseRoot)
+                {
+                    obj.transform.SetParent(m_releaseRoot, false);
+                }
+
+                obj.SetActive(false);
+                CountInactive++;
+
+                if (m_onRelease != null)
+                {
+                    m_onRelease(obj);
+                }
+            }
+        }
+
+
+
+
+        public bool Contains(GameObject obj)
+        {
+            return m_objects.Contains(obj);
+        }
+
+
+
+
+        public void ReleaseAll()
+        {
+            for (int i = m_objects.Count - 1; i >= 0; i--)
+            {
+                GameObject objItem = m_objects[i];
+                if (!objItem)
+                {
+                    m_objects.Remove(objItem);
+                    CountAll--;
+                    continue;
+                }
+
+                if (objItem.activeSelf)
+                {
+                    Release(objItem);
+                }
+            }
+        }
+
+
+
+
+        public void ClearNotActive()
+        {
+            for (int i = m_objects.Count - 1; i >= 0; i--)
+            {
+                GameObject objItem = m_objects[i];
+                if (!objItem.activeSelf)
+                {
+                    DestroyObj(objItem);
+                    m_objects.Remove(objItem);
+                }
+            }
+        }
+
+
+
+
+        public void Clear()
+        {
+            for (int i = m_objects.Count - 1; i >= 0; i--)
+            {
+                GameObject objItem = m_objects[i];
+                if (!objItem)
+                {
+                    m_objects.Remove(objItem);
+                    CountAll--;
+                    continue;
+                }
+
+                DestroyObj(objItem);
+            }
+
+            m_objects.Clear();
+        }
+
+
+
+
+        private void DestroyObj(GameObject obj)
+        {
+            Uvsjk.Destroy(obj.gameObject);
+        }
+
+
+
+
+        public void Dispose()
+        {
+            Clear();
+            m_prefab = null;
+            m_objects = null;
+        }
+    }
+}

Assets/BingoSun/Scripts/Shung/ShungH/Shungbass.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eea317353b47da1469658e1c85c9750c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: