游戏中的对象池技术探索（一）

于 2024-10-03 09:27:55 发布
阅读量543 收藏 6
点赞数 3
分类专栏： 个人研究 文章标签： unity c# 对象池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hgf1037882434/article/details/142674951
版权

前言

对象池技术在游戏开发中的应用非常普遍，它是一种高效管理对象实例的技术，能够避免频繁和重复创建对象所带来的性能开销。本篇文章我们就来探索一下如何在游戏开发中设计通用对象池，使之易于使用和扩展。

代码

代码目录结构
  • ObjectPool
    • Base
    • Interface
    • Settings

ObjectPool作为本模块的根目录，用于存储模块子目录和具体的对象池脚本。Base目录用于存储对象池抽象基类，用于规范对象池的设计。Interface目录用于存储对象池相关的接口，用于未来扩展。Settings目录用于存储创建对象池的参数脚本以及对象池的设置。

Base目录

BasePool.cs

using System;
using System.Collections.Generic;

/// <summary>
/// 对象池基类
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
public abstract class BasePool<T>
{
    /// <summary>
    /// 对象池所生产对象的总数量
    /// </summary>
    public int totalCount { get; protected set; }

    /// <summary>
    /// 对象池当前空闲对象的数量
    /// </summary>
    public int freeCount => _pool.Count;

    /// <summary>
    /// 是否为固定容量的对象池
    /// <para>默认值:False</para>
    /// </summary>
    public readonly bool isFixed;

    /// <summary>
    /// 对象池容量
    /// <para>默认值:PoolConstant.DEFAULT_CAPACITY</para>
    /// </summary>
    public readonly int capacity;

    /// <summary>
    /// 对象创建逻辑
    /// <para>提示：用来自定义对象的创建逻辑</para>
    /// </summary>
    public Func<T> overrideCreate;

    /// <summary>
    /// 对象重置逻辑
    /// <para>提示：用来自定义对象的重置逻辑</para>
    /// </summary>
    public Func<T, T> overrideReset;

    /// <summary>
    /// 池对象
    /// </summary>
    protected readonly Stack<T> _pool;

    /// <summary>
    /// 对象类型是否为可释放对象类型
    /// </summary>
    protected static bool _isDisposable => _staticIsDisposable;
    static readonly bool _staticIsDisposable = typeof(IDisposable).IsAssignableFrom(typeof(T));

    /// <summary>
    /// 对象类型名称
    /// </summary>
    protected static string _typeName => _staticTypeName;
    static readonly string _staticTypeName = typeof(T).Name;

    protected BasePool()
    {
        _pool = new Stack<T>(PoolConstant.DEFAULT_CAPACITY);
        capacity = PoolConstant.DEFAULT_CAPACITY;
    }

    protected BasePool(int capacity)
    {
        if (capacity <= 0) throw new ArgumentException("Pool:The capacity is not allowed to be less than or equal to zero for the pool.");

        _pool = new Stack<T>(capacity);
        this.capacity = capacity;
    }

    protected BasePool(int capacity, bool isFixed)
    {
        if (capacity <= 0) throw new ArgumentException("Pool:The capacity is not allowed to be less than or equal to zero for the pool.");

        _pool = new Stack<T>(capacity);
        this.capacity = capacity;
        this.isFixed = isFixed;
    }

    /// <summary>
    /// 重置对象并返回
    /// </summary>
    protected abstract T Reset(T item);

    /// <summary>
    /// 创建对象
    /// </summary>
    protected abstract T Create();

    /// <summary>
    /// 获取对象
    /// </summary>
    public abstract T Get();

    /// <summary>
    /// 释放对象
    /// </summary>
    public abstract void Release(T item);

    /// <summary>
    /// 清空对象池
    /// </summary>
    public abstract void Clear();
}
Interface目录

......

Settings目录

PoolConstant.cs

public static class PoolConstant
{
    // 对象池默认容量
    public const int DEFAULT_CAPACITY = 10;
}

UnityObjectPoolSettings.cs

using UnityEngine;

