服务器倒带

字数统计: 2.5k字   |   阅读时长≈ 10分

服务器倒带(Server Rewind)主要用于解决多人在线游戏中，由于网络延迟导致的客户端与服务器表现不一致问题。该技术特别适用于第一人称射击(FPS)和动作类游戏，能够在不牺牲响应性的前提下保证游戏的公平性。

服务器倒带算法的实现思路

在服务器上保存玩家一段时间内的历史状态信息（位置、旋转等），当收到客户端的命中请求时，根据客户端上报的时间戳将目标玩家的状态回滚到对应时刻，重新进行碰撞检测以验证命中有效性。

所以我们需要如下结构体：

1
2
3
4
5
6
7
8
9
struct FHistoryCache
{
public:
    float Time; // 运行时间
    FVector Loction; // 位置
    FRotator Rotation; // 旋转

    static void Create(...); // 创建方法
};

保存的时间

在这个结构体中我们保存了游戏的运行时间，UE给我们提供了游戏自开始一共运行了多少时间，我们可以很容易的获取并将其保存到缓存中，但需要注意的是：这个时间会因为客户端服务端的差异而存在不同，所以我们需要对时间进行校准。

时间校准的方法

我们可以向服务器请求一次当前服务器的运行时间并将客户端时间一并上报，当服务器收到客户端的请求后便将服务器运行时间于客户端上报的时间一并下发给客户端，这样便可以计算出服务器的运行时间。

具体过程：

  1. 在需要校准时间时将客户端的时间上报给服务器
  2. 服务器收到客户端上报的时间后将服务器的时间于客户端的时间一并发送给客户端
  3. 客户端收到后可以根据上报时的客户端时间计算出RTT，这里假设客户端服务端进行一次通信所花费的时间相同，即服务端收到客户端上报的时间于客户端收到服务器下发的数据所花费的时间相同，就可以计算出客户端在收到服务器下发数据时的运行时间

具体实现

我们将实现放在玩家的控制器中，继承APlayerController类。

ASGPlayerController的头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class ASGPlayerController : public APlayerController
{
public:
    ASGPlayerController();

    virtual void BeginPlay() override;

    virtual void Tick(float DeltaSeconds) override;

    /** 客户端上报服务器 */
    UFUNCTION(Server, Reliable)
    void Server_ReqServerTime(float ClientTime);

    /** 服务器响应客户端 */
    UFUNCTION(Client, Reliable)
    void Client_RspServerTime(float ServerTime, float ClientTime);

    UFUNCTION(BlueprintPure)
    float GetServerTime();
protected:
    /** 客户端服务端运行时间的差值 */
    float DeltaTimeInCS = 0.0f;

    /** 检查时间 */
    float CheckTime = 0.0f;

    /** RTT */
    float RTT = 0.0f;

    /** 检查间隔 */
    UPROPERTY(EditAnywhere)
    float CheckInterval = 4.0f;
};

ASGPlayerController的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
ASGPlayerController::ASGPlayerController()
{
    // 在Tick中决定校准运行时间的时机
    PrimaryActorTick.bCanEverTick = true;
};

ASGPlayerController::BeginPlay()
{
    Super::BeginPlay();

    // 客户端玩家进入游戏时校准一次时间
    if(!HasAuthority())
    {
        Server_ReqServerTime(GetWorld()->GetTimeSeconds());
    }
}

ASGPlayerController::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);

    // 只在客户端校准
    if(!HasAuthority())
    {
        if(CheckTime > CheckInterval)
        {
            CheckTime = 0.0f;
            Server_ReqServerTime(GetWorld()->GetTimeSeconds());
        }
        CheckTime += DeltaSeconds;
    }
}

ASGPlayerController::Server_ReqServerTime_Implementation(float ClientTime)
{
    // 服务器收到后将服务器运行时间于客户端上报的时间一并下发给客户端
    Client_RspServerTime(GetWorld()->GetTimeSeconds(), ClientTime);
}

ASGPlayerController::Client_RspServerTime_Implementation(float ServerTime, float ClientTime)
{
    RTT = GetWorld()->GetTimeSeconds() - ClientTime;
    // 当前时刻服务器的实际运行时间
    ServerTime += RTT * 0.5;
    // 客户端与服务器运行时间的差值
    DeltaTimeInCS = GetWorld()->GetTimeSeconds() - ServerTime;
}

float ASGPlayerController::GetServerTime()
{
    // 如果是服务器直接返回世界时间
    if (HasAuthority())
    {
        return GetWorld()->GetTimeSeconds();
    }
    // 否则返回客户端时间减去差值
    return GetWorld()->GetTimeSeconds() - DeltaTimeInCS;
}

位置与旋转

为了便于实现，我们只在玩家身上挂载一个UBoxComponent, 将这个BoxComponent用作玩家回滚后的击中判定：

