游戏客户端架构 / 系统课时
做一套跨引擎时间模块
做一套跨引擎时间模块
当帧差、固定步、暂停、后台恢复和延迟任务分别散落在业务代码里,更换引擎或调整主循环就会牵动大量系统。本节把这些能力收敛成一组引擎无关的时间契约,让引擎适配层只负责提供时钟与生命周期事件,游戏逻辑只消费稳定的时间结果。
学习目标
- 拆分时间源、帧时钟、固定步和调度器的职责边界
- 实现可注入、可测试且不依赖具体引擎 API 的最小时间服务
- 用暂停和后台恢复规则保证不同引擎下具有一致行为
把引擎差异压缩到边界
跨引擎时间模块最重要的不是设计很多接口,而是把真正变化的部分隔离出去。引擎适配层只需要提供单调递增的时间源,并在应用挂起、恢复或游戏暂停时通知时间服务。后面的固定步、缩放、调度和业务计时都不应该直接调用引擎时钟。

可以把稳定职责收敛为四部分:
TimeSource:只负责给出单调递增的原始时间。TimeService:生成帧差、游戏累计时间、固定步次数和插值比例。Scheduler:基于选定的时间域执行延迟任务,不自行读取系统时间。- 生命周期适配:把暂停、挂起和恢复转换为时间服务能够理解的事件。
这样迁移引擎时,通常只需要重新实现 TimeSource 和生命周期桥接层,而不是修改角色、物理、冷却和任务系统。
一帧只走一条时间链
每个活动帧都应先采样一次原始时钟,再从同一个时间快照派生所有结果。不要让物理系统、动画系统和调度器各自读取当前时间,否则同一帧内也可能得到略有差异的时间值。
推荐的执行顺序是:
- 引擎适配层采样原始单调时钟。
TimeService计算本帧时间,并限制异常大的帧差。- 根据固定步累加器得到本帧需要执行的固定更新次数。
- 游戏逻辑执行一次可变步更新,物理等系统执行零到多次固定更新。
Scheduler根据已经推进的游戏累计时间触发到期任务。- 渲染需要时使用固定步剩余量计算插值比例。
暂停和后台恢复也必须进入这条链。普通暂停可以继续采样原始时钟,但令游戏时间不推进;应用真正挂起后没有帧回调,则应在恢复事件中重新建立原始时钟基线。
实现可测试的最小时间服务
下面用 Python 实现完整的最小版本。ManualTimeSource 用于测试,实际接入引擎时只需替换成包装该引擎单调时钟的适配器。调度器依赖游戏累计时间,因此游戏暂停或后台被排除时,延迟任务也会自然停止推进。
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()预期输出
frame1 delta=0.016 fixed=0
timer fired
frame2 delta=0.020 fixed=1
resumed delta=0.020 elapsed=0.0565 秒后台时间没有进入 elapsed,恢复后的帧差仍为 0.020 秒。调度器在游戏累计时间达到 0.03 秒后触发一次任务,固定步次数也完全由同一个时间服务计算。
把暂停策略变成时间域选择
一个全局 paused 往往不够覆盖真实项目。物理和角色逻辑可能需要在菜单打开时暂停,但菜单动画仍要继续;局内技能冷却可能暂停,而离线体力恢复必须继续。解决办法不是到处增加 if paused,而是把消费者放进不同时间域。
最常见的划分是游戏时间、非缩放活动时间和绝对时间。游戏时间受暂停和时间倍率影响;非缩放活动时间不受慢动作影响,但仍排除应用挂起;绝对时间来自墙上时钟或服务器,适合跨会话任务。每个 Scheduler 明确绑定一个时间域,就能避免同一个延迟任务在不同系统里出现相反语义。
只在适配层接触具体引擎
接入新引擎时,不需要重写固定步和调度算法。适配层只完成三件事:提供高精度单调时间、每帧调用一次时间服务、在挂起恢复事件中调用 resume_from_suspend()。真正的引擎 API 名称可以变化,但这三个契约不变。
主循环消费者只读取当前 TimeFrame。固定更新按 fixed_steps 次数执行,普通逻辑读取 delta,渲染插值读取 alpha。这样测试环境还能使用 ManualTimeSource 精确推进 16 毫秒、20 毫秒或数秒,而不依赖真实等待和机器帧率。
用不变量验收跨引擎实现
跨引擎模块最适合按行为而不是 API 做验收。同一组原始时间输入在不同适配器下应产生相同的 delta、固定步次数和累计游戏时间;暂停期间游戏累计时间应保持不变;后台恢复不能把挂起时间灌入下一帧;单帧固定更新次数不得超过配置上限。
调度器也要验证时间域语义。绑定游戏时间的任务在暂停期间不能到期,绑定绝对时间的离线任务则应依据现实经过时间重新计算。只要这些不变量成立,具体项目以后更换引擎、主循环入口或测试框架时,时间相关业务就无需跟着重写。