Merge pull request #3 from CoderGamester/develop

0.3.0

Author: CoderGamester

CHANGELOG.md

@@ -4,14 +4,25 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+
+## [0.3.0] - 2020-02-09
+
+- Now the *MainInstaller* checks the object binding relationship in compile time
+- The *CoroutineService* no longer fails on null coroutines
+- Improved the *ObjectPools* helper classes with a now static global instatiator for game objects.
+
+**Changed**:
+- Now the *PoolService* is only a service container for objects pools and no longer creates/initializes new pools.
+- Removed *Pool.Clear* functionality. Use *DespawnAll* or delete the pool instead 
+
 ## [0.2.0] - 2020-01-19
 
 - Added new *ObjectPool* & *GameObjectPool* pools to allow to allow to use object pools independent from the *PoolService*. This allows to have different pools of the same type in the project in different object controllers
 - Added new interface *IPoolEntityClear* that allows a callback method for entities when they are cleared from the pool
 - Added new unit tests for the *ObjectPool*
 
 **Changed**:
-- Now the PoolService.Clear() does not take any action parameters. To have a callback when the entity is cleared, please have the entity implement the *IPoolEntityClear* interface
+- Now the *PoolService.Clear()* does not take any action parameters. To have a callback when the entity is cleared, please have the entity implement the *IPoolEntityClear* interface
 
 ## [0.1.1] - 2020-01-06
 

Runtime/CoroutineService.cs

@@ -140,13 +140,18 @@ public IAsyncCoroutine<T> StartAsyncCoroutine<T>(IEnumerator routine)
 		/// <inheritdoc />
 		public void StopCoroutine(Coroutine coroutine)
 		{
-			_serviceObject.ExternalStopCoroutine(coroutine);
+			if (coroutine == null)
+			{
+				return;
+			}
+			
+			_serviceObject?.ExternalStopCoroutine(coroutine);
 		}
 
 		/// <inheritdoc />
 		public void StopAllCoroutines()
 		{
-			_serviceObject.StopAllCoroutines();
+			_serviceObject?.StopAllCoroutines();
 		}
 
 		private static IEnumerator InternalCoroutine(IEnumerator routine, ICompleteCoroutine completed)

Runtime/MainInstaller.cs

@@ -22,7 +22,7 @@ public static class MainInstaller
 		/// <exception cref="ArgumentException">
 		/// Thrown if the given <paramref name="instance"/> doesn't implement <typeparamref name="T"/> interface
 		/// </exception>
-		public static void Bind<T>(object instance) where T : class
+		public static void Bind<T>(T instance) where T : class
 		{
 			var type = typeof(T);
 
@@ -31,11 +31,6 @@ public static void Bind<T>(object instance) where T : class
 				throw new ArgumentException($"Cannot bind {instance} because {type} is not an interface");
 			}
 
-			if (!(instance is T))
-			{
-				throw new ArgumentException($"Cannot bind the given instance because it doesn't implement the {type} interface");
-			}
-
 			_bindings.Add(type, instance);
 		}
 

Runtime/PoolService.cs

