Test_Project_Cocos/JisolGame
1
0
Fork 0
mirror of https://gitee.com/jisol/jisol-game/ synced 2025-09-27 10:46:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

提交

Browse Source
This commit is contained in:
PC-20230316NUNE\Administrator
2024-09-29 20:18:48 +08:00
parent e822544d9c
commit c5700ce655
1797 changed files with 40580 additions and 23804 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/IObjectPool.cs Normal file
View File

@@ -0,0 +1,218 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
namespace SHFrame
{
/// <summary>
/// 对象池接口。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
public interface IObjectPool<T> where T : ObjectBase
{
/// <summary>
/// 获取对象池名称。
/// </summary>
string Name
{
get;
}
/// <summary>
/// 获取对象池完整名称。
/// </summary>
string FullName
{
get;
}
/// <summary>
/// 获取对象池对象类型。
/// </summary>
Type ObjectType
{
get;
}
/// <summary>
/// 获取对象池中对象的数量。
/// </summary>
int Count
{
get;
}
/// <summary>
/// 获取对象池中能被释放的对象的数量。
/// </summary>
int CanReleaseCount
{
get;
}
/// <summary>
/// 获取是否允许对象被多次获取。
/// </summary>
bool AllowMultiSpawn
{
get;
}
/// <summary>
/// 获取或设置对象池自动释放可释放对象的间隔秒数。
/// </summary>
float AutoReleaseInterval
{
get;
set;
}
/// <summary>
/// 获取或设置对象池的容量。
/// </summary>
int Capacity
{
get;
set;
}
/// <summary>
/// 获取或设置对象池对象过期秒数。
/// </summary>
float ExpireTime
{
get;
set;
}
/// <summary>
/// 获取或设置对象池的优先级。
/// </summary>
int Priority
{
get;
set;
}
/// <summary>
/// 创建对象。
/// </summary>
/// <param name="obj">对象。</param>
/// <param name="spawned">对象是否已被获取。</param>
void Register(T obj, bool spawned);
/// <summary>
/// 检查对象。
/// </summary>
/// <returns>要检查的对象是否存在。</returns>
bool CanSpawn();
/// <summary>
/// 检查对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要检查的对象是否存在。</returns>
bool CanSpawn(string name);
/// <summary>
/// 获取对象。
/// </summary>
/// <returns>要获取的对象。</returns>
T Spawn();
/// <summary>
/// 获取对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要获取的对象。</returns>
T Spawn(string name);
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="obj">要回收的对象。</param>
void Unspawn(T obj);
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="target">要回收的对象。</param>
void Unspawn(object target);
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="obj">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
void SetLocked(T obj, bool locked);
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="target">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
void SetLocked(object target, bool locked);
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="obj">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
void SetPriority(T obj, int priority);
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="target">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
void SetPriority(object target, int priority);
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="obj">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
bool ReleaseObject(T obj);
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="target">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
bool ReleaseObject(object target);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
void Release();
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
void Release(int toReleaseCount);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
void Release(ReleaseObjectFilterCallback<T> releaseObjectFilterCallback);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
void Release(int toReleaseCount, ReleaseObjectFilterCallback<T> releaseObjectFilterCallback);
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
void ReleaseAllUnused();
}
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/IObjectPool.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 4d548f22ce18454a806f5f61ee71c75d
timeCreated: 1708673686

751
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/IObjectPoolManager.cs Normal file
View File

@@ -0,0 +1,751 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
using System.Collections.Generic;
namespace SHFrame
{
/// <summary>
/// 对象池管理器。
/// </summary>
public interface IObjectPoolManager
{
/// <summary>
/// 获取对象池数量。
/// </summary>
int Count
{
get;
}
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool(Type objectType);
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool(Type objectType, string name);
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool(Predicate<ObjectPoolBase> condition);
/// <summary>
/// 获取对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>要获取的对象池。</returns>
IObjectPool<T> GetObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase GetObjectPool(Type objectType);
/// <summary>
/// 获取对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>要获取的对象池。</returns>
IObjectPool<T> GetObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase GetObjectPool(Type objectType, string name);
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase GetObjectPool(Predicate<ObjectPoolBase> condition);
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase[] GetObjectPools(Predicate<ObjectPoolBase> condition);
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <param name="results">要获取的对象池。</param>
void GetObjectPools(Predicate<ObjectPoolBase> condition, List<ObjectPoolBase> results);
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <returns>所有对象池。</returns>
ObjectPoolBase[] GetAllObjectPools();
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <param name="results">所有对象池。</param>
void GetAllObjectPools(List<ObjectPoolBase> results);
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <param name="sort">是否根据对象池的优先级排序。</param>
/// <returns>所有对象池。</returns>
ObjectPoolBase[] GetAllObjectPools(bool sort);
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <param name="sort">是否根据对象池的优先级排序。</param>
/// <param name="results">所有对象池。</param>
void GetAllObjectPools(bool sort, List<ObjectPoolBase> results);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority);
/// <summary>
/// 销毁对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 销毁对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool(Type objectType);
/// <summary>
/// 销毁对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">要销毁的对象池名称。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 销毁对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">要销毁的对象池名称。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool(Type objectType, string name);
/// <summary>
/// 销毁对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="objectPool">要销毁的对象池。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool<T>(IObjectPool<T> objectPool) where T : ObjectBase;
/// <summary>
/// 销毁对象池。
/// </summary>
/// <param name="objectPool">要销毁的对象池。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool(ObjectPoolBase objectPool);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
void Release();
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
void ReleaseAllUnused();
}
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/IObjectPoolManager.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 4e06b511ecf14c3e8a183ed7492f70dc
timeCreated: 1708673686

207
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectBase.cs Normal file
View File

@@ -0,0 +1,207 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
namespace SHFrame
{
/// <summary>
/// 对象基类。
/// </summary>
public abstract class ObjectBase : IReference
{
private string m_Name;
private object m_Target;
private bool m_Locked;
private int m_Priority;
private DateTime m_LastUseTime;
/// <summary>
/// 初始化对象基类的新实例。
/// </summary>
public ObjectBase()
{
m_Name = null;
m_Target = null;
m_Locked = false;
m_Priority = 0;
m_LastUseTime = default(DateTime);
}
/// <summary>
/// 获取对象名称。
/// </summary>
public string Name
{
get
{
return m_Name;
}
}
/// <summary>
/// 获取对象。
/// </summary>
public object Target
{
get
{
return m_Target;
}
}
/// <summary>
/// 获取或设置对象是否被加锁。
/// </summary>
public bool Locked
{
get
{
return m_Locked;
}
set
{
m_Locked = value;
}
}
/// <summary>
/// 获取或设置对象的优先级。
/// </summary>
public int Priority
{
get
{
return m_Priority;
}
set
{
m_Priority = value;
}
}
/// <summary>
/// 获取自定义释放检查标记。
/// </summary>
public virtual bool CustomCanReleaseFlag
{
get
{
return true;
}
}
/// <summary>
/// 获取对象上次使用时间。
/// </summary>
public DateTime LastUseTime
{
get
{
return m_LastUseTime;
}
internal set
{
m_LastUseTime = value;
}
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="target">对象。</param>
protected void Initialize(object target)
{
Initialize(null, target, false, 0);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
protected void Initialize(string name, object target)
{
Initialize(name, target, false, 0);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
/// <param name="locked">对象是否被加锁。</param>
protected void Initialize(string name, object target, bool locked)
{
Initialize(name, target, locked, 0);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
/// <param name="priority">对象的优先级。</param>
protected void Initialize(string name, object target, int priority)
{
Initialize(name, target, false, priority);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
/// <param name="locked">对象是否被加锁。</param>
/// <param name="priority">对象的优先级。</param>
protected void Initialize(string name, object target, bool locked, int priority)
{
if (target == null)
{
throw new GameFrameworkException(Utility.Text.Format("Target '{0}' is invalid.", name));
}
m_Name = name ?? string.Empty;
m_Target = target;
m_Locked = locked;
m_Priority = priority;
m_LastUseTime = DateTime.UtcNow;
}
/// <summary>
/// 清理对象基类。
/// </summary>
public virtual void Clear()
{
m_Name = null;
m_Target = null;
m_Locked = false;
m_Priority = 0;
m_LastUseTime = default(DateTime);
}
/// <summary>
/// 获取对象时的事件。
/// </summary>
protected internal virtual void OnSpawn()
{
}
/// <summary>
/// 回收对象时的事件。
/// </summary>
protected internal virtual void OnUnspawn()
{
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="isShutdown">是否是关闭对象池时触发。</param>
protected internal abstract void Release(bool isShutdown);
}
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectBase.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 1aa534825636481e87032c12e5faa895
timeCreated: 1708673686

122
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectInfo.cs Normal file
View File

@@ -0,0 +1,122 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
using System.Runtime.InteropServices;
namespace SHFrame
{
/// <summary>
/// 对象信息。
/// </summary>
[StructLayout(LayoutKind.Auto)]
public struct ObjectInfo
{
private readonly string m_Name;
private readonly bool m_Locked;
private readonly bool m_CustomCanReleaseFlag;
private readonly int m_Priority;
private readonly DateTime m_LastUseTime;
private readonly int m_SpawnCount;
/// <summary>
/// 初始化对象信息的新实例。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="locked">对象是否被加锁。</param>
/// <param name="customCanReleaseFlag">对象自定义释放检查标记。</param>
/// <param name="priority">对象的优先级。</param>
/// <param name="lastUseTime">对象上次使用时间。</param>
/// <param name="spawnCount">对象的获取计数。</param>
public ObjectInfo(string name, bool locked, bool customCanReleaseFlag, int priority, DateTime lastUseTime, int spawnCount)
{
m_Name = name;
m_Locked = locked;
m_CustomCanReleaseFlag = customCanReleaseFlag;
m_Priority = priority;
m_LastUseTime = lastUseTime;
m_SpawnCount = spawnCount;
}
/// <summary>
/// 获取对象名称。
/// </summary>
public string Name
{
get
{
return m_Name;
}
}
/// <summary>
/// 获取对象是否被加锁。
/// </summary>
public bool Locked
{
get
{
return m_Locked;
}
}
/// <summary>
/// 获取对象自定义释放检查标记。
/// </summary>
public bool CustomCanReleaseFlag
{
get
{
return m_CustomCanReleaseFlag;
}
}
/// <summary>
/// 获取对象的优先级。
/// </summary>
public int Priority
{
get
{
return m_Priority;
}
}
/// <summary>
/// 获取对象上次使用时间。
/// </summary>
public DateTime LastUseTime
{
get
{
return m_LastUseTime;
}
}
/// <summary>
/// 获取对象是否正在使用。
/// </summary>
public bool IsInUse
{
get
{
return m_SpawnCount > 0;
}
}
/// <summary>
/// 获取对象的获取计数。
/// </summary>
public int SpawnCount
{
get
{
return m_SpawnCount;
}
}
}
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectInfo.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 383ecd9134c14f8b89494e4e49b9c42c
timeCreated: 1708673686

152
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolBase.cs Normal file
View File

@@ -0,0 +1,152 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
namespace SHFrame
{
/// <summary>
/// 对象池基类。
/// </summary>
public abstract class ObjectPoolBase
{
private readonly string m_Name;
/// <summary>
/// 初始化对象池基类的新实例。
/// </summary>
public ObjectPoolBase()
: this(null)
{
}
/// <summary>
/// 初始化对象池基类的新实例。
/// </summary>
/// <param name="name">对象池名称。</param>
public ObjectPoolBase(string name)
{
m_Name = name ?? string.Empty;
}
/// <summary>
/// 获取对象池名称。
/// </summary>
public string Name
{
get
{
return m_Name;
}
}
/// <summary>
/// 获取对象池完整名称。
/// </summary>
public string FullName
{
get
{
return new TypeNamePair(ObjectType, m_Name).ToString();
}
}
/// <summary>
/// 获取对象池对象类型。
/// </summary>
public abstract Type ObjectType
{
get;
}
/// <summary>
/// 获取对象池中对象的数量。
/// </summary>
public abstract int Count
{
get;
}
/// <summary>
/// 获取对象池中能被释放的对象的数量。
/// </summary>
public abstract int CanReleaseCount
{
get;
}
/// <summary>
/// 获取是否允许对象被多次获取。
/// </summary>
public abstract bool AllowMultiSpawn
{
get;
}
/// <summary>
/// 获取或设置对象池自动释放可释放对象的间隔秒数。
/// </summary>
public abstract float AutoReleaseInterval
{
get;
set;
}
/// <summary>
/// 获取或设置对象池的容量。
/// </summary>
public abstract int Capacity
{
get;
set;
}
/// <summary>
/// 获取或设置对象池对象过期秒数。
/// </summary>
public abstract float ExpireTime
{
get;
set;
}
/// <summary>
/// 获取或设置对象池的优先级。
/// </summary>
public abstract int Priority
{
get;
set;
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
public abstract void Release();
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
public abstract void Release(int toReleaseCount);
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
public abstract void ReleaseAllUnused();
/// <summary>
/// 获取所有对象信息。
/// </summary>
/// <returns>所有对象信息。</returns>
public abstract ObjectInfo[] GetAllObjectInfos();
internal abstract void Update(float elapseSeconds, float realElapseSeconds);
internal abstract void Shutdown();
}
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolBase.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 7feeaa70df6e49e8ac5f289d63942c70
timeCreated: 1708673686

200
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolManager.Object.cs Normal file
View File

@@ -0,0 +1,200 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
namespace SHFrame
{
internal sealed partial class ObjectPoolManager : ModuleImp, IObjectPoolManager
{
/// <summary>
/// 内部对象。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
private sealed class Object<T> : IReference where T : ObjectBase
{
private T m_Object;
private int m_SpawnCount;
/// <summary>
/// 初始化内部对象的新实例。
/// </summary>
public Object()
{
m_Object = null;
m_SpawnCount = 0;
}
/// <summary>
/// 获取对象名称。
/// </summary>
public string Name
{
get
{
return m_Object.Name;
}
}
/// <summary>
/// 获取对象是否被加锁。
/// </summary>
public bool Locked
{
get
{
return m_Object.Locked;
}
internal set
{
m_Object.Locked = value;
}
}
/// <summary>
/// 获取对象的优先级。
/// </summary>
public int Priority
{
get
{
return m_Object.Priority;
}
internal set
{
m_Object.Priority = value;
}
}
/// <summary>
/// 获取自定义释放检查标记。
/// </summary>
public bool CustomCanReleaseFlag
{
get
{
return m_Object.CustomCanReleaseFlag;
}
}
/// <summary>
/// 获取对象上次使用时间。
/// </summary>
public DateTime LastUseTime
{
get
{
return m_Object.LastUseTime;
}
}
/// <summary>
/// 获取对象是否正在使用。
/// </summary>
public bool IsInUse
{
get
{
return m_SpawnCount > 0;
}
}
/// <summary>
/// 获取对象的获取计数。
/// </summary>
public int SpawnCount
{
get
{
return m_SpawnCount;
}
}
/// <summary>
/// 创建内部对象。
/// </summary>
/// <param name="obj">对象。</param>
/// <param name="spawned">对象是否已被获取。</param>
/// <returns>创建的内部对象。</returns>
public static Object<T> Create(T obj, bool spawned)
{
if (obj == null)
{
throw new GameFrameworkException("Object is invalid.");
}
Object<T> internalObject = ReferencePool.Acquire<Object<T>>();
internalObject.m_Object = obj;
internalObject.m_SpawnCount = spawned ? 1 : 0;
if (spawned)
{
obj.OnSpawn();
}
return internalObject;
}
/// <summary>
/// 清理内部对象。
/// </summary>
public void Clear()
{
m_Object = null;
m_SpawnCount = 0;
}
/// <summary>
/// 查看对象。
/// </summary>
/// <returns>对象。</returns>
public T Peek()
{
return m_Object;
}
/// <summary>
/// 获取对象。
/// </summary>
/// <returns>对象。</returns>
public T Spawn()
{
m_SpawnCount++;
m_Object.LastUseTime = DateTime.UtcNow;
m_Object.OnSpawn();
return m_Object;
}
/// <summary>
/// 回收对象。
/// </summary>
public void Unspawn()
{
if(m_SpawnCount == 0)
{
return;
}
m_Object.OnUnspawn();
m_Object.LastUseTime = DateTime.UtcNow;
m_SpawnCount--;
if (m_SpawnCount < 0)
{
throw new GameFrameworkException(Utility.Text.Format("Object '{0}' spawn count is less than 0.", Name));
}
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="isShutdown">是否是关闭对象池时触发。</param>
public void Release(bool isShutdown)
{
m_Object.Release(isShutdown);
ReferencePool.Release(m_Object);
}
}
}
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolManager.Object.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: ad6098a006474f6f8ad774fff96556ce
timeCreated: 1708673686

637
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolManager.ObjectPool.cs Normal file
View File

@@ -0,0 +1,637 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
using System.Collections.Generic;
namespace SHFrame
{
internal sealed partial class ObjectPoolManager : ModuleImp, IObjectPoolManager
{
/// <summary>
/// 对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
private sealed class ObjectPool<T> : ObjectPoolBase, IObjectPool<T> where T : ObjectBase
{
private readonly GameFrameworkMultiDictionary<string, Object<T>> m_Objects;
private readonly Dictionary<object, Object<T>> m_ObjectMap;
private readonly ReleaseObjectFilterCallback<T> m_DefaultReleaseObjectFilterCallback;
private readonly List<T> m_CachedCanReleaseObjects;
private readonly List<T> m_CachedToReleaseObjects;
private readonly bool m_AllowMultiSpawn;
private float m_AutoReleaseInterval;
private int m_Capacity;
private float m_ExpireTime;
private int m_Priority;
private float m_AutoReleaseTime;
/// <summary>
/// 初始化对象池的新实例。
/// </summary>
/// <param name="name">对象池名称。</param>
/// <param name="allowMultiSpawn">是否允许对象被多次获取。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
public ObjectPool(string name, bool allowMultiSpawn, float autoReleaseInterval, int capacity, float expireTime, int priority)
: base(name)
{
m_Objects = new GameFrameworkMultiDictionary<string, Object<T>>();
m_ObjectMap = new Dictionary<object, Object<T>>();
m_DefaultReleaseObjectFilterCallback = DefaultReleaseObjectFilterCallback;
m_CachedCanReleaseObjects = new List<T>();
m_CachedToReleaseObjects = new List<T>();
m_AllowMultiSpawn = allowMultiSpawn;
m_AutoReleaseInterval = autoReleaseInterval;
Capacity = capacity;
ExpireTime = expireTime;
m_Priority = priority;
m_AutoReleaseTime = 0f;
}
/// <summary>
/// 获取对象池对象类型。
/// </summary>
public override Type ObjectType
{
get
{
return typeof(T);
}
}
/// <summary>
/// 获取对象池中对象的数量。
/// </summary>
public override int Count
{
get
{
return m_ObjectMap.Count;
}
}
/// <summary>
/// 获取对象池中能被释放的对象的数量。
/// </summary>
public override int CanReleaseCount
{
get
{
GetCanReleaseObjects(m_CachedCanReleaseObjects);
return m_CachedCanReleaseObjects.Count;
}
}
/// <summary>
/// 获取是否允许对象被多次获取。
/// </summary>
public override bool AllowMultiSpawn
{
get
{
return m_AllowMultiSpawn;
}
}
/// <summary>
/// 获取或设置对象池自动释放可释放对象的间隔秒数。
/// </summary>
public override float AutoReleaseInterval
{
get
{
return m_AutoReleaseInterval;
}
set
{
m_AutoReleaseInterval = value;
}
}
/// <summary>
/// 获取或设置对象池的容量。
/// </summary>
public override int Capacity
{
get
{
return m_Capacity;
}
set
{
if (value < 0)
{
throw new GameFrameworkException("Capacity is invalid.");
}
if (m_Capacity == value)
{
return;
}
m_Capacity = value;
Release();
}
}
/// <summary>
/// 获取或设置对象池对象过期秒数。
/// </summary>
public override float ExpireTime
{
get
{
return m_ExpireTime;
}
set
{
if (value < 0f)
{
throw new GameFrameworkException("ExpireTime is invalid.");
}
if (ExpireTime == value)
{
return;
}
m_ExpireTime = value;
Release();
}
}
/// <summary>
/// 获取或设置对象池的优先级。
/// </summary>
public override int Priority
{
get
{
return m_Priority;
}
set
{
m_Priority = value;
}
}
/// <summary>
/// 创建对象。
/// </summary>
/// <param name="obj">对象。</param>
/// <param name="spawned">对象是否已被获取。</param>
public void Register(T obj, bool spawned)
{
if (obj == null)
{
throw new GameFrameworkException("Object is invalid.");
}
Object<T> internalObject = Object<T>.Create(obj, spawned);
m_Objects.Add(obj.Name, internalObject);
m_ObjectMap.Add(obj.Target, internalObject);
if (Count > m_Capacity)
{
Release();
}
}
/// <summary>
/// 检查对象。
/// </summary>
/// <returns>要检查的对象是否存在。</returns>
public bool CanSpawn()
{
return CanSpawn(string.Empty);
}
/// <summary>
/// 检查对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要检查的对象是否存在。</returns>
public bool CanSpawn(string name)
{
if (name == null)
{
throw new GameFrameworkException("Name is invalid.");
}
GameFrameworkLinkedListRange<Object<T>> objectRange = default(GameFrameworkLinkedListRange<Object<T>>);
if (m_Objects.TryGetValue(name, out objectRange))
{
foreach (Object<T> internalObject in objectRange)
{
if (m_AllowMultiSpawn || !internalObject.IsInUse)
{
return true;
}
}
}
return false;
}
/// <summary>
/// 获取对象。
/// </summary>
/// <returns>要获取的对象。</returns>
public T Spawn()
{
return Spawn(string.Empty);
}
/// <summary>
/// 获取对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要获取的对象。</returns>
public T Spawn(string name)
{
if (name == null)
{
throw new GameFrameworkException("Name is invalid.");
}
GameFrameworkLinkedListRange<Object<T>> objectRange = default(GameFrameworkLinkedListRange<Object<T>>);
if (m_Objects.TryGetValue(name, out objectRange))
{
foreach (Object<T> internalObject in objectRange)
{
if (m_AllowMultiSpawn || !internalObject.IsInUse)
{
return internalObject.Spawn();
}
}
}
return null;
}
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="obj">要回收的对象。</param>
public void Unspawn(T obj)
{
if (obj == null)
{
throw new GameFrameworkException("Object is invalid.");
}
Unspawn(obj.Target);
}
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="target">要回收的对象。</param>
public void Unspawn(object target)
{
if (target == null)
{
throw new GameFrameworkException("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject != null)
{
internalObject.Unspawn();
if (Count > m_Capacity && internalObject.SpawnCount <= 0)
{
Release();
}
}
else
{
throw new GameFrameworkException(Utility.Text.Format("Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.", new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
}
}
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="obj">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
public void SetLocked(T obj, bool locked)
{
if (obj == null)
{
throw new GameFrameworkException("Object is invalid.");
}
SetLocked(obj.Target, locked);
}
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="target">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
public void SetLocked(object target, bool locked)
{
if (target == null)
{
throw new GameFrameworkException("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject != null)
{
internalObject.Locked = locked;
}
else
{
throw new GameFrameworkException(Utility.Text.Format("Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.", new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
}
}
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="obj">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
public void SetPriority(T obj, int priority)
{
if (obj == null)
{
throw new GameFrameworkException("Object is invalid.");
}
SetPriority(obj.Target, priority);
}
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="target">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
public void SetPriority(object target, int priority)
{
if (target == null)
{
throw new GameFrameworkException("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject != null)
{
internalObject.Priority = priority;
}
else
{
throw new GameFrameworkException(Utility.Text.Format("Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.", new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
}
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="obj">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
public bool ReleaseObject(T obj)
{
if (obj == null)
{
throw new GameFrameworkException("Object is invalid.");
}
return ReleaseObject(obj.Target);
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="target">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
public bool ReleaseObject(object target)
{
if (target == null)
{
throw new GameFrameworkException("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject == null)
{
return false;
}
if (internalObject.IsInUse || internalObject.Locked || !internalObject.CustomCanReleaseFlag)
{
return false;
}
m_Objects.Remove(internalObject.Name, internalObject);
m_ObjectMap.Remove(internalObject.Peek().Target);
internalObject.Release(false);
ReferencePool.Release(internalObject);
return true;
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
public override void Release()
{
Release(Count - m_Capacity, m_DefaultReleaseObjectFilterCallback);
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
public override void Release(int toReleaseCount)
{
Release(toReleaseCount, m_DefaultReleaseObjectFilterCallback);
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(ReleaseObjectFilterCallback<T> releaseObjectFilterCallback)
{
Release(Count - m_Capacity, releaseObjectFilterCallback);
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback<T> releaseObjectFilterCallback)
{
if (releaseObjectFilterCallback == null)
{
throw new GameFrameworkException("Release object filter callback is invalid.");
}
if (toReleaseCount < 0)
{
toReleaseCount = 0;
}
DateTime expireTime = DateTime.MinValue;
if (m_ExpireTime < float.MaxValue)
{
expireTime = DateTime.UtcNow.AddSeconds(-m_ExpireTime);
}
m_AutoReleaseTime = 0f;
GetCanReleaseObjects(m_CachedCanReleaseObjects);
List<T> toReleaseObjects = releaseObjectFilterCallback(m_CachedCanReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
{
return;
}
foreach (T toReleaseObject in toReleaseObjects)
{
ReleaseObject(toReleaseObject);
}
}
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
public override void ReleaseAllUnused()
{
m_AutoReleaseTime = 0f;
GetCanReleaseObjects(m_CachedCanReleaseObjects);
foreach (T toReleaseObject in m_CachedCanReleaseObjects)
{
ReleaseObject(toReleaseObject);
}
}
/// <summary>
/// 获取所有对象信息。
/// </summary>
/// <returns>所有对象信息。</returns>
public override ObjectInfo[] GetAllObjectInfos()
{
List<ObjectInfo> results = new List<ObjectInfo>();
foreach (KeyValuePair<string, GameFrameworkLinkedListRange<Object<T>>> objectRanges in m_Objects)
{
foreach (Object<T> internalObject in objectRanges.Value)
{
results.Add(new ObjectInfo(internalObject.Name, internalObject.Locked, internalObject.CustomCanReleaseFlag, internalObject.Priority, internalObject.LastUseTime, internalObject.SpawnCount));
}
}
return results.ToArray();
}
internal override void Update(float elapseSeconds, float realElapseSeconds)
{
m_AutoReleaseTime += realElapseSeconds;
if (m_AutoReleaseTime < m_AutoReleaseInterval)
{
return;
}
Release();
}
internal override void Shutdown()
{
foreach (KeyValuePair<object, Object<T>> objectInMap in m_ObjectMap)
{
objectInMap.Value.Release(true);
ReferencePool.Release(objectInMap.Value);
}
m_Objects.Clear();
m_ObjectMap.Clear();
m_CachedCanReleaseObjects.Clear();
m_CachedToReleaseObjects.Clear();
}
private Object<T> GetObject(object target)
{
if (target == null)
{
throw new GameFrameworkException("Target is invalid.");
}
Object<T> internalObject = null;
if (m_ObjectMap.TryGetValue(target, out internalObject))
{
return internalObject;
}
return null;
}
private void GetCanReleaseObjects(List<T> results)
{
if (results == null)
{
throw new GameFrameworkException("Results is invalid.");
}
results.Clear();
foreach (KeyValuePair<object, Object<T>> objectInMap in m_ObjectMap)
{
Object<T> internalObject = objectInMap.Value;
if (internalObject.IsInUse || internalObject.Locked || !internalObject.CustomCanReleaseFlag)
{
continue;
}
results.Add(internalObject.Peek());
}
}
private List<T> DefaultReleaseObjectFilterCallback(List<T> candidateObjects, int toReleaseCount, DateTime expireTime)
{
m_CachedToReleaseObjects.Clear();
if (expireTime > DateTime.MinValue)
{
for (int i = candidateObjects.Count - 1; i >= 0; i--)
{
if (candidateObjects[i].LastUseTime <= expireTime)
{
m_CachedToReleaseObjects.Add(candidateObjects[i]);
candidateObjects.RemoveAt(i);
continue;
}
}
toReleaseCount -= m_CachedToReleaseObjects.Count;
}
for (int i = 0; toReleaseCount > 0 && i < candidateObjects.Count; i++)
{
for (int j = i + 1; j < candidateObjects.Count; j++)
{
if (candidateObjects[i].Priority > candidateObjects[j].Priority
|| candidateObjects[i].Priority == candidateObjects[j].Priority && candidateObjects[i].LastUseTime > candidateObjects[j].LastUseTime)
{
T temp = candidateObjects[i];
candidateObjects[i] = candidateObjects[j];
candidateObjects[j] = temp;
}
}
m_CachedToReleaseObjects.Add(candidateObjects[i]);
toReleaseCount--;
}
return m_CachedToReleaseObjects;
}
}
}
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolManager.ObjectPool.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 47555abda225429bba3f1d33e7cf408a
timeCreated: 1708673686

1303
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolManager.cs Normal file
View File

File diff suppressed because it is too large Load Diff

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolManager.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 72eae18b8c9a41d5bc970c2d702061b9
timeCreated: 1708673686

1015
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolModule.cs Normal file
View File

File diff suppressed because it is too large Load Diff

11
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ObjectPoolModule.cs.meta Normal file
View File

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

22
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ReleaseObjectFilterCallback.cs Normal file
View File

@@ -0,0 +1,22 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using System;
using System.Collections.Generic;
namespace SHFrame
{
/// <summary>
/// 释放对象筛选函数。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="candidateObjects">要筛选的对象集合。</param>
/// <param name="toReleaseCount">需要释放的对象数量。</param>
/// <param name="expireTime">对象过期参考时间。</param>
/// <returns>经筛选需要释放的对象集合。</returns>
public delegate List<T> ReleaseObjectFilterCallback<T>(List<T> candidateObjects, int toReleaseCount, DateTime expireTime) where T : ObjectBase;
}

3
JNFrame2/Assets/UsePlugins/SHFrame/Runtime/Modules/ObjectPool/ReleaseObjectFilterCallback.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 6a256ddf090e4ed58402f4db83117f79
timeCreated: 1708673686