com.amanotes.prefabpool 1.0.1 → 1.0.2

package/Runtime/PrefabPool.cs

@@ -48,13 +48,12 @@ namespace Amanotes.Core
                 resultGameObject.hideFlags = HideFlags.DontSave;
             }
             
-            // Move to spawn parent when retrieved
             var t = resultGameObject.transform;
             t.SetParent(spawnParent, false);
             t.localPosition = localPosition;
             t.localRotation = Quaternion.identity;
+            resultGameObject.SetActive(true);
             
-            // Call OnGet on any IPoolPrefab components
             var poolComponents = resultGameObject.GetComponents<IPoolPrefab>();
             foreach (var pp in poolComponents)
             {
@@ -68,7 +67,6 @@ namespace Amanotes.Core
         {
             if (gameObject == null) return;
             
-            // Call OnReturn on any IPoolPrefab components
             var poolComponents = gameObject.GetComponents<IPoolPrefab>();
             foreach (var pp in poolComponents)
             {
@@ -76,6 +74,7 @@ namespace Amanotes.Core
             }
             
             var t = gameObject.transform;
+            gameObject.SetActive(false);
             t.SetParent(poolParent, false);
             t.localPosition = Vector3.zero;
             _pool.Add(gameObject);
@@ -93,12 +92,15 @@ namespace Amanotes.Core
             _pool.Clear();
         }
         
+        public void PurgeDestroyed() => _pool.RemoveAll(obj => obj == null);
+        
         public IEnumerator PreAllocate(Transform poolParent)
         {
             for (var i = 0; i < prewarmCount; i++)
             {
                 var instance = UnityObject.Instantiate(prefab, poolParent.position, Quaternion.identity, poolParent);
                 instance.hideFlags = HideFlags.DontSave;
+                instance.SetActive(false);
                 _pool.Add(instance);
             }
             
@@ -120,16 +122,16 @@ namespace Amanotes.Core
             _prefabPool = prefabPool;
             _spawnParent = spawnParent;
             
-            // Set parent group reference for each entry
             foreach (var entry in entries)
             {
                 entry.SetParentGroup(this);
+                entry.PurgeDestroyed();
             }
             
-            // Set parent group reference for fallback entry
             if (fallbackEntry != null)
             {
                 fallbackEntry.SetParentGroup(this);
+                fallbackEntry.PurgeDestroyed();
             }
         }
         
@@ -257,6 +259,7 @@ namespace Amanotes.Core
     {
         [NonSerialized] private bool _isDestroyed = false;
         [NonSerialized] private bool _isReady = false;
+        [NonSerialized] private bool _isInitializing = false;
         [NonSerialized] private readonly Dictionary<string, PoolGroup> _groups = new Dictionary<string, PoolGroup>();
         [NonSerialized] private readonly Dictionary<int, PoolEntry> _instanceTypeMap = new Dictionary<int, PoolEntry>();
         [NonSerialized] private readonly Dictionary<GameObject, PoolEntry> _customPool = new Dictionary<GameObject, PoolEntry>();
@@ -307,6 +310,7 @@ namespace Amanotes.Core
             
             _groups[group.id] = group;
             group.Register(this, spawnParent);
+            PurgeStaleInstanceMap();
         }
         
         public void SetSpawnParent(string groupId, Transform spawnParent)
@@ -352,10 +356,23 @@ namespace Amanotes.Core
             }
         }
         
+        private void PurgeStaleInstanceMap()
+        {
+#if UNITY_EDITOR
+            if (_instanceTypeMap.Count == 0) return;
+            var stale = new List<int>();
+            foreach (var kvp in _instanceTypeMap)
+            {
+                if (EditorUtility.InstanceIDToObject(kvp.Key) == null) stale.Add(kvp.Key);
+            }
+            foreach (var id in stale) _instanceTypeMap.Remove(id);
+#endif
+        }
+        
         public IEnumerator Initialize()
         {
-            if (_isReady) yield break;
-            _isReady = false;
+            if (_isReady || _isInitializing) yield break;
+            _isInitializing = true;
             
             #if UNITY_EDITOR
             EditorApplication.playModeStateChanged -= HandlePlayModeChanged;
@@ -377,6 +394,7 @@ namespace Amanotes.Core
                 }
             }
             
