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);
}
}
}