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

把初始化依赖显式化

把初始化依赖显式化

角色对象生成后,组件已经存在,并不代表所有运行时数据都已准备好。如果追击组件在目标坐标写入前开始执行,就可能读取默认值并产生错误移动。本课通过构造注入、阶段式初始化和就绪检查,把原本依赖回调先后顺序的行为改造成可验证的初始化流程。

学习目标

  • 识别组件引用依赖与运行时就绪依赖之间的区别。
  • 使用显式依赖和初始化阶段组织多个组件的启动顺序。
  • 通过可运行示例验证未就绪保护和正常激活行为。

隐式初始化顺序为什么不可靠

假设一个敌人对象包含三个组件:Motor 负责移动,TargetTracker 保存追踪目标,Chase 负责根据目标驱动移动。

Chase 同时依赖另外两个组件。如果三个组件各自在引擎生命周期回调中初始化,就可能出现以下情况:

  1. Motor 已经创建,但尚未设置出生位置。
  2. TargetTracker 已经创建,但尚未接收目标坐标。
  3. Chase 在启用回调中开始执行,读取到默认坐标。
  4. 后续目标数据虽然正确写入,但第一次错误移动已经发生。

这种问题经常表现为偶发的出生位置跳动、首帧方向错误或事件监听失效。调整组件执行顺序可能暂时隐藏问题,却没有明确说明哪些条件必须先成立。

真正需要区分的是两类依赖:

  • 引用依赖:Chase 必须持有有效的 Motor 和 TargetTracker 实例。
  • 就绪依赖:开始追击前,移动位置和目标位置都必须完成初始化。

仅检查引用不为 null,并不能证明组件已经具备可使用的状态。

把依赖拆成装配和就绪阶段

一种稳定的方案是将初始化拆成四个阶段。

  1. 创建组件:创建基础组件与依赖组件,不执行依赖尚未准备好的行为。
  2. 注入配置:通过统一的生成上下文设置出生位置、目标和必要参数。
  3. 检查并激活:依赖组件验证所有前置条件,通过后才能开始执行。
  4. 进入运行:允许执行逐帧更新、事件处理或其他游戏逻辑。

构造函数适合表达长期稳定的引用依赖,Initialize 适合接收本次生成特有的运行时数据,Activate 则负责守住开始运行的边界。

游戏对象组件的显式初始化依赖与阶段顺序

这种阶段划分不要求所有组件按照唯一的固定顺序初始化。没有相互依赖的基础组件可以交换初始化顺序,但依赖组件必须等到它所需的条件全部满足。

如果组件之间出现相互等待,例如 A 必须在 B 初始化后才能初始化,而 B 又必须等待 A,说明依赖关系出现了环。通常应提取共享配置,或者把双方需要的交互推迟到共同就绪后的激活阶段,而不是继续增加回调顺序规则。

用可执行代码固定初始化顺序

下面使用不依赖游戏引擎的 C# 示例模拟对象装配。将代码保存为 .NET 8 控制台项目的 Program.cs 并运行,即可观察初始化后的第一次追击。

csharp
using System;

var context = new SpawnContext(0, 3);
var motor = new Motor();
var target = new TargetTracker();
var chase = new Chase(motor, target);

// 基础组件先接收本次生成所需的数据
motor.Initialize(context.SpawnX);
target.Initialize(context.TargetX);

// 所有前置条件就绪后,才允许依赖行为运行
chase.Activate();
chase.Tick();
Console.WriteLine($"position={motor.X}, target={target.X}");

record SpawnContext(int SpawnX, int TargetX);

sealed class Motor
{
    public bool IsReady { get; private set; }
    public int X { get; private set; }

    public void Initialize(int x)
    {
        X = x;
        IsReady = true;
    }

    public void StepToward(int goal)
    {
        X += Math.Sign(goal - X);
    }
}

sealed class TargetTracker
{
    public bool IsReady { get; private set; }
    public int X { get; private set; }

    public void Initialize(int x)
    {
        X = x;
        IsReady = true;
    }
}

sealed class Chase
{
    private readonly Motor _motor;
    private readonly TargetTracker _target;
    private bool _active;

    public Chase(Motor motor, TargetTracker target)
    {
        _motor = motor ?? throw new ArgumentNullException(nameof(motor));
        _target = target ?? throw new ArgumentNullException(nameof(target));
    }

    public void Activate()
    {
        // 对象存在不等于状态就绪,激活前必须分别检查
        if (!_motor.IsReady || !_target.IsReady)
            throw new InvalidOperationException("Dependencies not ready.");
        _active = true;
    }

    public void Tick()
    {
        if (_active)
            _motor.StepToward(_target.X);
    }
}

预期输出:

text
position=1, target=3

初始移动位置为 0,目标位置为 3。Chase 成功激活后执行一次 Tick,移动位置向目标增加一个单位。

这里有两个关键设计:构造函数在装配时确保必需引用存在,Activate 在运行前确保依赖数据已经准备完成。这样可以把原本难以定位的首帧错误转化为明确的初始化异常。

验证初始化边界与失败行为

可以通过修改调用顺序验证这套约束。

  1. 将 chase.Activate() 移到两个 Initialize 调用之前,程序应抛出包含 Dependencies not ready. 的异常,而不是继续使用默认坐标。
  2. 只初始化 Motor,不初始化 TargetTracker,激活仍应失败,证明不会遗漏第二个依赖。
  3. 恢复正常调用后,交换两个基础组件的初始化顺序,输出应保持不变,证明独立组件之间没有额外的顺序要求。

在 Unity、Unreal Engine 或 Godot 中,可以由对象生成器、控制器或专门的装配逻辑协调这些阶段。引擎的生命周期回调负责提供执行时机,但不应该成为跨组件依赖已经就绪的唯一证明。

对于异步加载资源或远端数据,还需要把就绪状态延长到真正完成加载之后,并定义超时、取消或失败策略。不要把“对象已创建”和“业务可以开始执行”混为同一个状态。

初始化设计的核心不是给每个组件指定固定排名,而是让每个组件明确声明自己需要什么、何时具备运行条件,以及条件未满足时应该如何失败。

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

目录与阅读设置

阅读设置

17

记录一个想法

把初始化依赖显式化

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

登录哪都通