游戏设计模式——Unity对象池

对象池这个名字听起来好像不明觉厉，其实就是将一系列需要反复创建和销毁的对象存储在一个看不到的地方，下次用同样的东西时往这里取，类似于一个存放备用物质的仓库。

它的好处就是避免了反复实例化个体的运算，能减少大量内存碎片，当然你需要更多的空间来存这些备用对象，相信使用这些空间是非常值得的。

最常见的应用就是子弹的创建和销毁。

一般对象池都是一个全局性的通用脚本，可以采用单例模式来设计。

https://www.cnblogs.com/koshio0219/p/11203631.html

对象池至少包含以下两个基本功能：

1.从池中取出指定类型的对象

2.回收各式各样的对象到池中

先定义对象池和池子的容量：

     private const int maxCount = ;
     private Dictionary<string, List<GameObject>> pool = new Dictionary<string, List<GameObject>>();

容量是一个常量，最好取二的幂值，这样的话可以刚好占用所有内存位的资源，避免浪费。

这里池子用字典标识，key为对象的名字，这样比较好记，你用InstanceID也没问题。

每个同样的对象一般在池子中可以有很多，用一个List来存。

下面先定义回收对象的方法：

     public void RecycleObj(GameObject obj)
     {
         var par = Camera.main;
         obj.transform.SetParentSafe(par.transform);
         obj.SetActive(false);

         if (pool.ContainsKey(obj.name))
         {
             if (pool[obj.name].Count < maxCount)
             {
                 pool[obj.name].Add(obj);
             }
         }
         else
         {
             pool.Add(obj.name, new List<GameObject>() { obj });
         }
     }

这里将回收的对象统一放在了场景主摄像机下，你也可以选择放在自己喜欢的位置。

回收对象就是先把对象隐藏，然后看池子中有没有这一类对象，有的话没有超过容量上限就直接扔进去。

如果没有这类对象，那就创建这一类型对象的Key值（名字：比如说螃蟹），顺便添加第一只螃蟹。

如果回收对象时改变了父物体，最好在设置父物体前后记录下对象的本地位置，旋转和缩放，可以写了一个扩展方法用于安全设置父物体：

     public static void SetParentSafe(this Transform transform,Transform parent)
     {
         var lp = transform.localPosition;
         var lr = transform.localRotation;
         var ls = transform.localScale;
         transform.SetParent(parent);
         transform.localPosition = lp;
         transform.localRotation = lr;
         transform.localScale = ls;
     }

经常会遇到要批量回收进池子的情况：

     public void RecycleAllChildren(GameObject parent)
     {
         for (; parent.transform.childCount > ;)
         {
             var tar = parent.transform.GetChild().gameObject;
             RecycleObj(tar);
         }
     }

对象可以回收了，那怎么取呢，自然也是能从池子里取就从池子里取，实在不行才去实例化：

     public GameObject GetObj(GameObject perfab)
     {
         //池子中有
         GameObject result = null;
         if (pool.ContainsKey(perfab.name))
         {
             if (pool[perfab.name].Count > )
             {
                 result = pool[perfab.name][];
                 result.SetActive(true);
                 pool[perfab.name].Remove(result);
                 return result;
             }
         }
         //池子中缺少
         result = Object.Instantiate(perfab);
         result.name = perfab.name;
         RecycleObj(result);
         GetObj(result);
         return result;
     }

如果池子中有对象，取出来之后记得要把这个对象从该类对象的列表中移除，不然下次可能又会取到这家伙，而这家伙已经要派去做别的了。

如果池子中缺少对象，那就只能实例化了，要注意把实例化后的对应改为大家都一样的名字，这样方便下一次取能找到它。

没有对象的情况下，我这里又重新回收了一下再取一次，你也可以直接返回该对象，相当于在取的时候不存在这类对象的话我提前做了标记。

和Instantiate方法一样，加一个可以设置父对象的重载方法：

     public GameObject GetObj(GameObject perfab, Transform parent)
     {
         var result = GetObj(perfab);
         result.transform.SetParentSafe(parent);
         return result;
     }

下面是完整脚本：

 using System.Collections.Generic;
 using UnityEngine;

 public class ObjectPool : Singleton<ObjectPool>
 {
     private const int maxCount = ;
     private Dictionary<string, List<GameObject>> pool = new Dictionary<string, List<GameObject>>();

     public GameObject GetObj(GameObject perfab)
     {
         //池子中有
         GameObject result = null;
         if (pool.ContainsKey(perfab.name))
         {
             if (pool[perfab.name].Count > )
             {
                 result = pool[perfab.name][];
                 if (result != null)
                 {
                     result.SetActive(true);
                     pool[perfab.name].Remove(result);
                     return result;
                 }
                 else
                 {
                     pool.Remove(perfab.name);
                 }
             }
         }
         //池子中缺少
         result = Object.Instantiate(perfab);
         result.name = perfab.name;
         RecycleObj(result);
         GetObj(result);
         return result;
     }

     public GameObject GetObj(GameObject perfab, Transform parent)
     {
         var result = GetObj(perfab);
         result.transform.SetParentSafe(parent);
         return result;
     }

     public void RecycleObj(GameObject obj)
     {
         var par = Camera.main;
         obj.transform.SetParentSafe(par.transform);
         obj.SetActive(false);

         if (pool.ContainsKey(obj.name))
         {
             if (pool[obj.name].Count < maxCount)
             {
                 pool[obj.name].Add(obj);
             }
         }
         else
         {
             pool.Add(obj.name, new List<GameObject>() { obj });
         }
     }

     public void RecycleAllChildren(GameObject parent)
     {
         for (; parent.transform.childCount > ;)
         {
             var tar = parent.transform.GetChild().gameObject;
             RecycleObj(tar);
         }
     }

     public void Clear()
     {
         pool.Clear();
     }
 }

因为是用名字作为存储的Key值，所以不同类的物体命名不能相同，不然可能会取错对象。

另外由于上面的脚本有更改父物体的情况，在取出物体之后根据需要也可以对transform进行归位：

     public static void ResetLocal(this Transform transform)
     {
         transform.localPosition = Vector3.zero;
         transform.localRotation = Quaternion.identity;
         transform.localScale = Vector3.one;
     }

上面是对Transform类的一个扩展方法，例如：

  var ins = ObjectPool.Instance.GetObj(bulletPrefab, parent.transform);
  ins.transform.ResetLocal();