using System; using System.Collections.Generic; namespace TEngine { /// /// 对象池管理器。 /// internal sealed partial class ObjectPoolModule : Module, IObjectPoolModule, IUpdateModule { private const int DEFAULT_CAPACITY = int.MaxValue; private const float DEFAULT_EXPIRE_TIME = float.MaxValue; private const int DEFAULT_PRIORITY = 0; private readonly Dictionary _objectPools; private readonly List _cachedAllObjectPools; private readonly Comparison _objectPoolComparer; /// /// 获取游戏框架模块优先级。 /// /// 优先级较高的模块会优先轮询,并且关闭操作会后进行。 public override int Priority => 6; /// /// 获取对象池数量。 /// public int Count => _objectPools.Count; /// /// 对象池管理器轮询。 /// /// 逻辑流逝时间,以秒为单位。 /// 真实流逝时间,以秒为单位。 public void Update(float elapseSeconds, float realElapseSeconds) { foreach (KeyValuePair objectPool in _objectPools) { objectPool.Value.Update(elapseSeconds, realElapseSeconds); } } /// /// 初始化对象池管理器的新实例。 /// public ObjectPoolModule() { _objectPools = new Dictionary(); _cachedAllObjectPools = new List(); _objectPoolComparer = ObjectPoolComparer; } public override void OnInit() { Log.Info("Object pool system onInit."); } /// /// 关闭并清理对象池管理器。 /// public override void Shutdown() { foreach (KeyValuePair objectPool in _objectPools) { objectPool.Value.Shutdown(); } _objectPools.Clear(); _cachedAllObjectPools.Clear(); } /// /// 检查是否存在对象池。 /// /// 对象类型。 /// 是否存在对象池。 public bool HasObjectPool() where T : ObjectBase { return InternalHasObjectPool(new TypeNamePair(typeof(T))); } /// /// 检查是否存在对象池。 /// /// 对象类型。 /// 是否存在对象池。 public bool HasObjectPool(Type objectType) { if (objectType == null) { throw new GameFrameworkException("Object type is invalid."); } if (!typeof(ObjectBase).IsAssignableFrom(objectType)) { throw new GameFrameworkException(Utility.Text.Format("Object type '{0}' is invalid.", objectType.FullName)); } return InternalHasObjectPool(new TypeNamePair(objectType)); } /// /// 检查是否存在对象池。 /// /// 对象类型。 /// 对象池名称。 /// 是否存在对象池。 public bool HasObjectPool(string name) where T : ObjectBase { return InternalHasObjectPool(new TypeNamePair(typeof(T), name)); } /// /// 检查是否存在对象池。 /// /// 对象类型。 /// 对象池名称。 /// 是否存在对象池。 public bool HasObjectPool(Type objectType, string name) { if (objectType == null) { throw new GameFrameworkException("Object type is invalid."); } if (!typeof(ObjectBase).IsAssignableFrom(objectType)) { throw new GameFrameworkException(Utility.Text.Format("Object type '{0}' is invalid.", objectType.FullName)); } return InternalHasObjectPool(new TypeNamePair(objectType, name)); } /// /// 检查是否存在对象池。 /// /// 要检查的条件。 /// 是否存在对象池。 public bool HasObjectPool(Predicate condition) { if (condition == null) { throw new GameFrameworkException("Condition is invalid."); } foreach (KeyValuePair objectPool in _objectPools) { if (condition(objectPool.Value)) { return true; } } return false; } /// /// 获取对象池。 /// /// 对象类型。 /// 要获取的对象池。 public IObjectPool GetObjectPool() where T : ObjectBase { return (IObjectPool)InternalGetObjectPool(new TypeNamePair(typeof(T))); } /// /// 获取对象池。 /// /// 对象类型。 /// 要获取的对象池。 public ObjectPoolBase GetObjectPool(Type objectType) { if (objectType == null) { throw new GameFrameworkException("Object type is invalid."); } if (!typeof(ObjectBase).IsAssignableFrom(objectType)) { throw new GameFrameworkException(Utility.Text.Format("Object type '{0}' is invalid.", objectType.FullName)); } return InternalGetObjectPool(new TypeNamePair(objectType)); } /// /// 获取对象池。 /// /// 对象类型。 /// 对象池名称。 /// 要获取的对象池。 public IObjectPool GetObjectPool(string name) where T : ObjectBase { return (IObjectPool)InternalGetObjectPool(new TypeNamePair(typeof(T), name)); } /// /// 获取对象池。 /// /// 对象类型。 /// 对象池名称。 /// 要获取的对象池。 public ObjectPoolBase GetObjectPool(Type objectType, string name) { if (objectType == null) { throw new GameFrameworkException("Object type is invalid."); } if (!typeof(ObjectBase).IsAssignableFrom(objectType)) { throw new GameFrameworkException(Utility.Text.Format("Object type '{0}' is invalid.", objectType.FullName)); } return InternalGetObjectPool(new TypeNamePair(objectType, name)); } /// /// 获取对象池。 /// /// 要检查的条件。 /// 要获取的对象池。 public ObjectPoolBase GetObjectPool(Predicate condition) { if (condition == null) { throw new GameFrameworkException("Condition is invalid."); } foreach (KeyValuePair objectPool in _objectPools) { if (condition(objectPool.Value)) { return objectPool.Value; } } return null; } /// /// 获取对象池。 /// /// 要检查的条件。 /// 要获取的对象池。 public ObjectPoolBase[] GetObjectPools(Predicate condition) { if (condition == null) { throw new GameFrameworkException("Condition is invalid."); } List results = new List(); foreach (KeyValuePair objectPool in _objectPools) { if (condition(objectPool.Value)) { results.Add(objectPool.Value); } } return results.ToArray(); } /// /// 获取对象池。 /// /// 要检查的条件。 /// 要获取的对象池。 public void GetObjectPools(Predicate condition, List results) { if (condition == null) { throw new GameFrameworkException("Condition is invalid."); } if (results == null) { throw new GameFrameworkException("Results is invalid."); } results.Clear(); foreach (KeyValuePair objectPool in _objectPools) { if (condition(objectPool.Value)) { results.Add(objectPool.Value); } } } /// /// 获取所有对象池。 /// /// 所有对象池。 public ObjectPoolBase[] GetAllObjectPools() { return GetAllObjectPools(false); } /// /// 获取所有对象池。 /// /// 所有对象池。 public void GetAllObjectPools(List results) { GetAllObjectPools(false, results); } /// /// 获取所有对象池。 /// /// 是否根据对象池的优先级排序。 /// 所有对象池。 public ObjectPoolBase[] GetAllObjectPools(bool sort) { if (sort) { List results = new List(); foreach (KeyValuePair objectPool in _objectPools) { results.Add(objectPool.Value); } results.Sort(_objectPoolComparer); return results.ToArray(); } else { int index = 0; ObjectPoolBase[] results = new ObjectPoolBase[_objectPools.Count]; foreach (KeyValuePair objectPool in _objectPools) { results[index++] = objectPool.Value; } return results; } } /// /// 获取所有对象池。 /// /// 是否根据对象池的优先级排序。 /// 所有对象池。 public void GetAllObjectPools(bool sort, List results) { if (results == null) { throw new GameFrameworkException("Results is invalid."); } results.Clear(); foreach (KeyValuePair objectPool in _objectPools) { results.Add(objectPool.Value); } if (sort) { results.Sort(_objectPoolComparer); } } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool() where T : ObjectBase { return InternalCreateObjectPool(string.Empty, false, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType) { return InternalCreateObjectPool(objectType, string.Empty, false, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name) where T : ObjectBase { return InternalCreateObjectPool(name, false, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name) { return InternalCreateObjectPool(objectType, name, false, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(int capacity) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity) { return InternalCreateObjectPool(objectType, string.Empty, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(float expireTime) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, false, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime) { return InternalCreateObjectPool(objectType, string.Empty, false, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name, int capacity) where T : ObjectBase { return InternalCreateObjectPool(name, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity) { return InternalCreateObjectPool(objectType, name, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name, float expireTime) where T : ObjectBase { return InternalCreateObjectPool(name, false, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime) { return InternalCreateObjectPool(objectType, name, false, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(int capacity, float expireTime) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, false, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime) { return InternalCreateObjectPool(objectType, string.Empty, false, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(int capacity, int priority) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, int priority) { return InternalCreateObjectPool(objectType, string.Empty, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, false, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime, int priority) { return InternalCreateObjectPool(objectType, string.Empty, false, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name, int capacity, float expireTime) where T : ObjectBase { return InternalCreateObjectPool(name, false, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime) { return InternalCreateObjectPool(objectType, name, false, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name, int capacity, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, int priority) { return InternalCreateObjectPool(objectType, name, false, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, false, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime, int priority) { return InternalCreateObjectPool(objectType, name, false, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(int capacity, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, false, expireTime, capacity, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority) { return InternalCreateObjectPool(objectType, string.Empty, false, expireTime, capacity, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name, int capacity, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, false, expireTime, capacity, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority) { return InternalCreateObjectPool(objectType, name, false, expireTime, capacity, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池自动释放可释放对象的间隔秒数。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public IObjectPool CreateSingleSpawnObjectPool(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, false, autoReleaseInterval, capacity, expireTime, priority); } /// /// 创建允许单次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池自动释放可释放对象的间隔秒数。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许单次获取的对象池。 public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority) { return InternalCreateObjectPool(objectType, name, false, autoReleaseInterval, capacity, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool() where T : ObjectBase { return InternalCreateObjectPool(string.Empty, true, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType) { return InternalCreateObjectPool(objectType, string.Empty, true, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name) where T : ObjectBase { return InternalCreateObjectPool(name, true, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name) { return InternalCreateObjectPool(objectType, name, true, DEFAULT_EXPIRE_TIME, DEFAULT_CAPACITY, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(int capacity) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity) { return InternalCreateObjectPool(objectType, string.Empty, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(float expireTime) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, true, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime) { return InternalCreateObjectPool(objectType, string.Empty, true, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name, int capacity) where T : ObjectBase { return InternalCreateObjectPool(name, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity) { return InternalCreateObjectPool(objectType, name, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name, float expireTime) where T : ObjectBase { return InternalCreateObjectPool(name, true, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime) { return InternalCreateObjectPool(objectType, name, true, expireTime, DEFAULT_CAPACITY, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(int capacity, float expireTime) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, true, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime) { return InternalCreateObjectPool(objectType, string.Empty, true, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(int capacity, int priority) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, int priority) { return InternalCreateObjectPool(objectType, string.Empty, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, true, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime, int priority) { return InternalCreateObjectPool(objectType, string.Empty, true, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name, int capacity, float expireTime) where T : ObjectBase { return InternalCreateObjectPool(name, true, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime) { return InternalCreateObjectPool(objectType, name, true, expireTime, capacity, expireTime, DEFAULT_PRIORITY); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name, int capacity, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, int priority) { return InternalCreateObjectPool(objectType, name, true, DEFAULT_EXPIRE_TIME, capacity, DEFAULT_EXPIRE_TIME, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, true, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime, int priority) { return InternalCreateObjectPool(objectType, name, true, expireTime, DEFAULT_CAPACITY, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(int capacity, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(string.Empty, true, expireTime, capacity, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority) { return InternalCreateObjectPool(objectType, string.Empty, true, expireTime, capacity, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name, int capacity, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, true, expireTime, capacity, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority) { return InternalCreateObjectPool(objectType, name, true, expireTime, capacity, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池自动释放可释放对象的间隔秒数。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public IObjectPool CreateMultiSpawnObjectPool(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase { return InternalCreateObjectPool(name, true, autoReleaseInterval, capacity, expireTime, priority); } /// /// 创建允许多次获取的对象池。 /// /// 对象类型。 /// 对象池名称。 /// 对象池自动释放可释放对象的间隔秒数。 /// 对象池的容量。 /// 对象池对象过期秒数。 /// 对象池的优先级。 /// 要创建的允许多次获取的对象池。 public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority) { return InternalCreateObjectPool(objectType, name, true, autoReleaseInterval, capacity, expireTime, priority); } /// /// 销毁对象池。 /// /// 对象类型。 /// 是否销毁对象池成功。 public bool DestroyObjectPool() where T : ObjectBase { return InternalDestroyObjectPool(new TypeNamePair(typeof(T))); } /// /// 销毁对象池。 /// /// 对象类型。 /// 是否销毁对象池成功。 public bool DestroyObjectPool(Type objectType) { if (objectType == null) { throw new GameFrameworkException("Object type is invalid."); } if (!typeof(ObjectBase).IsAssignableFrom(objectType)) { throw new GameFrameworkException(Utility.Text.Format("Object type '{0}' is invalid.", objectType.FullName)); } return InternalDestroyObjectPool(new TypeNamePair(objectType)); } /// /// 销毁对象池。 /// /// 对象类型。 /// 要销毁的对象池名称。 /// 是否销毁对象池成功。 public bool DestroyObjectPool(string name) where T : ObjectBase { return InternalDestroyObjectPool(new TypeNamePair(typeof(T), name)); } /// /// 销毁对象池。 /// /// 对象类型。 /// 要销毁的对象池名称。 /// 是否销毁对象池成功。 public bool DestroyObjectPool(Type objectType, string name) { if (objectType == null) { throw new GameFrameworkException("Object type is invalid."); } if (!typeof(ObjectBase).IsAssignableFrom(objectType)) { throw new GameFrameworkException(Utility.Text.Format("Object type '{0}' is invalid.", objectType.FullName)); } return InternalDestroyObjectPool(new TypeNamePair(objectType, name)); } /// /// 销毁对象池。 /// /// 对象类型。 /// 要销毁的对象池。 /// 是否销毁对象池成功。 public bool DestroyObjectPool(IObjectPool objectPool) where T : ObjectBase { if (objectPool == null) { throw new GameFrameworkException("Object pool is invalid."); } return InternalDestroyObjectPool(new TypeNamePair(typeof(T), objectPool.Name)); } /// /// 销毁对象池。 /// /// 要销毁的对象池。 /// 是否销毁对象池成功。 public bool DestroyObjectPool(ObjectPoolBase objectPool) { if (objectPool == null) { throw new GameFrameworkException("Object pool is invalid."); } return InternalDestroyObjectPool(new TypeNamePair(objectPool.ObjectType, objectPool.Name)); } /// /// 释放对象池中的可释放对象。 /// public void Release() { Log.Info("Object pool release..."); GetAllObjectPools(true, _cachedAllObjectPools); foreach (ObjectPoolBase objectPool in _cachedAllObjectPools) { objectPool.Release(); } } /// /// 释放对象池中的所有未使用对象。 /// public void ReleaseAllUnused() { Log.Info("Object pool release all unused..."); GetAllObjectPools(true, _cachedAllObjectPools); foreach (ObjectPoolBase objectPool in _cachedAllObjectPools) { objectPool.ReleaseAllUnused(); } } private bool InternalHasObjectPool(TypeNamePair typeNamePair) { return _objectPools.ContainsKey(typeNamePair); } private ObjectPoolBase InternalGetObjectPool(TypeNamePair typeNamePair) { ObjectPoolBase objectPool = null; if (_objectPools.TryGetValue(typeNamePair, out objectPool)) { return objectPool; } return null; } private IObjectPool InternalCreateObjectPool(string name, bool allowMultiSpawn, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase { TypeNamePair typeNamePair = new TypeNamePair(typeof(T), name); if (HasObjectPool(name)) { throw new GameFrameworkException(Utility.Text.Format("Already exist object pool '{0}'.", typeNamePair)); } ObjectPool objectPool = new ObjectPool(name, allowMultiSpawn, autoReleaseInterval, capacity, expireTime, priority); _objectPools.Add(typeNamePair, objectPool); return objectPool; } private ObjectPoolBase InternalCreateObjectPool(Type objectType, string name, bool allowMultiSpawn, float autoReleaseInterval, int capacity, float expireTime, int priority) { if (objectType == null) { throw new GameFrameworkException("Object type is invalid."); } if (!typeof(ObjectBase).IsAssignableFrom(objectType)) { throw new GameFrameworkException(Utility.Text.Format("Object type '{0}' is invalid.", objectType.FullName)); } TypeNamePair typeNamePair = new TypeNamePair(objectType, name); if (HasObjectPool(objectType, name)) { throw new GameFrameworkException(Utility.Text.Format("Already exist object pool '{0}'.", typeNamePair)); } Type objectPoolType = typeof(ObjectPool<>).MakeGenericType(objectType); ObjectPoolBase objectPool = (ObjectPoolBase)Activator.CreateInstance(objectPoolType, name, allowMultiSpawn, autoReleaseInterval, capacity, expireTime, priority); _objectPools.Add(typeNamePair, objectPool); return objectPool; } private bool InternalDestroyObjectPool(TypeNamePair typeNamePair) { ObjectPoolBase objectPool = null; if (_objectPools.TryGetValue(typeNamePair, out objectPool)) { objectPool.Shutdown(); return _objectPools.Remove(typeNamePair); } return false; } private static int ObjectPoolComparer(ObjectPoolBase a, ObjectPoolBase b) { return a.Priority.CompareTo(b.Priority); } } }