游戏客户端架构 / 系统课时

引擎差异应该隔离在哪里

引擎差异应该隔离在哪里

对象池真正难迁移的部分通常不是队列或栈,而是创建对象、激活节点、恢复变换、解绑组件和销毁资源这些引擎操作。把这些差异集中在适配层,池核心与玩法代码才能保持稳定,只替换少量引擎相关实现。

学习目标

  • 划分对象池核心、引擎适配层与业务层的职责
  • 通过适配接口阻止具体引擎 API 渗透到池核心
  • 判断哪些代码应该随引擎迁移,哪些代码应该原样保留

把变化最大的代码压到最外层

一个可迁移的对象池至少可以分成三层:业务层决定什么时候获取或归还对象;池核心管理空闲集合、容量和生命周期顺序;引擎适配层负责真正创建、启用、停用和销毁引擎对象。

对象池核心与引擎适配层分层结构

这种结构的判断原则很直接:只要某段代码必须引用具体引擎命名空间、对象基类、场景 API 或资源销毁 API,就优先放到适配层。 栈、队列、容量计数、重复归还检查等纯逻辑则留在池核心。

用适配接口包住引擎生命周期

下面的完整 C# 示例把创建和生命周期操作全部放进 IEngineObjectAdapter<T>。示例中的 DemoAdapter 用普通对象模拟引擎适配器,因此可以直接运行;迁移到真实引擎时,只需替换适配器实现。

csharp
using System;
using System.Collections.Generic;

public interface IEngineObjectAdapter<T> where T : class
{
    T Create();
    void PrepareForUse(T instance);
    void PrepareForPool(T instance);
    void Destroy(T instance);
}

public sealed class ObjectPool<T> where T : class
{
    private readonly Stack<T> inactive = new();
    private readonly IEngineObjectAdapter<T> adapter;

    public ObjectPool(IEngineObjectAdapter<T> adapter)
    {
        this.adapter = adapter;
    }

    public T Acquire()
    {
        T instance = inactive.Count > 0 ? inactive.Pop() : adapter.Create();
        adapter.PrepareForUse(instance);
        return instance;
    }

    public void Release(T instance)
    {
        adapter.PrepareForPool(instance);
        inactive.Push(instance);
    }

    public void Clear()
    {
        while (inactive.Count > 0)
            adapter.Destroy(inactive.Pop());
    }
}

public sealed class DemoObject
{
    public int Id { get; init; }
    public bool Active { get; set; }
}

public sealed class DemoAdapter : IEngineObjectAdapter<DemoObject>
{
    private int nextId;

    public DemoObject Create()
    {
        var instance = new DemoObject { Id = ++nextId };
        Console.WriteLine($"create #{instance.Id}");
        return instance;
    }

    public void PrepareForUse(DemoObject instance)
    {
        instance.Active = true;
        Console.WriteLine($"activate #{instance.Id}");
    }

    public void PrepareForPool(DemoObject instance)
    {
        instance.Active = false;
        Console.WriteLine($"deactivate #{instance.Id}");
    }

    public void Destroy(DemoObject instance)
    {
        Console.WriteLine($"destroy #{instance.Id}");
    }
}

public static class Program
{
    public static void Main()
    {
        var pool = new ObjectPool<DemoObject>(new DemoAdapter());

        DemoObject first = pool.Acquire();
        pool.Release(first);
        DemoObject second = pool.Acquire();

        Console.WriteLine($"reused={ReferenceEquals(first, second)}");
        pool.Release(second);
        pool.Clear();
    }
}

预期输出:

text
create #1
activate #1
deactivate #1
activate #1
reused=True
deactivate #1
destroy #1

池核心没有出现任何具体引擎类。换到真实项目后,适配器内部可以将 Create 映射为引擎实例化操作,将 PrepareForUse 映射为激活和必要的场景挂接,将 PrepareForPool 映射为停用及引用清理,将 Destroy 映射为引擎规定的销毁流程。

不要让适配层变成第二个业务层

隔离引擎差异并不意味着把所有重置逻辑都塞进适配器。适配器只应该处理与引擎运行时相关的动作,例如激活状态、父节点关系、组件启停、引擎级销毁和资源句柄操作。

角色生命值、子弹伤害、技能冷却、敌人目标引用等属于游戏对象自己的业务状态,应该由对象的重置接口或专门的重置器负责。否则适配器会逐渐知道所有玩法规则,迁移引擎时反而需要重写大量业务逻辑。

用依赖方向检查迁移成本

迁移前可以顺着依赖关系做一次检查:玩法代码只能认识池接口,池核心只能认识抽象适配器,只有适配器能够认识具体引擎。这样从引擎 A 切换到引擎 B 时,需要替换的通常只是创建、激活、停用、销毁等边界代码。

反过来,如果业务层到处直接调用引擎对象的激活和销毁方法,即使已经存在一个名为“对象池”的类,也仍然只是把实例缓存了起来,并没有真正形成可迁移的池化架构。

合理的边界不是追求完全消除引擎代码,而是让它们集中在数量少、职责清晰、可以整体替换的适配器中。池的容量策略、空闲集合、获取归还顺序以及玩法调用方式因此可以跨引擎继续复用。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

引擎差异应该隔离在哪里

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通