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

做一套跨引擎时间模块

做一套跨引擎时间模块

当帧差、固定步、暂停、后台恢复和延迟任务分别散落在业务代码里,更换引擎或调整主循环就会牵动大量系统。本节把这些能力收敛成一组引擎无关的时间契约,让引擎适配层只负责提供时钟与生命周期事件,游戏逻辑只消费稳定的时间结果。

学习目标

  • 拆分时间源、帧时钟、固定步和调度器的职责边界
  • 实现可注入、可测试且不依赖具体引擎 API 的最小时间服务
  • 用暂停和后台恢复规则保证不同引擎下具有一致行为

把引擎差异压缩到边界

跨引擎时间模块最重要的不是设计很多接口,而是把真正变化的部分隔离出去。引擎适配层只需要提供单调递增的时间源,并在应用挂起、恢复或游戏暂停时通知时间服务。后面的固定步、缩放、调度和业务计时都不应该直接调用引擎时钟。

跨引擎时间模块的组件关系

可以把稳定职责收敛为四部分:

  • TimeSource:只负责给出单调递增的原始时间。
  • TimeService:生成帧差、游戏累计时间、固定步次数和插值比例。
  • Scheduler:基于选定的时间域执行延迟任务,不自行读取系统时间。
  • 生命周期适配:把暂停、挂起和恢复转换为时间服务能够理解的事件。

这样迁移引擎时,通常只需要重新实现 TimeSource 和生命周期桥接层,而不是修改角色、物理、冷却和任务系统。

一帧只走一条时间链

每个活动帧都应先采样一次原始时钟,再从同一个时间快照派生所有结果。不要让物理系统、动画系统和调度器各自读取当前时间,否则同一帧内也可能得到略有差异的时间值。

推荐的执行顺序是:

  1. 引擎适配层采样原始单调时钟。
  2. TimeService 计算本帧时间,并限制异常大的帧差。
  3. 根据固定步累加器得到本帧需要执行的固定更新次数。
  4. 游戏逻辑执行一次可变步更新,物理等系统执行零到多次固定更新。
  5. Scheduler 根据已经推进的游戏累计时间触发到期任务。
  6. 渲染需要时使用固定步剩余量计算插值比例。

暂停和后台恢复也必须进入这条链。普通暂停可以继续采样原始时钟,但令游戏时间不推进;应用真正挂起后没有帧回调,则应在恢复事件中重新建立原始时钟基线。

实现可测试的最小时间服务

下面用 Python 实现完整的最小版本。ManualTimeSource 用于测试,实际接入引擎时只需替换成包装该引擎单调时钟的适配器。调度器依赖游戏累计时间,因此游戏暂停或后台被排除时,延迟任务也会自然停止推进。

python
from dataclasses import dataclass
from heapq import heappop, heappush
from typing import Callable, Protocol


class TimeSource(Protocol):
    def now(self) -> float:
        ...


class ManualTimeSource:
    def __init__(self):
        self.value = 0.0

    def now(self) -> float:
        return self.value

    def advance(self, seconds: float) -> None:
        self.value += seconds


@dataclass(frozen=True)
class TimeFrame:
    delta: float
    elapsed: float
    fixed_steps: int
    alpha: float


class TimeService:
    def __init__(self, source: TimeSource, fixed_step=0.02,
                 max_delta=0.25, max_fixed_steps=4):
        self.source = source
        self.fixed_step = fixed_step
        self.max_delta = max_delta
        self.max_fixed_steps = max_fixed_steps
        self.last_raw = None
        self.elapsed = 0.0
        self.accumulator = 0.0
        self.paused = False

    def tick(self) -> TimeFrame:
        raw_now = self.source.now()
        if self.last_raw is None:
            self.last_raw = raw_now
            return TimeFrame(0.0, self.elapsed, 0, 0.0)

        raw_delta = max(0.0, raw_now - self.last_raw)
        self.last_raw = raw_now
        if self.paused:
            return TimeFrame(0.0, self.elapsed, 0,
                             self.accumulator / self.fixed_step)

        # max_delta 防止异常长帧一次推进过多模拟时间。
        delta = min(raw_delta, self.max_delta)
        self.elapsed += delta
        self.accumulator += delta

        available = int((self.accumulator + 1e-12) / self.fixed_step)
        fixed_steps = min(available, self.max_fixed_steps)
        self.accumulator -= fixed_steps * self.fixed_step

        # 达到步数上限后丢弃过量积压,避免持续追帧。
        if fixed_steps == self.max_fixed_steps and self.accumulator >= self.fixed_step:
            self.accumulator %= self.fixed_step

        alpha = self.accumulator / self.fixed_step
        return TimeFrame(delta, self.elapsed, fixed_steps, alpha)

    def set_paused(self, paused: bool) -> None:
        self.paused = paused

    def resume_from_suspend(self) -> None:
        # 应用挂起期间没有 tick,因此恢复时直接切断旧的帧基线。
        self.last_raw = self.source.now()
        self.accumulator = 0.0


