ARTICLE · 1365137
UE5 网络预测插件:客户端敢先斩后奏,底气藏在一个 8 位帧号里
2021 年,UE5 发布前的那个版本里,引擎仓库多了一个几乎没人讨论的插件:NetworkPrediction。Changelog 里只有一句不起眼的说明,官方文档页面上到现在还挂着"Experimental"的标签。但如果你现在回头翻 UE5.8 的源码,会发现一个事实:Mover 2.0 这个被寄予厚望的"下一代角色移动框架",它的网络同步底层,用的正是当年那个没人看好的插件。
三年时间,从边缘插件到接棒 CharacterMovementComponent 的底座,这中间发生了什么,就是这篇文章要讲清楚的事。
先搞明白:预测这件事为什么非做不可
咱们做联网游戏的人都踩过同一个坑。服务器是权威的,但客户端按下方向键那一刻,如果傻等服务器的位置回包再刷新画面,那就是 100 毫秒的延迟起步——枪口还没抬起来,人已经凉了。
所以客户端必须"先斩后奏":本地先按输入把角色往前挪,等服务器的权威结果回来了,再悄悄对齐。这套动作,教科书上叫客户端预测 + 服务器和解(Client-side Prediction & Reconciliation),圈里直接叫"预测 + 回滚"。
问题在于,UE 过去二十年,这套逻辑是缝在 CharacterMovementComponent 里的。位置预测、网络修正、模拟代理的插值,三件事搅在一个类里,你想换一种移动方式(比如载具、飞行、爬墙),要么改引擎,要么自己从头写一套。这也是为什么 Unity 那边 Netcode、Godot 那边各有各的土办法,谁也不服谁。
NetworkPrediction 想干的事,就是把这套"缝"出来的逻辑,抽成一个通用框架:你只管定义你的状态和模拟规则,预测、回滚、序列化、平滑,全部交给引擎。
三种状态:把"我按了什么"和"我变成了什么"分开
理解整个框架,先看一个最核心的类型定义。翻源码 NetworkPredictionStateTypes.h,能看到这样一段:
// 状态类型的三分类:输入 / 同步 / 辅助enum classENetworkPredictionStateType : uint8{ Input, // 输入命令:这一帧玩家按下了什么 Sync, // 同步状态:必须全网一致的东西 Aux // 辅助状态:只影响表现、不影响判定};// 用户自定义三个状态类型的模板容器template<typename InInputCmd=void, typename InSyncState=void, typename InAuxState=void>struct TNetworkPredictionStateTypes{using InputType = InInputCmd; // 例如:前进键、朝向、是否开火using SyncType = InSyncState; // 例如:位置、速度、朝向(要预测的)using AuxType = InAuxState; // 例如:动画混合权重、枪口火花};这三分类是整个框架的地基,值得多说两句。
**Input(输入命令)**是"我这一帧想干什么"。它从客户端单向流到服务器,服务器不预测它,只是按顺序消费它。**Sync(同步状态)**是"我此刻在哪儿、多快",它是预测和回滚的主角——客户端猜一个,服务器算一个,两边不一致就得修正。**Aux(辅助状态)**最容易被忽略,但它解决了 CMC 时代最烦人的一个问题:有些状态根本不该被预测,比如动画播放到第几帧、粒子特效的随机种子,这些让服务器和客户端各跑各的就行,硬要同步反而浪费带宽。
把这三者分开,你才真正理解为什么"预测"不是一个模糊概念,而是明确界定了什么数据走什么通道。
ModelDef:一个模板,装配出一整套预测系统
状态类型定义好了,下一个问题是:引擎怎么知道该拿什么去跑模拟、拿什么去接收输出?答案是另一个模板,NetworkPredictionModelDef.h 里的 FNetworkPredictionModelDef:
structFNetworkPredictionModelDef{// 用户定义的三个状态类型(Input/Sync/Aux)using StateTypes = TNetworkPredictionStateTypes<void,void,void>;// Simulation:真正跑模拟 tick 的对象// 例如一段纯函数式的移动逻辑using Simulation = void;// Driver:从预测系统拿输出的对象(通常是 Actor 或 Pawn)using Driver = void;staticconst TCHAR* GetName(){ returnnullptr; }};你把它当成一个"装配车间"。往里填三样东西:你的状态类型、你的模拟对象、你的驱动对象。填完之后,引擎用模板元编程帮你把预测、回滚、序列化这些脏活累活全部自动生成。
这里有个反直觉的点值得拎出来讲:Simulation 和 Driver 是分离的。Simulation 负责"纯计算",理想情况下它不碰任何 UObject、不读任何全局状态,是个纯粹的函数——输入一个 Input 和当前 Sync,输出下一个 Sync。为什么非要这么"洁癖"?因为回滚的本质是"时光倒流重新算一遍",如果模拟里混进了不可控的东西(比如读当前帧时间、读内存地址),重算出来的结果就不确定,预测就崩了。这个设计约束,是整个框架能跑起来的隐秘前提。
固定步长:确定性从哪来
预测要成立,有一个数学上的硬要求:同样的输入序列,必须得到同样的输出序列。这在计算机科学里叫确定性(Determinism)。
但游戏引擎的帧率是波动的——60 帧、30 帧、卡一下掉到 12 帧。如果每次 tick 用真实帧间隔去积分物理,浮点运算的舍入误差会在不同帧率下跑出不同结果,客户端猜的位置和服务器算的位置就永远对不上。
NetworkPrediction 的答案是固定步长模拟。翻 NetworkPredictionWorldManager.cpp,能看到核心的 tick 循环:
// 固定步长 tick 循环(节选自 BeginNewSimulationFrame_Internal)// FixedStepRealTimeMS = (1 / FixedTickFrameRate) * 1000,默认 60Hz → 约 16.67msFixedTickState.UnspentTimeMS += fEngineFrameDeltaTimeMS;// 攒够一个固定步长就 tick 一次,多退少补,绝不按真实帧间隔积分while ((FixedTickState.UnspentTimeMS + KINDA_SMALL_NUMBER) >= FixedTickState.FixedStepDilatedRealTimeMS){ FixedTickState.UnspentTimeMS -= FixedTickState.FixedStepDilatedRealTimeMS;// 拿一个固定步长的时间片 FNetSimTimeStep Step = FixedTickState.GetNextTimeStep();// 先生产这一帧的输入(本地 + 远端)for (TUniquePtr<IInputService>& Ptr : Services.FixedInputLocal.Array) Ptr->ProduceInput(FixedTickState.FixedStepMS);// 再跑这一帧的模拟for (TUniquePtr<ILocalTickService>& Ptr : Services.FixedTick.Array) Ptr->Tick(Step, ServiceStep);}看到那个 while 循环了吗?它用一个"未花完的时间"累加器,把波动的引擎帧率,重新切成一份份恒定 16.67 毫秒的模拟步。这一帧引擎跑了 33 毫秒?那就 tick 两次。只跑了 8 毫秒?那就先攒着,等下一次。
默认固定步长是 60Hz(FixedTickFrameRate = 60,见 NetworkPredictionSettings.h)。这个数字不是拍脑袋定的——它是"手感延迟"和"确定性精度"的折中:步长越大,确定性越稳但手感越肉;步长越小,手感越跟手但浮点误差越容易累积。
回滚:当服务器的真相到达,本地怎么自证清白
预测是"先斩",回滚是"后奏"。具体流程是这样的:客户端在第 100 帧预测角色往前跑了 3 米,但服务器因为别人撞了你一下,权威结果是只跑了 2.5 米。当服务器的这个结果(带着帧号)传回客户端时,客户端得把本地从第 100 帧到现在重演一遍,用服务器的 2.5 米作为新起点。
这个"从哪一帧开始重演"的判断,就在 ReconcileSimulationsPostNetworkUpdate_Internal 里:
// 有没有人需要回滚?找出最早需要回滚的那一帧int32 RollbackFrame = INDEX_NONE;for (TUniquePtr<IFixedRollbackService>& Ptr : Services.FixedRollback.Array){const int32 ReqFrame = Ptr->QueryRollback(&FixedTickState);if (ReqFrame != INDEX_NONE) { RollbackFrame = (RollbackFrame == INDEX_NONE ? ReqFrame : FMath::Min(RollbackFrame, ReqFrame)); }}// 从 RollbackFrame 开始,一路重新模拟到 PendingFrameif (RollbackFrame < FixedTickState.PendingFrame){// ... 逐帧重新 ProduceInput + Tick,直到追上当前帧}关键在 QueryRollback 返回的 RollbackFrame——它不是"当前帧",而是所有需要回滚的服务里最早的那一帧。取最小值,是为了保证一次回滚到位,而不是回滚一半、发现还得再滚一次。
而"要不要回滚"这个判断本身,走的是 ShouldReconcile 这套模板分发(NetworkPredictionDriver.h)。默认实现是直接问你定义的那个 Sync 状态:Predicted->ShouldReconcile(Authority)。你自己决定"预测值和权威值差多少才算需要修正"——比如位置差了 2 厘米就算了,别为了一根头发丝的距离打断玩家手感。
那个 8 位帧号:带宽里的极限抠门
回滚依赖"帧号"来对齐客户端和服务器的时间线。但帧号是个 32 位整数,每帧都传完整值太浪费了。翻 NetworkPredictionSerialization.h,能看到一段让做网络的人会心一笑的抠门操作:
structFNetworkPredictionSerialization{// 帧号用多少位来序列化?只在客户端<->服务器通信时生效enum { NUM_BITS_FRAME = NETSIM_NETCONSTANT_NUM_BITS_FRAME }; // = 8// 8 位能表示的最大值enum { MAX_FRAME_WRITE = 1 << NUM_BITS_FRAME }; // = 256// 超过这个阈值,帧号就会 wrap 错位// 8 位 → 128 帧 ≈ 60fps 下约 2 秒enum { FRAME_ERROR_THRESHOLD = MAX_FRAME_WRITE / 2 };// 把 32 位帧号压缩成 8 位,靠"相对帧"解出真实值static int32 SerializeFrame(FArchive& Ar, int32 Frame, int32 RelativeFrame){if (Ar.IsSaving()) { ((FNetBitWriter&)Ar).WriteIntWrapped(Frame, MAX_FRAME_WRITE);return Frame; }returnMakeRelative(((FNetBitReader&)Ar).ReadInt(MAX_FRAME_WRITE), RelativeFrame, MAX_FRAME_WRITE); }};看懂了吗?它不传绝对帧号,只传"相对上一帧的偏移"。因为网络包是有序到达的,接收方只要知道"这帧比我上次收到的帧差了 N 帧",就能还原出绝对帧号。32 位砍成 8 位,省下 75% 的帧号带宽。
代价就是那句注释里写的:如果连续 128 帧(约 2 秒)的包全丢了,帧号就 wrap 错位了。这是一个刻意的工程取舍——用"极端丢包下会错位"换"正常情况下的带宽节省"。做网络的人看到这种代码,往往会心一笑:这才是真正的"够用就行"。
和几种方案放一起比一比
预测回滚不是 NetworkPrediction 的专利,把它和几条常见路线摆一起,各自边界就清楚了:
一眼能看出来的结论是:CMC 赢在"开箱即用",但输在"只能管胶囊体移动";自研赢在"想干嘛干嘛",但输在"回滚逻辑你得自己写对";NetworkPrediction 卡在中间——它把最难写对的回滚和固定步长替你做了,代价是你得先学会它的模板那套。
最小骨架:一个能跑的 ModelDef 长这样
概念讲完了,落到代码上。一个最小可用的预测模型,骨架大概长这样(基于 NetworkPredictionExtras 里的 CharacterMotion 示例简化):
// 1. 输入命令:这一帧想干什么structFMyInputCmd{ FVector MoveInput; // 方向输入bool bJump; // 是否跳跃// 必须实现:输入怎么序列化voidNetSerialize(FArchive& Ar){ Ar << MoveInput << bJump; }};// 2. 同步状态:必须一致、要被预测的东西structFMySyncState{ FVector Position; // 位置 FVector Velocity; // 速度voidNetSerialize(FArchive& Ar){ Ar << Position << Velocity; }// 关键:定义"差多少才需要回滚"boolShouldReconcile(const FMySyncState& Authority)const{return FVector::DistSquared(Position, Authority.Position) > 4.0f; // >2cm }};// 3. 模拟:纯函数式的"输入+当前态 → 下一态"structFMySimulation{voidSimulationTick(const FNetSimTimeStep& Step,const FMyInputCmd& Input,const FMySyncState& In, FMySyncState& Out){ Out.Velocity = Input.MoveInput * 600.0f; // 加速度 Out.Position = In.Position + Out.Velocity * Step.StepSeconds; }};// 4. 装配:填进 ModelDef 三件套structFMyModelDef : public FNetworkPredictionModelDef{NP_MODEL_BODY();using StateTypes = TNetworkPredictionStateTypes<FMyInputCmd, FMySyncState, void>;using Simulation = FMySimulation;using Driver = AMyPawn; // 你的 Actor};填完这个,引擎就能自动帮你:客户端本地预测、服务器权威模拟、帧号对齐、回滚重演、状态序列化。你要写的核心业务逻辑,其实只有 SimulationTick 那几行——剩下的都是框架的活。
这就是它和 CMC 最大的分野:CMC 把"移动逻辑"和"预测机制"焊死,NetworkPrediction 把两者拆开,你只写前者。
延伸到哪:这条路线正在吞掉更多地盘
理解 NetworkPrediction,其实是在理解一条更大的技术路线——确定性模拟 + 回滚网络。
这条路线最极端的玩家是格斗游戏界的 GGPO。格斗游戏帧数严苛到"1 帧输入延迟"都能被职业选手感知,所以 GGPO 走的是纯回滚:不预测,双方各自往前跑,一旦输入不同步就整局回滚重演。NetworkPrediction 的"回滚重演"和它是同一个原理,只是粒度不同——一个回滚角色,一个回滚整局。
引擎内部,Mover 2.0 是最大的受益者。它把移动模式做成可插拔的状态机,网络层直接坐在 NetworkPrediction 上,等于白捡了一套预测回滚。而 Chaos Physics 那边,也有一派思路主张物理仿真走确定性固定步长,方便做"物理预测回滚"——虽然目前还主要在单机预测(Predicted Physics)范围。
再往外看,Unity 的 Netcode for Entities 也在玩同一套确定性 ECS 模拟,只是它绑定在 DOTS 上。三家的底层数学其实是相通的:确定性是预测的入场券,固定步长是确定性的入场券。 谁先把这条路走通、走顺,谁就抢到下一代联网游戏的技术心智。
收个尾
这篇文章我翻完了 NetworkPrediction 的 ModelDef、StateTypes、固定步长循环、回滚查询和帧号序列化这五块核心源码。想验证的话,UE5.8 的 Engine/Plugins/Runtime/NetworkPrediction/ 目录全都在,顺着我标的文件名找,代码都在那儿。
最后抛个问题——NetworkPrediction 解决了"单个角色怎么预测回滚",但有一个更硬的问题它没碰:两个玩家互相碰撞时,谁的预测算数? 双方都预测自己没被撞开,结果服务器一裁决,两边同时回滚,画面一起抖一下。这种"预测冲突"是回滚网络的下一个坎,目前连 GGPO 都没能优雅解决。这个问题,我打算后面找一篇拆。
如果你也在折腾联网游戏的同步,或者被 CMC 的预测坑过,点个"在看"让更多同行看到。这个号每周拆一个 UE5 底层系统,从源码讲到能跑的代码,关注了不走丢。还想看哪个子系统,评论区点名。















































