@@ -14,54 +14,60 @@ namespace GameLovers.Services
 	public interface IPoolService
 	{
 		/// <summary>
-		/// Initializes a new pool with the given <paramref name="initialSize"/>
-		/// It invokes the <paramref name="instantiator"/> function every time a new entity is created in the pool
+		/// Adds the given <paramref name="pool"/> of <typeparamref name="T"/> to the service
 		/// </summary>
-		void InitPool<T>(int initialSize, Func<T> instantiator) where T : new();
-		
+		/// <exception cref="ArgumentException">
+		/// Thrown if the service already has a pool of the given <typeparamref name="T"/> type
+		/// </exception>
+		void AddPool<T>(IObjectPool<T> pool);
+
 		/// <summary>
-		/// Initializes a new pool with the given <paramref name="initialSize"/> and a sample entity given back in the <paramref name="instantiator"/>
-		/// It invokes the <paramref name="instantiator"/> function every time a new entity is created in the pool
+		/// Removes the pool of the given <typeparamref name="T"/>
 		/// </summary>
-		void InitPool<T>(int initialSize, T sampleEntity, Func<T, T> instantiator) where T : Object;
+		void RemovePool<T>();
 
 		/// <summary>
-		/// Checks if exists a pool of the given type already exists or needs to be initialized with
-		/// <seealso cref="InitPool{T}(int,System.Func{T})"/>  before calling <seealso cref="Spawn{T}"/>
+		/// Checks if exists a pool of the given type already exists or needs to be added before calling <seealso cref="Spawn{T}"/>
 		/// </summary>
 		bool HasPool<T>();
 
 		/// <inheritdoc cref="HasPool{T}"/>
 		bool HasPool(Type type);
 
 		/// <inheritdoc cref="IObjectPool{T}.Spawn"/>
+		/// <exception cref="ArgumentException">
+		/// Thrown if the service does not contains a pool of the given <typeparamref name="T"/> type
+		/// </exception>
 		T Spawn<T>();
 
 		/// <inheritdoc cref="IObjectPool{T}.Despawn"/>
+		/// <exception cref="ArgumentException">
+		/// Thrown if the service does not contains a pool of the given <typeparamref name="T"/> type
+		/// </exception>
 		void Despawn<T>(T entity);
 
 		/// <inheritdoc cref="IObjectPool{T}.DespawnAll"/>
+		/// <exception cref="ArgumentException">
+		/// Thrown if the service does not contains a pool of the given <typeparamref name="T"/> type
+		/// </exception>
 		void DespawnAll<T>();
-
-		/// <inheritdoc cref="IObjectPool{T}.Clear"/>
-		void Clear<T>();
 	}
 
 	/// <inheritdoc />
 	public class PoolService : IPoolService
 	{
 		private readonly Dictionary<Type, IObjectPool> _pools = new Dictionary<Type, IObjectPool>();
-		
+
 		/// <inheritdoc />
-		public void InitPool<T>(int initialSize, Func<T> instantiator) where T : new()
+		public void AddPool<T>(IObjectPool<T> pool)
 		{
-			_pools.Add(typeof(T), new ObjectPool<T>(initialSize, instantiator));
+			_pools.Add(typeof(T), pool);
 		}
 
 		/// <inheritdoc />
-		public void InitPool<T>(int initialSize, T sampleEntity, Func<T, T> instantiator) where T : Object
+		public void RemovePool<T>()
 		{
-			_pools.Add(typeof(T), new GameObjectPool<T>(initialSize, sampleEntity, instantiator));
+			_pools.Remove(typeof(T));
 		}
 
 		/// <inheritdoc />
@@ -94,13 +100,6 @@ public void DespawnAll<T>()
 			GetPool<T>().DespawnAll();
 		}
 
-		/// <inheritdoc />
-		public void Clear<T>()
-		{
-			GetPool<T>().Clear();
-			_pools.Remove(typeof(T));
-		}
-
 		private IObjectPool<T> GetPool<T>()
 		{
 			if (!_pools.TryGetValue(typeof(T), out IObjectPool pool))
@@ -133,29 +132,12 @@ public interface IPoolEntityDespawn
 		/// </summary>
 		void OnDespawn();
 	}
-	
-	/// <summary>
-	/// This interface allows pooled objects to be notified when they are cleared from the pool
-	/// </summary>
-	public interface IPoolEntityCleared
-	{
-		/// <summary>
-		/// Invoked when the entity is cleared
-		/// </summary>
-		void OnCleared();
-	}
 
 	/// <summary>
 	/// Simple object pool implementation that can handle any type of entity objects
 	/// </summary>
 	public interface IObjectPool
 	{
-		/// <summary>
-		/// Clears the pool
-		/// This function does not clear the entity. For that, have the entity implement <see cref="IPoolEntityCleared"/> or do it externally
-		/// </summary>
-		void Clear();
-		
 		/// <summary>
 		/// Despawns all active spawned entities and returns them back to the pool to be used again later
 		/// This function does not reset the entity. For that, have the entity implement <see cref="IPoolEntityDespawn"/> or do it externally
@@ -198,19 +180,6 @@ protected ObjectPoolBase(int initSize, T sampleEntity, Func<T, T> instantiator)
 				_stack.Push(instantiator.Invoke(sampleEntity));
 			}
 		}
-		
-		/// <inheritdoc />
-		public void Clear()
-		{
-			for (var i = 0; i < _stack.Count; i++)
-			{
-				var entity =_stack.Pop() as IPoolEntityCleared;
-				
-				entity?.OnCleared();
-			}
-			
-			_spawnedEntities.Clear();
-		}
 
 		/// <inheritdoc />
 		public T Spawn()
@@ -247,21 +216,44 @@ public void DespawnAll()
 	}
 
 	/// <inheritdoc />