/// <summary>
/// Unity对象池设置
/// </summary>
public class UnityObjectPoolSettings<T> where T : Object
{
    /// <summary>
    /// 对象池初始容量
    /// </summary>
    public int capacity = PoolConstant.DEFAULT_CAPACITY;

    /// <summary>
    /// 对象池是否持久化
    /// </summary>
    public bool isPersistant = true;

    /// <summary>
    /// 对象池是否固定容量
    /// </summary>
    public bool isFixed;

    /// <summary>
    /// 对象池容器
    /// </summary>
    public GameObject container;

    /// <summary>
    /// 对象原型
    /// </summary>
    public T original;

    /// <summary>
    /// 对象默认名称
    /// </summary>
    public string defaultName;

    /// <summary>
    /// 获取时激活对象
    /// </summary>
    public bool activeWhenGet = true;
}
具体的对象池 

ClassPool.cs

using System;

/// <summary>
/// Class 类型对象池
/// </summary>
/// <typeparam name="T">具体的 Class 类型</typeparam>
public class ClassPool<T> : BasePool<T>
where T : class
{
    public ClassPool() { }
    public ClassPool(int capacity) : base(capacity) { }
    public ClassPool(int capacity, bool isFixed) : base(capacity, isFixed) { }

    public override void Clear()
    {
        if (_isDisposable)
        {
            while (_pool.Count > 0)
            {
                if (_pool.Pop() is IDisposable ds)
                    ds?.Dispose();
            }
        }
        else _pool.Clear();

        totalCount = 0;
    }

    public override T Get()
    {
        T item;

        if (freeCount > 0) item = _pool.Pop();
        else
        {
            item = Create();
            totalCount++;
        }

        return item;
    }

    public override void Release(T item)
    {
        if (item == null) return;
        _pool.Push(Reset(item));
    }

    protected override T Reset(T item)
    {
        T v_item;
        if (overrideReset != null) v_item = overrideReset(item);
        else v_item = item;
        return v_item == null ? item : v_item;
    }

    protected override T Create()
    {
        if (isFixed && totalCount == capacity)
            throw new InvalidOperationException("Pool:The number of objects in the object pool has reached the upper limit.");

        T item;
        if (overrideCreate != null) item = overrideCreate();
        else item = Activator.CreateInstance<T>();

        if (item == null) throw new InvalidOperationException("Pool:The item created is null.");
        return item;
    }
}

UnityObjectPool.cs

using System;
using UnityEngine;