1
2
3
4
5
6
7
8
class ASGCharacter : public ACharacter
{
    // ...

public:
    UPROPERTY(EditAnywhere)
    TObjectPtr<UBoxComponent> BoxComponent;
};

倒带过程

我们使用一个组件来承担倒带的主要逻辑，主要实现功能为：

  1. 记录一段时间内玩家的历史位置信息
  2. 根据上报的信息回滚玩家位置并确认击中
  3. 使用循环数组保存信息以减少开销
  4. 需要提供可视化调试

USGLagComponent的头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/** 历史缓存的结构体，存储每帧玩家的位置以及时间信息 */
USTRUCT(BlueprintType)
struct FSGHistoryFrameCache
{
	GENERATED_BODY()
public:
	/** 缓存的时间 */
	float Time;

	/** 位置信息 */
	FVector BoxLocation;

	/** 旋转信息 */
	FRotator BoxRotation;
	
    /** 创建方法 */
	static void CreateHistoryFrame(ASGCharacter* Character, FSGHistoryFrameCache& CurrentFrame)
	{
		if (IsValid(Character))
		{
			CurrentFrame.Time = Character->GetWorld()->GetTimeSeconds();
			CurrentFrame.BoxLocation = Character->GetHitBoxComponent()->GetComponentLocation();
			CurrentFrame.Rotation = Character->GetHitBoxComponent()->GetComponentRotation();
		}
	}
};

class USGLagComponent : public UActorComponent
{
public:	
	
	USGLagComponent();

	virtual void BeginPlay() override;

	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

    /** 检查是否被击中 */
	UFUNCTION(BlueprintCallable)
	bool CheckHit(FVector& StartLocation, FVector& EndLocation, float HittedTime);

protected:
    /** 尝试保存每帧的回滚信息 */
	void TrySaveFrame();

    /**
    * 根据目标时间查找历史帧并进行线性插值
    * @param TargetTime 目标时间（服务器时间）
    * @param bFind 输出参数，是否找到合适帧
    * @param FrameCache 输出参数，插值后的帧数据
    */
	void FindFrame_Liner(float TargetTime, bool& bFind, FSGHistoryFrameCache& FrameCache);
	
    /** 玩家 */
	TWeakObjectPtr<ASGCharacter> OwnerCharacter;

    /** 历史帧缓存列表 */
	TArray<FSGHistoryFrameCache> HistoryFrameCache;
	
    /** 保存的有效帧数 */
	UPROPERTY(EditAnywhere, BlueprintReadOnly)
	int32 ValidTickNum = 64;
    
    /** 用于记录保存的帧号，为了与数组下标对应，从-1开始记录 */
	int32 CurrentTickNum = -1;
	