-	public class ObjectPool<T> : ObjectPoolBase<T> where T : new()
+	public class ObjectPool<T> : ObjectPoolBase<T>
+	{
+		public ObjectPool(int initSize, Func<T> instantiator) : base(initSize, instantiator(), entityRef => instantiator.Invoke())
+		{
+		}
+	}/// <inheritdoc />
+	/// <remarks>
+	/// Useful to for pools that use object references to create new instances (ex: GameObjects)
+	/// </remarks>
+	public class ObjectRefPool<T> : ObjectPoolBase<T>
 	{
-		public ObjectPool(int initSize, Func<T> instantiator) : base(initSize, instantiator(), newEntity => instantiator.Invoke())
+		public ObjectRefPool(int initSize, T sampleEntity, Func<T, T> instantiator) : base(initSize, sampleEntity, instantiator)
 		{
 		}
 	}
 
 	/// <inheritdoc />
 	/// <remarks>
-	/// <see cref="IObjectPool"/> implementation for objects of type <see cref="Object"/>
+	/// Useful to for pools that use object references to create new <see cref="GameObject"/>
 	/// </remarks>
-	public class GameObjectPool<T> : ObjectPoolBase<T> where T : Object
+	public class GameObjectPool<T> : ObjectRefPool<T> where T : MonoBehaviour
 	{
-		public GameObjectPool(int initSize, T sampleEntity, Func<T, T> instantiator) : base(initSize, sampleEntity, instantiator)
+		public GameObjectPool(int initSize, T sampleEntity) : base(initSize, sampleEntity, Instantiator)
+		{
+		}
+
+		/// <summary>
+		/// Generic instantiator for <see cref="GameObject"/> pools
+		/// </summary>
+		/// <param name="entityRef"></param>
+		/// <returns></returns>
+		public static T Instantiator(T entityRef)
 		{
+			var instance = Object.Instantiate(entityRef, entityRef.transform.parent, true);
+
+			instance.gameObject.SetActive(false);
+
+			return instance;
 		}
 	}
 }

Runtime/TimeService.cs

@@ -51,11 +51,12 @@ public interface ITimeService
 		float UnityTimeFromUnixTime(long time);
 	}
 
-	/// <summary>
+	/// <inheritdoc cref="ITimeService"/>
+	/// <remarks>
 	/// Manipulates the service's time.
 	/// This can be useful in cases where we want to speed up the game or to synchronize time with an outside source
-	/// </summary>
-	public interface ITimeManipulator
+	/// </remarks>
+	public interface ITimeManipulator : ITimeService
 	{
 		/// <summary>
 		/// Adds <paramref name="timeInSeconds"/> to the current game's clock.
@@ -70,7 +71,7 @@ public interface ITimeManipulator
 	}
 
 	/// <inheritdoc cref="ITimeService"/>
-	public class TimeService : ITimeService, ITimeManipulator
+	public class TimeService : ITimeManipulator
 	{
 		private static readonly DateTime UnixInitialTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 

Tests/Editor/MainInstallerTest.cs

@@ -32,13 +32,7 @@ public void Bind_Resolve_Successfully()
 		[Test]
 		public void Bind_NotInterface_ThrowsException()
 		{
-			Assert.Throws<ArgumentException>(() => MainInstaller.Bind<Implementation>(new Implementation()));
-		}
-
-		[Test]
-		public void Bind_NotImplementing_ThrowsException()
-		{
-			Assert.Throws<ArgumentException>(() => MainInstaller.Bind<IInterface>(new int[0]));
+			Assert.Throws<ArgumentException>(() => MainInstaller.Bind(new Implementation()));
 		}
 
 		[Test]

Tests/Editor/ObjectPoolTest.cs

@@ -14,11 +14,10 @@ public class ObjectPoolTest
 		private PoolableEntity _poolableEntity;
 		private int initialSize = 5;
 
-		public class PoolableEntity : IPoolEntitySpawn, IPoolEntityDespawn, IPoolEntityCleared
+		public class PoolableEntity : IPoolEntitySpawn, IPoolEntityDespawn
 		{
 			public void OnSpawn() {}
 			public void OnDespawn() {}
-			public void OnCleared() {}
 		}
 
 		[SetUp]
@@ -75,25 +74,5 @@ public void DespawnAll_Successfully()
 				entity.Received().OnDespawn();
 			}
 		}
-
-		[Test]
-		public void Clear_Successfully()
-		{
-			_pool.Despawn(_poolableEntity);
-			_pool.Clear();
-			
-			_poolableEntity.Received().OnCleared();
-			
-			Assert.DoesNotThrow(() => _pool.Spawn());
-			Assert.DoesNotThrow(() => _pool.Despawn(_poolableEntity));
-		}
-
-		[Test]
-		public void Clear_Twice_NothingHappens()
-		{
-			_pool.Clear();
-			
-			Assert.DoesNotThrow(() => _pool.Clear());
-		}
 	}
 }