/// <summary>
/// Unity对象池
/// </summary>
/// <typeparam name="T">Unity对象类型</typeparam>
public class UnityObjectPool<T> : ClassPool<T>, IDisposable
where T : UnityEngine.Object
{
    protected readonly GameObject _container;
    protected readonly T _original;
    protected readonly string _defaultName;
    protected readonly bool _activeWhenGet;
    bool _isDisposed;

    public UnityObjectPool()
    {
        _container = new GameObject($"{_typeName}Pool");
        MonoBehaviour.DontDestroyOnLoad(_container);
        _activeWhenGet = true;
    }

    public UnityObjectPool(int capacity) : base(capacity)
    {
        _container = new GameObject($"{_typeName}Pool");
        MonoBehaviour.DontDestroyOnLoad(_container);
        _activeWhenGet = true;
    }

    public UnityObjectPool(int capacity, bool isFixed) : base(capacity, isFixed)
    {
        _container = new GameObject($"{_typeName}Pool");
        MonoBehaviour.DontDestroyOnLoad(_container);
        _activeWhenGet = true;
    }

    public UnityObjectPool(UnityObjectPoolSettings<T> settings) :
    base(settings == null ? PoolConstant.DEFAULT_CAPACITY : settings.capacity, settings != null && settings.isFixed)
    {
        if (settings == null)
        {
            _container = new GameObject($"{_typeName}Pool");
            MonoBehaviour.DontDestroyOnLoad(_container);
            return;
        }

        _container = settings.container;
        _original = settings.original;
        _defaultName = settings.defaultName;
        _activeWhenGet = settings.activeWhenGet;

        if (settings.isPersistant) MonoBehaviour.DontDestroyOnLoad(_container);
    }

    /// <summary>
    /// 释放对象池
    /// <para>提示：释放后对象池将无法继续使用</para>
    /// </summary>
    public void Dispose()
    {
        if (_isDisposed) return;

        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public sealed override void Clear()
    {
        if (_isDisposed) return;
        DoClear();
    }

    public sealed override void Release(T item)
    {
        if (_isDisposed) return;
        DoRelease(item);
    }

    public sealed override T Get()
    {
        if (_isDisposed) return null;
        return DoGet();
    }

    protected virtual void DoClear()
    {
        T item;
        while (_pool.Count > 0)
        {
            item = _pool.Pop();
            MonoBehaviour.Destroy(item);
        }

        totalCount = 0;
    }

    protected virtual void DoRelease(T item) { base.Release(item); }
    protected virtual T DoGet() { return base.Get(); }

    void Dispose(bool disposing)
    {
        if (_isDisposed) return;
        _isDisposed = true;

        if (disposing)
        {
            Clear();
            MonoBehaviour.Destroy(_container);
        }
    }

    ~UnityObjectPool()
    {
        Dispose(false);
    }
}

GameObjectPool.cs

using System;
using UnityEngine;

/// <summary>
/// GameObject 对象池
/// </summary>
public sealed class GameObjectPool : UnityObjectPool<GameObject>
{
    public GameObjectPool() { }
    public GameObjectPool(int capacity) : base(capacity) { }
    public GameObjectPool(int capacity, bool isFixed) : base(capacity, isFixed) { }
    public GameObjectPool(UnityObjectPoolSettings<GameObject> settings) : base(settings) { }

    protected override GameObject DoGet()
    {
        if (!_activeWhenGet) return base.DoGet();
        else
        {
            GameObject item = base.DoGet();
            item.SetActive(true);
            return item;
        }
    }

    protected override GameObject Reset(GameObject item)
    {
        GameObject v_item;
        if (overrideReset != null) v_item = overrideReset(item);
        else
        {
            v_item = item;
            v_item.SetActive(false);
        }

        if (v_item == null) throw new InvalidOperationException("Pool:The item being reset is null.");
        return v_item;
    }

    protected override GameObject Create()
    {
        if (isFixed && totalCount == capacity)
            throw new InvalidOperationException("Pool:The number of objects in the object pool has reached the upper limit.");

        GameObject item;
        if (overrideCreate != null) item = overrideCreate();
        else
        {
            if (_original == null) item = new GameObject();
            else item = MonoBehaviour.Instantiate(_original);

            if (item != null)
            {
                if (!string.IsNullOrEmpty(_defaultName)) item.name = _defaultName;
                item.transform.SetParent(_container.transform);
                item.SetActive(false);
            }
        }

        if (item == null) throw new InvalidOperationException("Pool:The item being created is null.");
        return item;
    }
}

MonoPool.cs

using System;
using UnityEngine;

/// <summary>
/// Monobehaviour 类型对象池
/// </summary>
/// <typeparam name="T">具体的 Monobehaviour 类型</typeparam>
public sealed class MonoPool<T> : UnityObjectPool<T>
where T : MonoBehaviour
{
    public MonoPool() { }
    public MonoPool(int capacity) : base(capacity) { }
    public MonoPool(int capacity, bool isFixed) : base(capacity, isFixed) { }
    public MonoPool(UnityObjectPoolSettings<T> settings) : base(settings) { }

    protected override T DoGet()
    {
        if (!_activeWhenGet) return base.DoGet();
        else
        {
            T item = base.DoGet();
            item.enabled = true;
            return item;
        }
    }

    protected override T Reset(T item)
    {
        T v_item;
        if (overrideReset != null) v_item = overrideReset(item);
        else
        {
            v_item = item;
            v_item.enabled = false;
        }

        if (v_item == null) throw new InvalidOperationException("Pool:The item being reset is null.");
        return v_item;
    }

    protected override T Create()
    {
        if (isFixed && totalCount == capacity)
            throw new InvalidOperationException("Pool:The number of objects in the object pool has reached the upper limit.");

        T item;
        if (overrideCreate != null) item = overrideCreate();
        else
        {
            if (_original == null) item = _container.AddComponent<T>();
            else item = MonoBehaviour.Instantiate(_original);

            if (item != null)
            {
                if (!string.IsNullOrEmpty(_defaultName)) item.name = _defaultName;
                item.enabled = false;
            }
        }

        if (item == null) throw new InvalidOperationException("Pool:The item being created is null.");
        return item;
    }
}

测试

using System;
using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools;

public class ObjectPoolTest
{
    // 子弹
    public class Bullet : MonoBehaviour
    {
        public Action<Bullet> onDestroy;
        public DamageModel damageModel;

        public void OnCustomTriggerEnter(string tag)
        {
            if (tag == "Head")
            {
                Debug.Log("Attack Head:" + damageModel.AttackHead());
                onDestroy?.Invoke(this);
            }
            else if (tag == "Body")
            {
                Debug.Log("Attack Body:" + damageModel.AttackBody());
                onDestroy?.Invoke(this);
            }
        }
    }

    // 伤害计算模型
    public class DamageModel
    {
        public int damage;

        public int AttackHead()
        {
            return damage * 2;
        }

        public int AttackBody()
        {
            return damage;
        }
    }

    static readonly GameObjectPool bulletPool = new GameObjectPool();
    static readonly ClassPool<DamageModel> damagePool = new ClassPool<DamageModel>();
    static readonly string[] tags = { "Head", "Body" };

    static ObjectPoolTest()
    {
        bulletPool.overrideReset = ResetBullet;
        damagePool.overrideReset = ResetDamageModel;
    }

    static GameObject ResetBullet(GameObject go)
    {
        if (go.TryGetComponent(out Bullet bullet))
        {
            damagePool.Release(bullet.damageModel);
            bullet.damageModel = null;
            bullet.onDestroy = null;
        }
        go.SetActive(false);
        return go;
    }

    static DamageModel ResetDamageModel(DamageModel dm)
    {
        dm.damage = 0;
        return dm;
    }

    Bullet GetBullet()
    {
        GameObject go = bulletPool.Get();
        if (!go.TryGetComponent(out Bullet bullet)) bullet = go.AddComponent<Bullet>();
        DamageModel damageModel = damagePool.Get();
        damageModel.damage = UnityEngine.Random.Range(10, 100);
        bullet.damageModel = damageModel;
        bullet.onDestroy = OnBulletDestroy;
        return bullet;
    }

    void OnBulletDestroy(Bullet bullet)
    {
        Debug.Log("Bullet is being destroied.");
        bulletPool.Release(bullet.gameObject);
    }

    [UnityTest]
    public IEnumerator ObjectPool_Test()
    {
        int index = 0;
        WaitForSeconds waitForSeconds = new WaitForSeconds(0.5f);
        Stack<Bullet> temp = new Stack<Bullet>();
        while (index < 9)
        {
            Debug.Log($"正在进行第{index + 1}次射击...");

            int sendBulletCount = UnityEngine.Random.Range(1, 5);
            for (int i = 0; i < sendBulletCount; i++)
            {
                Debug.Log($"正在生成第{i + 1}颗子弹...");
                temp.Push(GetBullet());
            }

            Debug.Log($"生产子弹总量:{bulletPool.totalCount}，子弹库存:{bulletPool.freeCount}");

            int j = 0;
            while (temp.Count > 0)
            {
                Debug.Log($"正在发射第{j + 1}颗子弹...");
                temp.Pop().OnCustomTriggerEnter(tags[UnityEngine.Random.Range(0, 1)]);
                j++;
            }

            yield return waitForSeconds;
            index++;
        }
        yield return null;
        Assert.IsTrue(true);
    }
}

 上述代码基于Unity Test Framework进行测试，模拟了9次射击，每次随机发射1-5颗子弹，随机设置每个子弹的基本伤害为10-100，用对象池技术管理子弹游戏对象实例和伤害计算模型实例。

分析

BasePool作为所有对象池的抽象基类，规范对象池的必要属性和方法。PoolConstant记录对象池所用的常量值。UnityObjectPoolSettings作为Unity对象池特有的对象池设置参数，在创建Unity对象池时传递。ClassPool作为C#类对象池。UnityObjectPool作为Unity对象池，继承自ClassPool。GameObjectPool作为Unity游戏对象池。MonoPool作为Monobehaviour对象池。

版本改进

......

系列文章

......

如果这篇文章对你有帮助，请给作者点个赞吧！

我与岁月的森林
关注
专栏目录
GameFramework框架详解之 ObejctPool对象池模块
TxNet
11-26 3354
一.前言 GF框架中对象池的使用，总共有三处 1.ObjectPool对象池 2.RefrencePool引用池 3.TaskPool任务池 首先使用原理都是一样的，都是因为存在频繁的创建和销毁，为了避免GC而对对象进行缓存，需要时获取，不需要是回收。 而在GF框架中之所以分成3个Pool去做这些事情，也是为了不同的 功能而分别差异化实现的 二.TaskPool任务池 先来聊聊TaskPool吧，TaskPool其实是ITaskAgent的一个集合，负责ITaskAgent的初始化，执行，回收等操作
探索Unity游戏开发的新境界：kPooling对象池利器
gitblog_00051的博客
05-30 267
探索Unity游戏开发的新境界：kPooling对象池利器 kPoolingCustomizable Object Pooling for Unity.项目地址:https://gitcode.com/gh_mirrors/kpo/kPooling 在当今快节奏的游戏开发世界里，性能优化是每个开发者不可忽视的关键点。针对这一需求，一款名为kPooling的开源神器横空出世，为Unity开发者提供...
探索高效能的JavaScript对象池：deePool
gitblog_00839的博客
09-02 259
探索高效能的JavaScript对象池：deePool deePoolhighly-efficient pool for JavaScript objects项目地址:https://gitcode.com/gh_mirrors/de/deePool 在现代Web开发中，性能优化是每个开发者都必须面对的挑战。今天，我们将介绍一个名为deePool的开源项目，它是一个高效、简洁的JavaScrip...
推荐文章：深入探索 Lifeguard - Rust 中的对象池管理器
gitblog_01074的博客
08-29 486
推荐文章：深入探索 Lifeguard - Rust 中的对象池管理器 lifeguardAn object pool manager in Rust项目地址:https://gitcode.com/gh_mirrors/li/lifeguard 在追求高效与资源优化的现代软件开发中，一个精心设计的对象池管理工具显得尤为重要。今天，我们将聚焦于一个名为 Lifeguard 的 Rust 开源项目...
推荐文章：深度探索「deePool」——高效对象池解决方案
gitblog_00099的博客
06-26 387
推荐文章：深度探索「deePool」——高效对象池解决方案 deePoolhighly-efficient pool for JavaScript objects项目地址:https://gitcode.com/gh_mirrors/de/deePool 在现代软件开发中，性能优化是永恒的话题，尤其是在资源密集型应用中。今天，我们带来了一个旨在提升应用效率的宝藏工具 —— deePool。这是一...
探索PLoop：一个强大的Lua面向对象系统
gitblog_00891的博客
09-24 416
探索PLoop：一个强大的Lua面向对象系统 PLoop Prototype Lua object-oriented program system and frameworks. 项目地址: https://gitcode.co...
中重度手游项目开发（一） 中重度游戏框架探索与搭建
jiao2222的博客
11-21 1015
        从参加工作到现在匆匆过去11年，回头看看，发现无形中经历了手机游戏从“小玩意”到“摩天大楼”的技术变迁，常见的中重度游戏类型也开发过不少，发现很多功能模块都是相似的，设计理念可以一脉相承。于是萌生了一个想法：分享出游戏中常见的功能模块与理念设计，并将我整理好的框架工具分享出来，尽可能让有类似功能需求的朋友们，可以直接用。           a.详细介绍目前已知方案与优缺点，并...
第一篇【传奇开心果系列】Python的游戏库pygame技术点案例示例：深度解读实战开发飞机大战经典游戏案例
jackchuanqi的博客
04-22 5083
开发飞机大战游戏不仅能满足广大玩家的娱乐需求，提供寓教于乐的学习机会，也是技术实践、创新实验和商业探索的重要载体，具有多维度的社会与经济价值。
探索Light-Memory-Pool：一款高效的内存池管理库
gitblog_00017的博客
04-23 422
探索Light-Memory-Pool：一款高效的内存池管理库 项目地址:https://gitcode.com/Light-City/light-memory-pool 在软件开发中，内存管理是优化性能的重要环节，而内存池正是实现这一目标的有效策略之一。今天，我们将会深入介绍一个名为Light-Memory-Pool的开源项目，它是一个轻量级、高性能的内存池实现，适用于C++开发者。 项目简介 ...
Unity中对象池插件
01-12
Unity中的对象池是一种优化游戏性能的技术，主要用于管理游戏对象，如敌人、子弹或者特效等，以减少频繁创建和销毁对象带来的开销。对象池插件是实现这一技术的工具，它可以自动化地管理游戏对象的生命周期，提高...
一个简单ssh游戏网站,重点放在java后端上。.zip
12-17
这是一个基于Java技术开发的简单SSH（Struts2 + Spring + Hibernate）游戏网站项目，适合用于毕业设计、课程设计或者作为初学者提升技能的学习资源。在这个项目中，你将接触到Java后端开发的关键技术和实践应用。 ...
【架构设计必备】：对象池模式在系统设计中的优势与应用
对象池模式是一种广泛应用于软件工程中的设计模式，它通过维护一个对象的集合来减少在系统中创建和销毁对象的开销。对象池模式的核心是“重用”，通过复用对象而不是重复创建来优化资源利用和提高性能。在处理大量...
【C#生态园】后端服务与网络库：选择适合你游戏开发的利器
最新发布
记录我的学习历程
10-02 1683
本文将重点介绍PlayFab、Photon、Lidgren.Network、Mirror、DarkRift Networking和Lidgren.Lite这六个提供后端服务或网络通信功能的库。通过简要介绍它们的核心功能、使用场景、安装与配置方法以及API概览，读者可以更好地了解并选择适合自己项目的后端服务和网络库。
热补丁反调试API Hook—上跳/下跳
weixin_48257887的博客
09-30 426
以 IsDebuggerPresent 函数为例，可以看到可以上跳（简单），也可以下跳（复杂）。
【C#生态园】探秘C#地图处理库：功能详解与安装配置指南
记录我的学习历程
09-28 1158
本文将介绍六个用于C#的地图处理库，分别是GMap.NET、MapWinGIS、SharpMap、Esri.ArcGISRuntime、NetTopologySuite和Leaflet.Net。对于每个库，我们将从简介、安装与配置、API概览等方面进行详细介绍，帮助读者全面了解这些库的特点和适用场景。
初识C#（四）- 函数或方法
qq_45310624的博客
09-27 665
本篇笔记重点描述C#中如何使用函数。
C#源码安装ZedGraph组件，并且立即演示使用
大坡3D软件开发
09-28 299
这样就可以把代码全部下载下来，不过它是支持.net 3.5的版本，现在已经不再使用，编译器里也没有带有这个SDK，需要把它删除掉，这里的ZedGraph.dll是公共文件，ZedGraph.WinForms.dll是导入到WinForm应用程序的文件。当然这个程序没有干什么事情，下一次再来一个复杂一点的程序。在工具箱里添加动态连接库，就可以出现这个组件。这里添加了.net 4.8的支持。这样就可以运行程序了，
C# 实现UVC摄像头扩展模块通讯
weixin_43986048的博客
09-30 299
【代码】C# 实现UVC摄像头扩展模块通讯。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值