implemented object pooling for projectiles and floating damage text

Author: ValentinGurkov

Combat/Projectile.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections;
 using RPG.Attributes;
+using RPG.Util;
 using UnityEngine;
 using UnityEngine.Events;
 
@@ -19,14 +21,24 @@ public class Projectile : MonoBehaviour {
         private float damage = 0;
         private Health target = null;
         private GameObject instigator = null;
+        private ObjectPooler pooler;
+        private string poolTag;
         /// <summary>
         /// Can update UI when damaging an enemy (e.g. update enemy health on HUD)
         /// </summary>
         private Action updateUI = null;
+        private float originalSpeed;
 
-        private void Start() {
-            transform.LookAt(GetAimLocation());
-            onLaunch.Invoke();
+        private void Awake() {
+            pooler = ObjectPooler.Instace;
+            originalSpeed = speed;
+        }
+
+        private void LookTowardsTarget() {
+            if (target != null) {
+                transform.LookAt(GetAimLocation());
+                onLaunch.Invoke();
+            }
         }
 
         private void Update() {
@@ -37,6 +49,7 @@ private void Update() {
                 transform.LookAt(GetAimLocation());
             }
             transform.Translate(Vector3.forward * speed * Time.deltaTime);
+            StartCoroutine(ReturnToPoolWithDelay(projectileTTL));
         }
 
         private void OnTriggerEnter(Collider other) {
@@ -45,15 +58,19 @@ private void OnTriggerEnter(Collider other) {
                 return;
             }
 
+            foreach (GameObject toDestroy in destroyAfterHit) {
+                toDestroy.SetActive(true);
+            }
+
             Health targetHealth = other.GetComponent<Health>();
 
             if (targetHealth == null) { // to disallow friendly fire -  || targetHealth != target
-                Destroy(gameObject);
+                ReturnToPool();
                 return;
             }
 
             if (targetHealth.IsDead) {
-                Destroy(gameObject, projectileTTL);
+                StartCoroutine(ReturnToPoolWithDelay(projectileTTL));
                 return;
             }
 
@@ -73,7 +90,7 @@ private void OnTriggerEnter(Collider other) {
             }
 
             foreach (GameObject toDestroy in destroyAfterHit) {
-                Destroy(toDestroy);
+                toDestroy.SetActive(false);
             }
 
             onHit.Invoke();
@@ -82,7 +99,7 @@ private void OnTriggerEnter(Collider other) {
                 updateUI();
             }
 
-            Destroy(gameObject, afterHitTTL);
+            StartCoroutine(ReturnToPoolWithDelay(afterHitTTL));
         }
 
         private Vector3 GetAimLocation() {
@@ -93,11 +110,36 @@ private Vector3 GetAimLocation() {
             return target.transform.position + Vector3.up * targetCollider.height / 2;
         }
 
+        private void ReturnToPool() {
+            pooler.AddToPool(poolTag, gameObject);
+        }
+
+        private IEnumerator ReturnToPoolWithDelay(float delay) {
+            yield return new WaitForSeconds(delay);
+            ReturnToPool();
+        }
+
+        // TODO finish this
+        /// <summary>
+        /// Sets the target for the projectile.
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="instigator"></param>
+        /// <param name="damage"></param>
+        /// <param name="updateUI"></param>
         public void SetTarget(Health target, GameObject instigator, float damage, Action updateUI) {
             this.target = target;
             this.damage = damage;
             this.instigator = instigator;
             this.updateUI = updateUI;
+            speed = originalSpeed;
+            LookTowardsTarget();
+        }
+
+        public void SetPoolTag(string tag) {
+            if (string.IsNullOrEmpty(poolTag)) {
+                poolTag = tag;
+            }
         }
     }
 }

Combat/WeaponConfig.cs

@@ -1,5 +1,6 @@
 using System;
 using RPG.Attributes;
+using RPG.Util;
 using UnityEngine;
 
 namespace RPG.Combat {
@@ -8,6 +9,7 @@ namespace RPG.Combat {
     public class WeaponConfig : ScriptableObject {
         [SerializeField] private AnimatorOverrideController animatorOverride = null;
         [SerializeField] private Weapon equippedPrefab = null;
+        [SerializeField] private string projectileTag = "arrow";
         [SerializeField] private Projectile projectile = null;
         [SerializeField] private float weaponRange = 3f;
         [SerializeField] private float weaponDamage = 25f;
@@ -16,7 +18,7 @@ public class WeaponConfig : ScriptableObject {
         private const string WEAPON_NAME = "Weapon";
         private const string DESTORYING = "Destroying";
         private enum HAND { LEFT, RIGHT }
-
+        private ObjectPooler pooler = null;
         public float Range => weaponRange;
         public float Damage => weaponDamage;
         public float PercentageBous => percentageBonus;
@@ -37,6 +39,12 @@ private Transform GetTransform(Transform rightHand, Transform leftHand) {
             return hand == HAND.RIGHT ? rightHand : leftHand;
         }
 
+        private void EstablishPoolerReference() {
+            if (pooler == null) {
+                pooler = ObjectPooler.Instace;
+            }
+        }
+
         public Weapon Spawn(Transform rightHand, Transform leftHand, Animator animator) {
             DestroyOldWeapon(rightHand, leftHand);
             Weapon weapon = null;
@@ -69,8 +77,16 @@ public bool HasProjectile() {
         /// <param name="calculatedDamage"></param>
         /// <param name="updateUI"></param>
         public void LaunchProjectile(Transform rightHand, Transform leftHand, Health target, GameObject instigator, float calculatedDamage, Action updateUI) {
-            Projectile projectileInstance = Instantiate(projectile, GetTransform(rightHand, leftHand).position, Quaternion.identity);
+            EstablishPoolerReference();
+            GameObject instance = pooler.SpawnFromPool(projectileTag);
+            if (!instance) {
+                return;
+            }
+            Projectile projectileInstance = instance.GetComponent<Projectile>();
+            projectileInstance.transform.position = GetTransform(rightHand, leftHand).position;
+            projectile.transform.rotation = Quaternion.identity;
             projectileInstance.SetTarget(target, instigator, calculatedDamage, updateUI);
+            projectileInstance.SetPoolTag(projectileTag);
         }
     }
 }

UI/Damage Text/DamageText.cs

@@ -1,13 +1,26 @@
 using System;
+using RPG.Util;
 using UnityEngine;
 using UnityEngine.UI;
 
 namespace RPG.UI {
     public class DamageText : MonoBehaviour {
         [SerializeField] private Text damageText = null;
+        private ObjectPooler pooler;
+        private string poolTag;
+
+        private void Awake() {
+            pooler = ObjectPooler.Instace;
+        }
 
         public void DestroyText() {
-            Destroy(gameObject);
+            pooler.AddToPool(poolTag, gameObject);
+        }
+
+        public void SetPoolTag(string tag) {
+            if (string.IsNullOrEmpty(poolTag)) {
+                poolTag = tag;
+            }
         }
 
         public void SetValue(float amount) {

UI/Damage Text/DamageTextSpawner.cs

@@ -1,12 +1,25 @@
-using UnityEngine;
+using RPG.Util;
+using UnityEngine;
 
 namespace RPG.UI {
     public class DamageTextSpawner : MonoBehaviour {
+        [SerializeField] private string poolTag = "damageText";
         [SerializeField] private DamageText damageTextPrefab = null;
+        private ObjectPooler pooler;
+
+        private void Start() {
+            pooler = ObjectPooler.Instace;
+        }
 
         public void Spawn(float damage) {
-            DamageText instance = Instantiate<DamageText>(damageTextPrefab, transform);
-            instance.SetValue(damage);
+            GameObject instance = pooler.SpawnFromPool(poolTag);
+            if (instance == null) {
+                return;
+            }
+            instance.transform.position = transform.position;
+            DamageText damageText = instance.GetComponent<DamageText>();
+            damageText.SetValue(damage);
+            damageText.SetPoolTag(poolTag);
         }
     }
 

Util/ObjectPooler.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace RPG.Util {
+    public class ObjectPooler : MonoBehaviour {
+
+        [System.Serializable]
+        private struct Pool {
+            public string tag;
+            public GameObject prefab;
+            public int size;
+        }
+
+        [SerializeField] private List<Pool> pools;
+        [SerializeField] private Dictionary<string, Queue<GameObject>> poolDict;
+
+        public static ObjectPooler Instace;
+
+        private void Awake() {
+            Instace = this;
+            poolDict = new Dictionary<string, Queue<GameObject>>();
+
+            FillPools();
+        }
+
+        private void FillPools() {
+            for (int i = 0; i < pools.Count; i++) {
+                Queue<GameObject> objectPool = new Queue<GameObject>();
+                for (int j = 0; j < pools[i].size; j++) {
+                    GameObject obj = Instantiate(pools[i].prefab);
+                    obj.transform.SetParent(transform);
+                    obj.SetActive(false);
+                    objectPool.Enqueue(obj);
+                }
+                poolDict.Add(pools[i].tag, objectPool);
+            }
+        }
+
+        public void FillPool(string tag) {
+            if (!poolDict.ContainsKey(tag)) {
+                return;
+            }
+            Pool pool = pools.Find(p => p.tag == tag);
+            for (int j = 0; j < pool.size; j++) {
+                GameObject obj = Instantiate(pool.prefab);
+                obj.transform.SetParent(transform);
+                obj.SetActive(false);
+                poolDict[tag].Enqueue(obj);
+            }
+        }
+
+        public void AddToPool(string tag, GameObject instance) {
+            if (!poolDict.ContainsKey(tag)) {
+                return;
+            }
+            instance.SetActive(false);
+            poolDict[tag].Enqueue(instance);
+        }
+
+        public GameObject SpawnFromPool(string tag) {
+            if (!poolDict.ContainsKey(tag)) {
+                return null;
+            }
+
+            if (poolDict[tag].Count == 0) {
+                FillPool(tag);
+            }
+
+            GameObject instance = poolDict[tag].Dequeue();
+            instance.SetActive(true);
+
+            return instance;
+
+        }
+    }
+
+}