+            _isInitializing = false;
             _isReady = true;
         }
 
@@ -401,23 +419,27 @@ namespace Amanotes.Core
                     entry.DestroyPool();
                 }
                 
-                // Destroy fallback entry if available
                 if (group.fallbackEntry != null)
                 {
                     group.fallbackEntry.DestroyPool();
                 }
             }
-            
             _groups.Clear();
             
+            foreach (var entry in _customPool.Values)
+            {
+                entry.DestroyPool();
+            }
+            _customPool.Clear();
+            
 #if UNITY_EDITOR
             foreach (var kvp in _instanceTypeMap)
             {
                 var obj = EditorUtility.InstanceIDToObject(kvp.Key);
                 if (obj != null) UnityObject.DestroyImmediate(obj);
             }
-            _instanceTypeMap.Clear();
 #endif
+            _instanceTypeMap.Clear();
         }
     }
 } 

package/Tests/Runtime/PrefabPool.Test.asmdef

@@ -0,0 +1,11 @@
+{
+    "name": "PrefabPool.Tests",
+    "rootNamespace": "Amanotes.Core",
+    "references": [
+        "PrefabPool",
+        "Unity.PerformanceTesting"
+    ],
+    "optionalUnityReferences": [
+        "TestAssemblies"
+    ]
+}

package/Tests/Runtime/PrefabPool.Test.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f4f4c6bd22a404f98bd5cc47335df5d8
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/PrefabPoolGroupTests.cs