    /** 是否开启调试 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bDebug = false;
};

USGLagComponent的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
USGLagComponent::USGLagComponent()
{
	PrimaryComponentTick.bCanEverTick = true;
}

USGLagComponent::BeginPlay()
{
	Super::BeginPlay();
}

USGLagComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

    // 尝试保存每帧的回滚信息
	TrySaveFrame();
}

bool USGLagComponent::CheckHit(FVector& StartLocation, FVector& EndLocation, float HittedTime)
{
    // 前置检查
	if (!OwnerCharacter.IsValid() || !GetWorld())
	{
		return false;
	}

    UBoxComponent* HittedBox = OwnerCharacter->GetHitBoxComponent();
    if (!IsValid(HittedBox))
    {
        return false;
    }
	
	bool bFind = false;
	FSGHistoryFrameCache FrameCache;
	FindFrame_Liner(HittedTime, bFind, FrameCache);
	if (bFind == false)
	{
		return false;
	}

	// 获取原先的位置并记录

	FVector OriginLocation = HittedBox->GetComponentLocation();
	FRotator OriginRotation = HittedBox->GetComponentRotation();
	
	// 将碰撞体移动到被击中的位置
	HittedBox->SetWorldLocation(FrameCache.BoxLocation);
	HittedBox->SetWorldRotation(FrameCache.BoxRotation);
	HittedBox->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
	
	// 专门用来进行回滚检测的碰撞预设
	FHitResult HitResult;
	bool bHit = GetWorld()->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, ECC_GameTraceChannel1);

	// 关闭碰撞并且恢复原先的位置
	HittedBox->SetCollisionEnabled(ECollisionEnabled::NoCollision);
	HittedBox->SetWorldLocation(OriginLocation);
	HittedBox->SetWorldRotation(OriginRotation);

    // 在调试模式下绘制检测过程
#if WITH_EDITOR
    if (bDebug == true && !OwnerCharacter->HasAuthority())
    {
    // 绘制射线
    DrawDebugLine(GetWorld(), StartLocation, EndLocation, 
                    bHit ? FColor::Green : FColor::Green, false, 5.0f);

    // 绘制碰撞体在回滚时刻的位置
    DrawDebugBox(GetWorld(), FrameCache.BoxLocation,
                    HitBox->GetScaledBoxExtent(),
                    FQuat(FrameCache.BoxRotation), 
                    bHit ? FColor::Green : FColor::Red, false, 5.0f);
    }
#endif

	return bHit;
}

void USGLagComponent::TrySaveFrame()
{
    if(!OwnerCharacter.IsValid())
    {
        OwnerCharacter = Cast<ASGCharacter>(GetOwner());
        return;
    }

	int32 CurrentFrameSize = HistoryFrameCache.Num();
    // 计算要保存的帧索引
	int32 SavedFrameIndex = (CurrentTickNum + 1) % ValidTickNum;
	// 如果当前数量小于最大数量则直接添加
	if (CurrentFrameSize < ValidTickNum)
	{
		FSGHistoryFrameCache CurrentFrameCache;
		FSGHistoryFrameCache::CreateHistoryFrame(OwnerCharacter.Get(), CurrentFrameCache);
		HistoryFrameCache.Add(CurrentFrameCache);
	}
	else
	{
		// 否则循环更新
		FSGHistoryFrameCache::CreateHistoryFrame(OwnerCharacter.Get(), HistoryFrameCache[SavedFrameIndex]);
	}
	CurrentTickNum = SavedFrameIndex;

    // 调试功能
#if WITH_EDITOR
    if(bDebug == true && !OwnerCharacter->HasAuthority())
    {
        // 将调试Box绘制出来
        DrawDebugBox(GetWorld(), HistoryFrameCache[CurrentTickNum].BoxLocation,
		             OwnerCharacter->GetHitBoxComponent()->GetScaledBoxExtent(),
		             FQuat(HistoryFrameCache[CurrentTickNum].BoxRotation), FColor::Red, false, ValidTickNum * GetWorld()->GetDeltaSeconds());
    }
#endif
}

void USGLagComponent::FindFrame_Liner(float TargetTime, bool& bFind, FSGHistoryFrameCache& FrameCache)
{
bFind = false;
	
	// 获取有效帧的数量和范围
	int32 TotalValidFrames = HistoryFrameCache.Num();
	int32 StartIndex = 0;
	int32 EndIndex = TotalValidFrames - 1;

	// 如果已满，调整起始和结束索引
	if (TotalValidFrames >= ValidTickNum)
	{
		StartIndex = (CurrentTickNum + 1) % ValidTickNum;
		EndIndex = CurrentTickNum;
	}
	
	// 检查目标时间是否在有效范围内
	float FirstTime = HistoryFrameCache[StartIndex].Time;
	float LastTime = HistoryFrameCache[EndIndex].Time;

	if (TargetTime < FirstTime || LastTime < TargetTime)
	{
		bFind = false;
		return;
	}

	// 查找目标时间所在的时间段
	int32 PreIndex = -1;
	int32 NextIndex = -1;

	// 遍历查找合适的时间段
	for (int32 i = 0; i < TotalValidFrames; i++)
	{
		int32 CurrentIndex = (StartIndex + i) % ValidTickNum;
		float CurrentTime = HistoryFrameCache[CurrentIndex].Time;
        
		if (CurrentTime <= TargetTime)
		{
			PreIndex = CurrentIndex;
		}
		else
		{
			NextIndex = CurrentIndex;
			break;
		}
	}

	// 如果Pre没更新过，则说明是第一帧
	if (PreIndex == -1)
	{
		FrameCache = HistoryFrameCache[StartIndex];
		bFind = true;
		return;
	}

	// 如果Next没更新过，则说明是最后一帧
	if (NextIndex == -1)
	{
		FrameCache = HistoryFrameCache[EndIndex];
		bFind = true;
		return;
	}

	float PreTime = HistoryFrameCache[PreIndex].Time;
	float NextTime = HistoryFrameCache[NextIndex].Time;

	if (FMath::IsNearlyEqual(PreTime, NextTime))
	{
        bFind = false;
		return;
	}
	
	// 长度大于2，进行插值
	FVector PreLocation = HistoryFrameCache[PreIndex].BoxLocation;
	FVector NextLocation = HistoryFrameCache[NextIndex].BoxLocation;
	FRotator PreRotation = HistoryFrameCache[PreIndex].BoxRotation;
	FRotator NextRotation = HistoryFrameCache[NextIndex].BoxRotation;
	
	// 进行线性插值
	float Distance = NextTime - PreTime;
	float InterpSpeed = (TargetTime - PreTime) / Distance;
	FrameCache.BoxLocation = FMath::VInterpTo(PreLocation, NextLocation, 1.0f, InterpSpeed);
	FrameCache.BoxRotation = FMath::RInterpTo(PreRotation, NextRotation, 1.0f, InterpSpeed);
	bFind = true;
}

总结

工作流程

以下mermaid展示了整个服务器倒带的工作流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
graph LR
    A[客户端开始射击] --> B[本地碰撞检测]
    B --> C[检测到命中]
    C --> D[上报服务器<br>包含命中时间]
    
    E[服务器接收命中请求] --> F[获取目标玩家LagComponent]
    F --> G[调用CheckHit函数]
    G --> H[FindFrame_Liner查找历史帧]
    H --> I{是否找到合适帧?}
    I -->|是| J[回滚碰撞体位置]
    I -->|否| K[返回命中失败]
    J --> L[执行碰撞检测]
    L --> M[恢复碰撞体位置]
    M --> N[返回检测结果]
    
    O[服务器Tick更新] --> P[TrySaveFrame保存帧]
    P --> Q{缓存是否已满?}
    Q -->|否| R[添加新帧]
    Q -->|是| S[循环覆盖旧帧]
    R --> T[更新CurrentTickNum]
    S --> T
    
    U[时间校准流程] --> V[客户端请求校准]
    V --> W[服务器响应时间]
    W --> X[客户端计算DeltaTimeInCS]
    
    subgraph 数据存储
        Y[HistoryFrameCache<br>历史帧缓存]
        Z[CurrentTickNum<br>当前帧索引]
    end
    
    H --> Y
    P --> Y
    T --> Z

mermaid网站链接：https://mermaid-live.nodejs.cn/edit#pako:eNptlOtOGkEUx1-FzGc0IEKVNDYV661oVahWB9OsMApRdsm629SiidrWO2iLt1ZrxXprrYiNiimiL8PM4lt0mFm7mDgfNjtzfufMOf85M1HglwIIOMGALESCJneHTzTR8RTi1A6ZyWhHJ_hqHB_M4_QHPJ3tNZWV1ZhqIdn8jTfT2k6afN4iP8bJ-Xwv96tlgAvyRTyTxp9y-ctj3epi1jqYv5wjc3tkM4bnkvjL4eM-uQYvfMRLR5wmaxe3a2e6D_8-g_9pEt8jyxecLJxkyOkkz6oeFuIZvLiqbaTI9rQW_4lTF25hwCWFI5KIREWPV8_gBlhIv9eWD11B5B9sDCl4OkdW0jrSwJBGWB8SA_WyEEav3SERyeT7Hpm9xvEpvPgHXx7ocCODm6Jk_QQv7RcBWvTSzO34JGWejHGoqQiNUmTU1AzxxhbJfuXi5XOJfC6m5VK9pSANNGp6Dgs3y5TlleLd08LZnk41sz3dkMweFJILDxyDmwEtkEzs4N3Yw1u1MKZV34W7a9kE2dq8p_wLQ3lvyD9INs7Iapor3ga98ohHeIOYSPmbb_h43RCmjTHtUe0qQde5PDjzh2STd6q0G8V2QJLJ4rltGtuI0G6o5oH4-pcWPynsT2kbq2TtwKA62D5eyDNzqbJMD7uYaqsa1hEPR0rLegl5l5HtJJ6eIucT2uE8r6rTaH3eXhzRQ3UypssQBSdi-O_yvZbtYsyrkjippJZaq0NDiuANhVGT6PLc03hY7ePXj_YgiaWKMk4eclNxdMPG0LAiySNMZ5fgDyJ2Ze46kSvcazj0wPsyMDqXwLOxIn22g69WdBqJgdJEeDN3lx6gPvGySQ8wgzCSw0IoQJ-MaNHkA0oQhZEPOOlvAPUL6pDiAz5xjKKCqkieEdEPnIqsIjOQJXUgCJz9wtAwnamRgKCgupBAaw_fIRFB7JGk0ilwRsFb4CxzVNrK7RXWKpvtUaW1oqraDEaA02qrLrdbHBWOaovVYqmwVTnGzOAdC2Att9urLRaHjQ671Wqz28z0kSsmridDa0eyS1JFBTjtY_8AjNc7_w

调试与优化

如果要模拟高延迟的情况，可以选择在DefaultEngine.ini中添加:

1
2
[PacketSimulationSettings]
PktLag = 500

可修改PktLag这个值来改变测试的延迟

依然可优化的方案：

  1. 如果保存的历史帧非常长的话使用遍历会影响性能，可以使用二分查找来优化
  2. 在进行回滚检测时，可以使用更细致的检测方案

参考

https://zhuanlan.zhihu.com/p/690661788
https://zhuanlan.zhihu.com/p/1929071131677143054

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true


个人简介:
大学生一枚，想要从事游戏开发,
希望能做出自己的游戏

主要涉及技术：
UE4、Unity2D、C++