feat(pool): 添加对象池系统基础架构

- 实现了抽象对象池系统支持基于键值的对象池管理
- 定义了对象池系统接口和可池化对象接口规范
- 提供了获取、释放和清空对象池的核心功能
- 添加了Godot节点专用的对象池系统抽象类
- 实现了对象在池中生命周期管理的回调机制

GFramework.Core.Abstractions/pool/IObjectPoolSystem.cs

@@ -0,0 +1,30 @@
+namespace GFramework.Core.Abstractions.pool;
+
+/// <summary>
+/// 对象池系统接口，定义了对象池的基本操作
+/// </summary>
+/// <typeparam name="TKey">池键的类型</typeparam>
+/// <typeparam name="TObject">池中对象的类型，必须实现IPoolableObject接口</typeparam>
+public interface IObjectPoolSystem<in TKey, TObject>
+    where TObject : IPoolableObject
+    where TKey : notnull
+{
+    /// <summary>
+    /// 从对象池中获取一个对象实例
+    /// </summary>
+    /// <param name="key">对象池的键</param>
+    /// <returns>池中的对象实例，如果池中没有可用对象则创建新实例</returns>
+    TObject Acquire(TKey key);
+
+    /// <summary>
+    /// 将对象释放回对象池
+    /// </summary>
+    /// <param name="key">对象池的键</param>
+    /// <param name="obj">要释放的对象</param>
+    void Release(TKey key, TObject obj);
+
+    /// <summary>
+    /// 清空所有对象池
+    /// </summary>
+    void Clear();
+}

GFramework.Core.Abstractions/pool/IPoolableObject.cs

@@ -0,0 +1,22 @@
+namespace GFramework.Core.Abstractions.pool;
+
+/// <summary>
+/// 定义可池化对象的接口，提供对象在池中的生命周期管理方法
+/// </summary>
+public interface IPoolableObject
+{
+    /// <summary>
+    /// 当对象从池中被获取时调用，用于初始化或重置对象状态
+    /// </summary>
+    void OnAcquire();
+
+    /// <summary>
+    /// 当对象被释放回池中时调用，用于清理或重置对象状态以便下次使用
+    /// </summary>
+    void OnRelease();
+
+    /// <summary>
+    /// 当对象池被销毁时调用，用于执行最终的清理工作
+    /// </summary>
+    void OnPoolDestroy();
+}

GFramework.Core/pool/AbstractObjectPoolSystem.cs

@@ -0,0 +1,86 @@
+using GFramework.Core.Abstractions.pool;
+using GFramework.Core.system;
+
+namespace GFramework.Core.pool;
+
+/// <summary>
+/// 抽象对象池系统，提供基于键值的对象池管理功能
+/// </summary>
+/// <typeparam name="TKey">对象池的键类型，必须不为null</typeparam>
+/// <typeparam name="TObject">池化对象类型，必须实现IPoolableObject接口</typeparam>
+public abstract class AbstractObjectPoolSystem<TKey, TObject>
+    : AbstractSystem, IObjectPoolSystem<TKey, TObject> where TObject : IPoolableObject where TKey : notnull
+{
+    /// <summary>
+    /// 存储对象池的字典，键为池标识，值为对应类型的对象栈
+    /// </summary>
+    protected readonly Dictionary<TKey, Stack<TObject>> Pools = new();
+
+    /// <summary>
+    /// 获取对象池中的对象，如果池中没有可用对象则创建新的对象
+    /// </summary>
+    /// <param name="key">对象池的键值</param>
+    /// <returns>获取到的对象实例</returns>
+    public TObject Acquire(TKey key)
+    {
+        if (!Pools.TryGetValue(key, out var pool))
+        {
+            pool = new Stack<TObject>();
+            Pools[key] = pool;
+        }
+
+        var obj = pool.Count > 0
+            ? pool.Pop()
+            : Create(key);
+
+        obj.OnAcquire();
+        return obj;
+    }
+
+    /// <summary>
+    /// 将对象释放回对象池中
+    /// </summary>
+    /// <param name="key">对象池的键值</param>
+    /// <param name="obj">需要释放的对象</param>
+    public void Release(TKey key, TObject obj)
+    {
+        obj.OnRelease();
+
+        if (!Pools.TryGetValue(key, out var pool))
+        {
+            pool = new Stack<TObject>();
+            Pools[key] = pool;
+        }
+
+        pool.Push(obj);
+    }
+
+    /// <summary>
+    /// 清空所有对象池，销毁所有池中的对象并清理池容器
+    /// </summary>
+    public void Clear()
+    {
+        // 遍历所有对象池，调用每个对象的销毁方法
+        foreach (var obj in Pools.Values.SelectMany(pool => pool))
+        {
+            obj.OnPoolDestroy();
+        }
+
+        Pools.Clear();
+    }
+
+    /// <summary>
+    /// 创建一个新的对象实例（由子类决定怎么创建）
+    /// </summary>
+    /// <param name="key">用于创建对象的键值</param>
+    /// <returns>新创建的对象实例</returns>
+    protected abstract TObject Create(TKey key);
+
+    /// <summary>
+    /// 系统销毁时的清理操作，清空所有对象池
+    /// </summary>
+    protected override void OnDestroy()
+    {
+        Clear();
+    }
+}

GFramework.Godot/pool/AbstractNodePoolSystem.cs

@@ -0,0 +1,32 @@
+using GFramework.Core.pool;
+using Godot;
+
+namespace GFramework.Godot.pool;
+
+/// <summary>
+/// 抽象节点对象池系统，用于管理Godot节点类型的对象池
+/// </summary>
+/// <typeparam name="TKey">用作键的类型，必须不为null</typeparam>
+/// <typeparam name="TNode">节点类型，必须继承自Node并实现IPoolableNode接口</typeparam>
+public abstract class AbstractNodePoolSystem<TKey, TNode>
+    : AbstractObjectPoolSystem<TKey, TNode>
+    where TKey : notnull
+    where TNode : Node, IPoolableNode
+{
+    /// <summary>
+    /// 加载场景的抽象方法
+    /// </summary>
+    /// <param name="key">用于标识场景的键</param>
+    /// <returns>加载的PackedScene对象</returns>
+    protected abstract PackedScene LoadScene(TKey key);
+
+    /// <summary>
+    /// 创建新节点实例的重写方法
+    /// </summary>
+    /// <param name="key">用于创建节点的键</param>
+    /// <returns>创建的新节点实例</returns>
+    protected override TNode Create(TKey key)
+    {
+        return LoadScene(key).Instantiate<TNode>();
+    }
+}

GFramework.Godot/pool/IPoolableNode.cs

@@ -0,0 +1,17 @@
+using GFramework.Core.Abstractions.pool;
+using Godot;
+
+namespace GFramework.Godot.pool;
+
+/// <summary>
+/// 可池化节点接口，继承自IPoolableObject接口
+/// 用于定义可以被对象池管理的Godot节点类型
+/// </summary>
+public interface IPoolableNode : IPoolableObject
+{
+    /// <summary>
+    /// 将当前对象转换为Node类型
+    /// </summary>
+    /// <returns>返回当前对象对应的Node实例</returns>
+    Node AsNode();
+}