夜雨聆风学习资料网

ARTICLE · 1365137

UE5 网络预测插件:客户端敢先斩后奏,底气藏在一个 8 位帧号里

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 的专利,把它和几条常见路线摆一起,各自边界就清楚了:

维度
NetworkPrediction
CMC 内建预测
自研回滚
Iris 复制
定位
通用预测框架
角色移动专用
项目定制
通用状态复制
预测粒度
任意自定义模拟
胶囊体移动
自由
不预测,只同步
回滚
内建,帧级
内建,位置级
手写
无
固定步长
60Hz 恒定
依赖引擎 tick
看实现
不涉及
状态分类
Input/Sync/Aux
位置/速度混在一起
看实现
属性/引用
上手成本
中(要学模板)
低(开箱即用)
高(全自己写)
中
成熟度
Experimental 但已撑起 Mover
稳定但难扩展
看团队
成熟

一眼能看出来的结论是: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 底层系统,从源码讲到能跑的代码,关注了不走丢。还想看哪个子系统,评论区点名。

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料