@@ -0,0 +1,224 @@
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Core
+{
+    public class PrefabPoolGroupTests
+    {
+        private PrefabPool _pool;
+        private PoolGroup _groupA;
+        private PoolGroup _groupB;
+        private GameObject _prefabA;
+        private GameObject _prefabB;
+        private Transform _spawnParentA;
+        private Transform _spawnParentB;
+        
+        [SetUp]
+        public void SetUp()
+        {
+            var poolObject = new GameObject("TestPool");
+            _pool = poolObject.AddComponent<PrefabPool>();
+            
+            var spawnParentObjectA = new GameObject("SpawnParentA");
+            _spawnParentA = spawnParentObjectA.transform;
+            
+            var spawnParentObjectB = new GameObject("SpawnParentB");
+            _spawnParentB = spawnParentObjectB.transform;
+            
+            _prefabA = new GameObject("PrefabA");
+            _prefabA.AddComponent<MockPoolPrefab>();
+            
+            _prefabB = new GameObject("PrefabB");
+            _prefabB.AddComponent<MockPoolPrefab>();
+            
+            _groupA = new PoolGroup
+            {
+                id = "GroupA",
+                entries = new List<PoolEntry>
+                {
+                    new PoolEntry
+                    {
+                        id = "PrefabA",
+                        prefab = _prefabA,
+                        prewarmCount = 5
+                    }
+                }
+            };
+            
+            _groupB = new PoolGroup
+            {
+                id = "GroupB",
+                entries = new List<PoolEntry>
+                {
+                    new PoolEntry
+                    {
+                        id = "PrefabB",
+                        prefab = _prefabB,
+                        prewarmCount = 5
+                    }
+                }
+            };
+            
+            _pool.RegisterGroup(_groupA, _spawnParentA);
+            _pool.RegisterGroup(_groupB, _spawnParentB);
+        }
+        
+        [TearDown]
+        public void TearDown()
+        {
+            if (_pool != null)
+            {
+                _pool.DestroyPool();
+                UnityObject.DestroyImmediate(_pool.gameObject);
+            }
+            
+            if (_spawnParentA != null)
+            {
+                UnityObject.DestroyImmediate(_spawnParentA.gameObject);
+            }
+            
+            if (_spawnParentB != null)
+            {
+                UnityObject.DestroyImmediate(_spawnParentB.gameObject);
+            }
+            
+            if (_prefabA != null)
+            {
+                UnityObject.DestroyImmediate(_prefabA);
+            }
+            
+            if (_prefabB != null)
+            {
+                UnityObject.DestroyImmediate(_prefabB);
+            }
+            
+            var allObjects = UnityObject.FindObjectsOfType<GameObject>();
+            foreach (var obj in allObjects)
+            {
+                if (obj.hideFlags == HideFlags.DontSave)
+                {
+                    UnityObject.DestroyImmediate(obj);
+                }
+            }
+        }
+        
+        [UnityTest]
+        public IEnumerator PoolGroupIsolation_MultipleGroups_ObjectsNeverCrossBetweenGroups()
+        {
+            yield return _pool.Initialize();
+            
+            for (int i = 0; i < 100; i++)
+            {
+                var objFromA = _groupA.Get("PrefabA");
+                Assert.IsNotNull(objFromA, $"Iteration {i}: GroupA should return valid GameObject");
+                
+                var objFromB = _groupB.Get("PrefabB");
+                Assert.IsNotNull(objFromB, $"Iteration {i}: GroupB should return valid GameObject");
+                
+                var instanceIdA = objFromA.GetInstanceID();
+                var instanceIdB = objFromB.GetInstanceID();
+                
+                Assert.AreNotEqual(instanceIdA, instanceIdB, 
+                    $"Iteration {i}: Objects from different groups should have different instance IDs");
+                
+                Assert.IsTrue(objFromA.name.Contains("PrefabA"), 
+                    $"Iteration {i}: Object from GroupA should be PrefabA instance");
+                Assert.IsTrue(objFromB.name.Contains("PrefabB"), 
+                    $"Iteration {i}: Object from GroupB should be PrefabB instance");
+                
+                _groupA.Return(objFromA);
+                _groupB.Return(objFromB);
+                
+                var reusedFromA = _groupA.Get("PrefabA");
+                var reusedFromB = _groupB.Get("PrefabB");
+                
+                Assert.AreEqual(instanceIdA, reusedFromA.GetInstanceID(), 
+                    $"Iteration {i}: GroupA should reuse its own objects");
+                Assert.AreEqual(instanceIdB, reusedFromB.GetInstanceID(), 
+                    $"Iteration {i}: GroupB should reuse its own objects");
+                
+                Assert.IsTrue(reusedFromA.name.Contains("PrefabA"), 
+                    $"Iteration {i}: GroupA should never return PrefabB instances");
+                Assert.IsTrue(reusedFromB.name.Contains("PrefabB"), 
+                    $"Iteration {i}: GroupB should never return PrefabA instances");
+                
+                _groupA.Return(reusedFromA);
+                _groupB.Return(reusedFromB);
+            }
+        }
+        
+        [UnityTest]
+        public IEnumerator ReturnGroupRouting_ReturnToGroup_SubsequentGetRetrievesSameInstanceFromSameGroup()
+        {
+            yield return _pool.Initialize();
+            
+            for (int i = 0; i < 100; i++)
+            {
+                var objA1 = _groupA.Get("PrefabA");
+                var objA2 = _groupA.Get("PrefabA");
+                var objB1 = _groupB.Get("PrefabB");
+                var objB2 = _groupB.Get("PrefabB");
+                
+                Assert.IsNotNull(objA1, $"Iteration {i}: GroupA Get 1 should return valid GameObject");
+                Assert.IsNotNull(objA2, $"Iteration {i}: GroupA Get 2 should return valid GameObject");
+                Assert.IsNotNull(objB1, $"Iteration {i}: GroupB Get 1 should return valid GameObject");
+                Assert.IsNotNull(objB2, $"Iteration {i}: GroupB Get 2 should return valid GameObject");
+                
+                var instanceIdA1 = objA1.GetInstanceID();
+                var instanceIdA2 = objA2.GetInstanceID();
+                var instanceIdB1 = objB1.GetInstanceID();
+                var instanceIdB2 = objB2.GetInstanceID();
+                
+                _groupA.Return(objA1);
+                _groupA.Return(objA2);
+                _groupB.Return(objB1);
+                _groupB.Return(objB2);
+                
+                var reusedA1 = _groupA.Get("PrefabA");
+                var reusedA2 = _groupA.Get("PrefabA");
+                var reusedB1 = _groupB.Get("PrefabB");
+                var reusedB2 = _groupB.Get("PrefabB");
+                
+                var reusedInstanceIdsA = new HashSet<int> 
+                { 
+                    reusedA1.GetInstanceID(), 
+                    reusedA2.GetInstanceID() 
+                };
+                var reusedInstanceIdsB = new HashSet<int> 
+                { 
+                    reusedB1.GetInstanceID(), 
+                    reusedB2.GetInstanceID() 
+                };
+                
+                Assert.IsTrue(reusedInstanceIdsA.Contains(instanceIdA1), 
+                    $"Iteration {i}: Object returned to GroupA should be retrieved from GroupA");
+                Assert.IsTrue(reusedInstanceIdsA.Contains(instanceIdA2), 
+                    $"Iteration {i}: Object returned to GroupA should be retrieved from GroupA");
+                
+                Assert.IsTrue(reusedInstanceIdsB.Contains(instanceIdB1), 
+                    $"Iteration {i}: Object returned to GroupB should be retrieved from GroupB");
+                Assert.IsTrue(reusedInstanceIdsB.Contains(instanceIdB2), 
+                    $"Iteration {i}: Object returned to GroupB should be retrieved from GroupB");
+                
+                Assert.IsFalse(reusedInstanceIdsA.Contains(instanceIdB1), 
+                    $"Iteration {i}: GroupA should not return objects from GroupB");
+                Assert.IsFalse(reusedInstanceIdsA.Contains(instanceIdB2), 
+                    $"Iteration {i}: GroupA should not return objects from GroupB");
+                
+                Assert.IsFalse(reusedInstanceIdsB.Contains(instanceIdA1), 
+                    $"Iteration {i}: GroupB should not return objects from GroupA");
+                Assert.IsFalse(reusedInstanceIdsB.Contains(instanceIdA2), 
+                    $"Iteration {i}: GroupB should not return objects from GroupA");
+                
+                _groupA.Return(reusedA1);
+                _groupA.Return(reusedA2);
+                _groupB.Return(reusedB1);
+                _groupB.Return(reusedB2);
+            }
+        }
+    }
+}

