PoolEssentials.cs

Go to the documentation of this file.

using System.Collections.Generic;
 
namespace UnityEngine
{
    [System.Serializable]
    public class PoolEssentials
    {
        private List<GameObject> referencedObjects = new List<GameObject>();
        [Tooltip("The prefabs of the GameObjects to be spawned for the pool.")]
        public GameObject[] baseObjects = new GameObject[1];
        public int activeIndex { get; private set; }
        public int nextBaseObjectIndex { get; private set; }
        [Tooltip("Should the selection of the next base object to instantiate be random? If false, the selection will be made in order looping through the baseObjects array.")]
        public bool randomInstantiationSequence = false;
        [Tooltip("The size of the pool. How many referenced objects it han have.")]
        public int size = 10;
        private RandomEssentials randomEssentialsInstantiation = new RandomEssentials();
        private DefaultPositionAndRotation defaultPositionAndRotation = new DefaultPositionAndRotation();
 
        public PoolEssentials() { 
            activeIndex = 0;
            nextBaseObjectIndex = 0;
            referencedObjects = new List<GameObject>();
            size = 10;
        }
 
        public PoolEssentials(GameObject[] baseObjects, int size, bool instantiateAllAtCreation = false, bool randomInstantiationSequence = false, int intantiationRandomizationSeed = -1)
        {
            this.baseObjects = baseObjects;
            this.size = size;
            referencedObjects = new List<GameObject>();
            activeIndex = 0;
            
            this.randomInstantiationSequence = randomInstantiationSequence;
            if (intantiationRandomizationSeed != -1)
                this.randomEssentialsInstantiation = new RandomEssentials(intantiationRandomizationSeed);
            
            if (instantiateAllAtCreation)
                for (int i = 0; i < size; i++)
                    InstantiateNewAt(i);
        }
        
        public PoolEssentials(GameObject baseObject, int size, bool instantiateAllAtCreation = false)
        {
            this.baseObjects = new GameObject[] {baseObject};
            this.size = size;
            referencedObjects = new List<GameObject>();
            activeIndex = 0;
            
            if (instantiateAllAtCreation)
                for (int i = 0; i < size; i++)
                    InstantiateNewAt(i);
        }
 
        public PoolEssentials(GameObject[] baseObjects, int size, Vector3 instantiationPosition, Quaternion instantiationRotation, bool instantiateAllAtCreation = false, bool randomInstantiationSequence = false, int intantiationRandomizationSeed = -1) : this(baseObjects, size, instantiateAllAtCreation, randomInstantiationSequence, intantiationRandomizationSeed)
        {
            defaultPositionAndRotation = new DefaultPositionAndRotation(instantiationPosition, instantiationRotation);
        }
 
        public GameObject Spawn(Vector3 position, Quaternion rotation, Vector3 scale, Transform parent = null)
        {
            if (activeIndex>=referencedObjects.Count || referencedObjects[activeIndex] == null)
                InstantiateNewAt(activeIndex);
 
            if ((referencedObjects.Count <= activeIndex) || (referencedObjects[activeIndex] == null))
            {
                activeIndex = activeIndex.GetLooped(size); //index = index+1<referencedObjects.Length? index+1 : 0;
                Debug.LogError(
                    "An error occured trying to spawn the GameObject using the class Pool\nBe sure that your pools are properly configured.");
                return null;
            }
            else
            {
                referencedObjects[activeIndex].transform.SetProperties(position, rotation, scale);
                if (parent != null)
                    referencedObjects[activeIndex].transform.parent = parent;
                referencedObjects[activeIndex].SetActive(true);
 
                GameObject goToReturn = referencedObjects[activeIndex];
 
 
                activeIndex = activeIndex.GetLooped(size); //index = index+1<referencedObjects.Length? index+1 : 0;
 
                return goToReturn;
            }
        }
 
        public void Load(int quantity, Transform parent = null)
        {
            int remainingQuantity = Mathf.Min(size - referencedObjects.Count, quantity);
            for (int i = 0; i < size; i++)
            {
                if (InstantiateNewAt(i, parent) != null)
                    remainingQuantity--;
                if (remainingQuantity <= 0)
                    break;
            }
        }
        
        private GameObject InstantiateNewAt(int index, Transform parent = null)
        {
            if (referencedObjects.Count >= size || (index < referencedObjects.Count && referencedObjects[index] != null))
                return null;
            
            if (index != referencedObjects.Count)
                Debug.LogWarning($"Trying to instantiate an object in the pool '{this}' but the expected index of the object should be {referencedObjects.Count} and it is {index}.");
            
            GameObject nextToInstantiate = GetNextBaseObjectToInstantiate(true);
            
            if(nextToInstantiate == null)
                return null;
 
            GameObject go = Object.Instantiate(nextToInstantiate, defaultPositionAndRotation.instantiationPosition, defaultPositionAndRotation.instantiationRotation, parent);
            go.SetActive(false);
            referencedObjects.Add(go);
            return go;
        }
 
        private GameObject GetNextBaseObjectToInstantiate(bool register)
        {
            if (randomInstantiationSequence)
            {
                nextBaseObjectIndex = register
                    ? randomEssentialsInstantiation.GetRandomInt(baseObjects.Length)
                    : nextBaseObjectIndex;
            }
            else
            {
                nextBaseObjectIndex = register
                    ? nextBaseObjectIndex.GetLooped(baseObjects.Length)
                    : nextBaseObjectIndex;
            }
            return baseObjects[nextBaseObjectIndex];
        }
 
        public GameObject Disable(GameObject gameObject)
        {
            if (referencedObjects.Contains(gameObject))
            {
                gameObject.SetActive(false);
                return gameObject; 
            }
            else
            {
                Debug.LogWarning("Trying to disable an object ("+gameObject.name+") from a pool that doesn't belong to.");
                return null;
            }
        }
        
        public GameObject Disable(int gameObjectIndexInPool)
        {
            return Disable(referencedObjects[gameObjectIndexInPool]);
        }
        
        [System.Serializable]
        private class DefaultPositionAndRotation
        {
            public Vector3 instantiationPosition = Vector3.zero;
            public Quaternion instantiationRotation = Quaternion.identity;
 
            public DefaultPositionAndRotation() { }
        
            public DefaultPositionAndRotation(Vector3 instantiationPosition, Quaternion instantiationRotation)
            {
                this.instantiationPosition = instantiationPosition;
                this.instantiationRotation = instantiationRotation;
            }
        }
    }
    
 
    
}