class Scheduler:
    def __init__(self, time_service: TimeService):
        self.time_service = time_service
        self.queue = []
        self.sequence = 0

    def schedule(self, delay: float, action: Callable[[], None]) -> None:
        self.sequence += 1
        due = self.time_service.elapsed + delay
        heappush(self.queue, (due, self.sequence, action))

    def poll(self) -> None:
        while self.queue and self.queue[0][0] <= self.time_service.elapsed:
            _, _, action = heappop(self.queue)
            action()


def main():
    source = ManualTimeSource()
    time = TimeService(source)
    scheduler = Scheduler(time)

    time.tick()
    scheduler.schedule(0.03, lambda: print("timer fired"))

    source.advance(0.016)
    frame1 = time.tick()
    scheduler.poll()
    print(f"frame1 delta={frame1.delta:.3f} fixed={frame1.fixed_steps}")

    source.advance(0.020)
    frame2 = time.tick()
    scheduler.poll()
    print(f"frame2 delta={frame2.delta:.3f} fixed={frame2.fixed_steps}")

    source.advance(5.0)
    time.resume_from_suspend()
    source.advance(0.020)
    frame3 = time.tick()
    print(f"resumed delta={frame3.delta:.3f} elapsed={frame3.elapsed:.3f}")


if __name__ == "__main__":
    main()

预期输出

text
frame1 delta=0.016 fixed=0
timer fired
frame2 delta=0.020 fixed=1
resumed delta=0.020 elapsed=0.056

5 秒后台时间没有进入 elapsed,恢复后的帧差仍为 0.020 秒。调度器在游戏累计时间达到 0.03 秒后触发一次任务,固定步次数也完全由同一个时间服务计算。

把暂停策略变成时间域选择

一个全局 paused 往往不够覆盖真实项目。物理和角色逻辑可能需要在菜单打开时暂停,但菜单动画仍要继续;局内技能冷却可能暂停,而离线体力恢复必须继续。解决办法不是到处增加 if paused,而是把消费者放进不同时间域。

最常见的划分是游戏时间、非缩放活动时间和绝对时间。游戏时间受暂停和时间倍率影响;非缩放活动时间不受慢动作影响,但仍排除应用挂起;绝对时间来自墙上时钟或服务器,适合跨会话任务。每个 Scheduler 明确绑定一个时间域,就能避免同一个延迟任务在不同系统里出现相反语义。

只在适配层接触具体引擎

接入新引擎时,不需要重写固定步和调度算法。适配层只完成三件事:提供高精度单调时间、每帧调用一次时间服务、在挂起恢复事件中调用 resume_from_suspend()。真正的引擎 API 名称可以变化,但这三个契约不变。

主循环消费者只读取当前 TimeFrame。固定更新按 fixed_steps 次数执行,普通逻辑读取 delta,渲染插值读取 alpha。这样测试环境还能使用 ManualTimeSource 精确推进 16 毫秒、20 毫秒或数秒,而不依赖真实等待和机器帧率。

用不变量验收跨引擎实现

跨引擎模块最适合按行为而不是 API 做验收。同一组原始时间输入在不同适配器下应产生相同的 delta、固定步次数和累计游戏时间;暂停期间游戏累计时间应保持不变;后台恢复不能把挂起时间灌入下一帧;单帧固定更新次数不得超过配置上限。

调度器也要验证时间域语义。绑定游戏时间的任务在暂停期间不能到期,绑定绝对时间的离线任务则应依据现实经过时间重新计算。只要这些不变量成立,具体项目以后更换引擎、主循环入口或测试框架时,时间相关业务就无需跟着重写。

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

目录与阅读设置

阅读设置

17

记录一个想法

做一套跨引擎时间模块

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

登录哪都通