package/Tests/Runtime/PrefabPoolGroupTests.cs.meta

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

package/Tests/Runtime/PrefabPoolLifecycleTests.cs

@@ -0,0 +1,257 @@
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Core
+{
+    public class PrefabPoolLifecycleTests
+    {
+        private PrefabPool _pool;
+        private GameObject _testPrefab;
+        private PoolGroup _testGroup;
+        private Transform _spawnParent;
+        
+        [SetUp]
+        public void SetUp()
+        {
+            var poolObject = new GameObject("TestPool");
+            _pool = poolObject.AddComponent<PrefabPool>();
+            
+            var spawnParentObject = new GameObject("SpawnParent");
+            _spawnParent = spawnParentObject.transform;
+            
+            _testPrefab = new GameObject("TestPrefab");
+            _testPrefab.AddComponent<MockPoolPrefab>();
+            
+            _testGroup = new PoolGroup
+            {
+                id = "TestGroup",
+                entries = new System.Collections.Generic.List<PoolEntry>
+                {
+                    new PoolEntry
+                    {
+                        id = "TestPrefab",
+                        prefab = _testPrefab,
+                        prewarmCount = 5
+                    }
+                }
+            };
+            
+            _pool.RegisterGroup(_testGroup, _spawnParent);
+        }
+        
+        [TearDown]
+        public void TearDown()
+        {
+            if (_pool != null)
+            {
+                _pool.DestroyPool();
+                UnityObject.DestroyImmediate(_pool.gameObject);
+            }
+            
+            if (_spawnParent != null)
+            {
+                UnityObject.DestroyImmediate(_spawnParent.gameObject);
+            }
+            
+            if (_testPrefab != null)
+            {
+                UnityObject.DestroyImmediate(_testPrefab);
+            }
+            
+            var allObjects = UnityObject.FindObjectsOfType<GameObject>();
+            foreach (var obj in allObjects)
+            {
+                if (obj.hideFlags == HideFlags.DontSave)
+                {
+                    UnityObject.DestroyImmediate(obj);
+                }
+            }
+        }
+        
+        [UnityTest]
+        public IEnumerator PoolObjectRoundTrip_GetReturnGet_ReuseSameInstance()
+        {
+            yield return _pool.Initialize();
+            
+            for (int i = 0; i < 100; i++)
+            {
+                var firstGet = _testGroup.Get("TestPrefab");
+                Assert.IsNotNull(firstGet, $"Iteration {i}: First Get should return valid GameObject");
+                
+                var firstInstanceId = firstGet.GetInstanceID();
+                
+                _testGroup.Return(firstGet);
+                
+                var secondGet = _testGroup.Get("TestPrefab");
+                Assert.IsNotNull(secondGet, $"Iteration {i}: Second Get should return valid GameObject");
+                
+                var secondInstanceId = secondGet.GetInstanceID();
+                
+                Assert.AreEqual(firstInstanceId, secondInstanceId, 
+                    $"Iteration {i}: Get-Return-Get should reuse same instance (validates pooling eliminates instantiation)");
+                
+                _testGroup.Return(secondGet);
+            }
+        }
+        
+        [UnityTest]
+        public IEnumerator LifecycleCallbackInvocation_GetReturnCycle_InvokesOnGetAndOnReturnExactlyOnce()
+        {
+            yield return _pool.Initialize();
+            
+            for (int i = 0; i < 100; i++)
+            {
+                var obj = _testGroup.Get("TestPrefab");
+                Assert.IsNotNull(obj, $"Iteration {i}: Get should return valid GameObject");
+                
+                var mock = obj.GetComponent<MockPoolPrefab>();
+                Assert.IsNotNull(mock, $"Iteration {i}: GameObject should have MockPoolPrefab component");
+                
+                mock.ResetCounts();
+                
+                var objAgain = _testGroup.Get("TestPrefab");
+                var mockAgain = objAgain.GetComponent<MockPoolPrefab>();
+                mockAgain.ResetCounts();
+                
+                _testGroup.Return(obj);
+                
+                Assert.AreEqual(1, mock.returnCallCount, 
+                    $"Iteration {i}: OnReturn should be called exactly once during Return");
+                Assert.AreEqual(0, mock.getCallCount, 
+                    $"Iteration {i}: OnGet should not be called during Return");
+                
+                var reusedObj = _testGroup.Get("TestPrefab");
+                var reusedMock = reusedObj.GetComponent<MockPoolPrefab>();
+                
+                Assert.AreEqual(1, reusedMock.getCallCount, 
+                    $"Iteration {i}: OnGet should be called exactly once during Get");
+                
+                _testGroup.Return(objAgain);
+                _testGroup.Return(reusedObj);
+            }
+        }
+        
+        [UnityTest]
+        public IEnumerator PreallocationCorrectness_PrewarmCount_CreatesExactNumberOfPreallocatedObjects()
+        {
+            for (int iteration = 0; iteration < 100; iteration++)
+            {
+                var prewarmCount = UnityEngine.Random.Range(1, 20);
+                
+                var poolObject = new GameObject($"TestPool_{iteration}");
+                var pool = poolObject.AddComponent<PrefabPool>();
+                
+                var spawnParentObject = new GameObject($"SpawnParent_{iteration}");
+                var spawnParent = spawnParentObject.transform;
+                
+                var prefab = new GameObject($"Prefab_{iteration}");
+                prefab.AddComponent<MockPoolPrefab>();
+                
+                var group = new PoolGroup
+                {
+                    id = $"Group_{iteration}",
+                    entries = new System.Collections.Generic.List<PoolEntry>
+                    {
+                        new PoolEntry
+                        {
+                            id = "TestPrefab",
+                            prefab = prefab,
+                            prewarmCount = prewarmCount
+                        }
+                    }
+                };
+                
+                pool.RegisterGroup(group, spawnParent);
+                
+                yield return pool.Initialize();
+                
+                var retrievedObjects = new System.Collections.Generic.List<GameObject>();
+                
+                for (int i = 0; i < prewarmCount; i++)
+                {
+                    var obj = group.Get("TestPrefab");
+                    Assert.IsNotNull(obj, $"Iteration {iteration}: Should retrieve pre-allocated object {i}");
+                    retrievedObjects.Add(obj);
+                }
+                
+                Assert.AreEqual(prewarmCount, retrievedObjects.Count, 
+                    $"Iteration {iteration}: Should retrieve exactly {prewarmCount} pre-allocated objects");
+                
+                foreach (var obj in retrievedObjects)
+                {
+                    group.Return(obj);
+                }
+                
+                pool.DestroyPool();
+                UnityObject.DestroyImmediate(poolObject);
+                UnityObject.DestroyImmediate(spawnParentObject);
+                UnityObject.DestroyImmediate(prefab);
+            }
+        }
+        
+        [UnityTest]
+        public IEnumerator DynamicPoolExpansion_GetBeyondCapacity_SuccessfullyReturnsValidGameObjects()
+        {
+            for (int iteration = 0; iteration < 100; iteration++)
+            {
+                var initialCapacity = UnityEngine.Random.Range(2, 10);
+                var extraRequests = UnityEngine.Random.Range(5, 15);
+                
+                var poolObject = new GameObject($"TestPool_{iteration}");
+                var pool = poolObject.AddComponent<PrefabPool>();
+                
+                var spawnParentObject = new GameObject($"SpawnParent_{iteration}");
+                var spawnParent = spawnParentObject.transform;
+                
+                var prefab = new GameObject($"Prefab_{iteration}");
+                prefab.AddComponent<MockPoolPrefab>();
+                
+                var group = new PoolGroup
+                {
+                    id = $"Group_{iteration}",
+                    entries = new System.Collections.Generic.List<PoolEntry>
+                    {
+                        new PoolEntry
+                        {
+                            id = "TestPrefab",
+                            prefab = prefab,
+                            prewarmCount = initialCapacity
+                        }
+                    }
+                };
+                
+                pool.RegisterGroup(group, spawnParent);
+                
+                yield return pool.Initialize();
+                
+                var retrievedObjects = new System.Collections.Generic.List<GameObject>();
+                
+                var totalRequests = initialCapacity + extraRequests;
+                
+                for (int i = 0; i < totalRequests; i++)
+                {
+                    var obj = group.Get("TestPrefab");
+                    Assert.IsNotNull(obj, 
+                        $"Iteration {iteration}: Get beyond capacity should succeed (request {i + 1}/{totalRequests})");
+                    retrievedObjects.Add(obj);
+                }
+                
+                Assert.AreEqual(totalRequests, retrievedObjects.Count, 
+                    $"Iteration {iteration}: Should retrieve {totalRequests} objects (capacity {initialCapacity} + expansion {extraRequests})");
+                
+                foreach (var obj in retrievedObjects)
+                {
+                    group.Return(obj);
+                }
+                
+                pool.DestroyPool();
+                UnityObject.DestroyImmediate(poolObject);
+                UnityObject.DestroyImmediate(spawnParentObject);
+                UnityObject.DestroyImmediate(prefab);
+            }
+        }
+    }
+}

package/Tests/Runtime/PrefabPoolLifecycleTests.cs.meta

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