对象池介绍

爱被打了一巴掌 2023-10-13 15:54 41阅读 0赞

## 对象池介绍 ##

对象池是一种常见的优化技术，用于减少游戏运行时的内存分配和垃圾回收。对象池维护了一组已经创建的对象实例，这些对象可以被多次重复使用，而不需要每次都重新创建和销毁。对象池的主要优点是可以减少内存分配和垃圾回收的次数，从而提高游戏的运行效率。

在 Unity 中，对象池通常使用 `List` 或 `Queue` 来存储对象实例。当需要使用对象时，从对象池中取出一个对象并初始化，当不需要使用对象时，将对象重置并放回对象池中。

## 对象池方法 ##

在 Unity 中，可以使用以下方法来实现对象池：

### 创建对象池 ###

List<GameObject> objectPool = new List<GameObject>(); // 使用 List 存储对象池

或者使用 `Queue` 存储对象池：

Queue<GameObject> objectPool = new Queue<GameObject>(); // 使用 Queue 存储对象池

### 初始化对象池 ###

在游戏开始时，可以创建一定数量的对象并添加到对象池中，以便在游戏运行时可以快速地使用这些对象。

public GameObject prefab; // 对象池中存储的对象预制体
    public int poolSize = 10; // 对象池的大小
    
    private List<GameObject> objectPool = new List<GameObject>();
    
    void Start()
    {
        
        for (int i = 0; i < poolSize; i++)
        {
        
            GameObject obj = Instantiate(prefab);
            obj.SetActive(false); // 初始状态下，对象不激活
            objectPool.Add(obj);
        }
    }

### 从对象池中取出对象 ###

private GameObject GetObjectFromPool()
    {
        
        GameObject obj;
        if (objectPool.Count > 0)
        {
        
            obj = objectPool[0];
            objectPool.RemoveAt(0);
        }
        else
        {
        
            obj = Instantiate(prefab);
        }
    
        obj.SetActive(true);
        return obj;
    }

在上述代码中，如果对象池中有可用的对象，则从对象池中取出一个对象并返回。如果对象池中没有可用的对象，则创建一个新的对象并返回。在返回对象之前，需要将对象设置为激活状态。

### 将对象放回对象池 ###

private void ReturnObjectToPool(GameObject obj)
    {
        
        obj.SetActive(false);
        objectPool.Add(obj);
    }

在上述代码中，将对象设置为不激活状态，并将对象添加回对象池中。

## 对象池举例子 ##

下面是一些常见的使用对象池的例子：

### 对象池管理器 ###

可以创建一个对象池管理器，用于管理多个对象池。在对象池管理器中，可以根据对象的类型（例如敌人、子弹、道具等）创建不同的对象池，并提供从对象池中获取和回收对象的方法。

public class ObjectPoolManager : MonoBehaviour
    {
        
        public static ObjectPoolManager instance;
    
        private Dictionary<string, List<GameObject>> objectPools = new Dictionary<string, List<GameObject>>();
    
        private void Awake()
        {
        
            instance = this;
        }
    
        public GameObject GetObjectFromPool(string poolName)
        {
        
            if (!objectPools.ContainsKey(poolName))
            {
        
                objectPools.Add(poolName, new List<GameObject>());
            }
    
            List<GameObject> pool = objectPools[poolName];
            GameObject obj;
    
            if (pool.Count > 0)
            {
        
                obj = pool[0];
                pool.RemoveAt(0);
            }
            else
            {
        
                obj = Instantiate(prefab);
            }
    
            obj.SetActive(true);
            return obj;
        }
    
        public void ReturnObjectToPool(GameObject obj, string poolName)
        {
        
            obj.SetActive(false);
    
            if (!objectPools.ContainsKey(poolName))
            {
        
                objectPools.Add(poolName, new List<GameObject>());
            }
    
            List<GameObject> pool = objectPools[poolName];
            pool.Add(obj);
        }
    }

在上述代码中，我们定义了一个 `ObjectPoolManager` 类，用于管理多个对象池。在 `GetObjectFromPool()` 方法中，我们根据对象池的名称从字典中获取相应的对象池。如果对象池不存在，则创建一个新的对象池。然后从对象池中获取一个对象并返回。在 `ReturnObjectToPool()` 方法中，我们首先将对象设置为不激活状态，然后将对象添加回对象池中。

### 子弹对象池 ###

可以创建一个子弹对象池，用于管理多个子弹。当需要发射子弹时，从对象池中获取一个子弹并初始化，当子弹碰撞到物体或者到达一定距离时，将子弹重置并放回对象池中。

public class BulletPool : MonoBehaviour
    {
        
        public GameObject bulletPrefab;
        public int poolSize = 10;
        public float lifetime = 2f;
    
        private List<GameObject> bulletPool = new List<GameObject>();
    
        void Start()
        {
        
            for (int i = 0; i < poolSize; i++)
            {
        
                GameObject bullet = Instantiate(bulletPrefab);
                bullet.SetActive(false);
                bulletPool.Add(bullet);
            }
        }
    
        public void ShootBullet(Vector3 position, Quaternion rotation, Vector3 direction)
        {
        
            GameObject bullet = GetBulletFromPool();
            bullet.transform.position = position;
            bullet.transform.rotation = rotation;
            bullet.GetComponent<Bullet>().SetDirection(direction);
            StartCoroutine(ReturnBulletToPool(bullet));
        }
    
        private GameObject GetBulletFromPool()
        {
        
            GameObject bullet;
            if (bulletPool.Count > 0)
            {
        
                bullet = bulletPool[0];
                bulletPool.RemoveAt(0);
            }
            else
            {
        
                bullet = Instantiate(bulletPrefab);
            }
    
            bullet.SetActive(true);
            return bullet;
        }
    
        private IEnumerator ReturnBulletToPool(GameObject bullet)
        {
        
            yield return new WaitForSeconds(lifetime);
            bullet.SetActive(false);
            bulletPool.Add(bullet);
        }
    }

在上述代码中，我们定义了一个 `BulletPool` 类，用于管理多个子弹。在 `Start()` 方法中，我们创建了一定数量的子弹并添加到对象池中。在 `ShootBullet()` 方法中，我们从对象池中获取一个子弹并初始化，然后启动一个协程，等待子弹到达一定距离或者碰撞到物体后，将子弹重置并放回对象池中。在协程 `ReturnBulletToPool()` 中，我们使用 `yield return new WaitForSeconds(lifetime)` 等待一定时间后，将子弹设置为不激活状态并添加回对象池中。

![在这里插入图片描述][8b18cedb8b2347e58795172be20da805.png]

[8b18cedb8b2347e58795172be20da805.png]: https://img-blog.csdnimg.cn/8b18cedb8b2347e58795172be20da805.png