Blender & Godot 3D 教程 - 2026-06-25 - Godot 4 客户端预测与服务器调和:把网络延迟从「半秒」压到「感觉不到」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# player_input.gd —— 玩家输入 + 状态打包
class_name PlayerInput
extends RefCounted

var sequence: int = 0        # 输入序号,每次操作 +1(核心!调和靠这个对齐)
var move: Vector2 = Vector2.ZERO   # WASD 方向,归一化
var dt: float = 0.016             # 这一帧 dt
var client_time_ms: int = 0       # 客户端发包时间戳(用于 RTT 估算)

static func from_input(sequence: int, move: Vector2, dt: float) -> PlayerInput:
    var pi := PlayerInput.new()
    pi.sequence = sequence
    pi.move = move
    pi.dt = dt
    pi.client_time_ms = Time.get_ticks_msec()
    return pi

 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

# client_player.gd —— 挂在玩家 Node3D 上
class_name ClientPlayer
extends Node3D

const SPEED := 5.0
const SERVER_TICK_HZ := 20.0        # 客户端发包频率 20Hz(够用)
const TICK_INTERVAL := 1.0 / SERVER_TICK_HZ   # 0.05s

@export var peer_id: int = 1
var pending_inputs: Array[PlayerInput] = []  # 待确认输入队列
var last_processed_sequence: int = -1         # 服务器最后确认的序号
var tick_accumulator: float = 0.0

func _physics_process(delta: float) -> void:
    tick_accumulator += delta
    while tick_accumulator >= TICK_INTERVAL:
        tick_accumulator -= TICK_INTERVAL
        _client_tick(TICK_INTERVAL)

func _client_tick(dt: float) -> void:
    # 1. 读输入
    var move := Vector2(
        Input.get_axis("ui_left", "ui_right"),
        Input.get_axis("ui_up", "ui_down")
    )
    
    # 2. **预测:立刻在本地应用输入**
    _apply_move(move, dt)
    
    # 3. 把这次输入打包,加序号,发给服务器
    var input := PlayerInput.from_input(
        _next_sequence(), move, dt
    )
    pending_inputs.append(input)
    
    # 4. 发送到服务器(authority 路由:本地玩家走 rpc 到服务端)
    _send_input_to_server.rpc_id(1, input)   # 1 = 服务端 peer_id

func _apply_move(move: Vector2, dt: float) -> void:
    var dir := Vector3(move.x, 0, move.y).normalized()
    position += dir * SPEED * dt

func _next_sequence() -> int:
    last_processed_sequence += 1
    return last_processed_sequence

 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

# server.gd —— 服务端权威(挂在 Main 节点上)
extends Node

const PROCESS_DELAY_MS := 200
const SPEED := 5.0

var server_player_positions: Dictionary[int, Vector3] = {}   # peer_id → 世界坐标
var input_queue: Array = []  # 模拟延迟:延后处理的输入包

@rpc("any_peer", "call_remote", "reliable")
func _receive_input(input: PlayerInput) -> void:
    # 客户端 rpc_id(1, ...) 把输入送到这里
    input.client_time_ms = Time.get_ticks_msec()
    input_queue.append(input)

func _physics_process(delta: float) -> void:
    # 模拟 200ms 处理延迟
    var now := Time.get_ticks_msec()
    var ready: Array[PlayerInput] = []
    var still_pending: Array = []
    for input in input_queue:
        if now - input.client_ms >= PROCESS_DELAY_MS:
            ready.append(input)
        else:
            still_pending.append(input)
    input_queue = still_pending
    
    # 处理已就绪的输入
    for input in ready:
        var peer_id := multiplayer.get_remote_sender_id()
        _server_apply_move(peer_id, input)
    
    # 把权威位置回推给客户端
    _broadcast_state.rpc(server_player_positions)

func _server_apply_move(peer_id: int, input: PlayerInput) -> void:
    if not server_player_positions.has(peer_id):
        server_player_positions[peer_id] = Vector3.ZERO
    var dir := Vector3(input.move.x, 0, input.move.y).normalized()
    server_player_positions[peer_id] += dir * SPEED * input.dt

@rpc("authority", "call_remote", "reliable")
func _broadcast_state(positions: Dictionary) -> void:
    # 客户端收到后,触发调和(下面 4 节)
    _on_server_state_received(positions)

 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

# 接 3.2 的 client_player.gd
var server_positions: Dictionary[int, Vector3] = {}   # 服务端权威位置
var server_last_sequence: int = -1                     # 服务端最后处理的 sequence

const RECONCILE_THRESHOLD := 0.05   # 位置误差超过 5cm 才回滚,否则不动

func _on_server_state_received(positions: Dictionary) -> void:
    # 注意:这里简化处理,假设只有自己一个玩家
    # 多人场景需要按 peer_id 分别处理(留作练习)
    var server_pos: Vector3 = positions.get(peer_id, position)
    var delta := position.distance_to(server_pos)
    
    if delta > RECONCILE_THRESHOLD:
        # **回滚:跳回服务器真值**
        position = server_pos
        
        # **重放:从服务器确认点之后,所有未确认输入再 apply 一遍**
        var replay_start_idx := _find_input_after(server_last_sequence)
        for i in range(replay_start_idx, pending_inputs.size()):
            _apply_move(pending_inputs[i].move, pending_inputs[i].dt)
    
    # 把已确认的输入从队列里清掉
    _drop_inputs_up_to(server_last_sequence)

func _find_input_after(seq: int) -> int:
    for i in range(pending_inputs.size()):
        if pending_inputs[i].sequence > seq:
            return i
    return pending_inputs.size()

func _drop_inputs_up_to(seq: int) -> void:
    while not pending_inputs.is_empty() and pending_inputs[0].sequence <= seq:
        pending_inputs.pop_front()

 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

# 接 3.2 / 4.1 的 client_player.gd
# 假设有另一个玩家,叫 RemotePlayer
const INTERPOLATION_DELAY_MS := 100   # 比服务器往返延迟略小

var remote_state_buffer: Array = []   # [(timestamp_ms, position), ...]
var remote_visual: Node3D              # 用来显示「插值后的位置」,跟权威位置脱钩

func _on_other_player_state(peer_id: int, pos: Vector3) -> void:
    var now := Time.get_ticks_msec()
    remote_state_buffer.append([now, pos])
    # 只保留最近 500ms 的数据,避免无限增长
    while remote_state_buffer.size() > 1 and now - remote_state_buffer[0][0] > 500:
        remote_state_buffer.pop_front()

func _process(delta: float) -> void:
    if remote_state_buffer.size() < 2:
        return
    # **回溯 100ms 前的两个状态,在它们之间插值**
    var render_time := Time.get_ticks_msec() - INTERPOLATION_DELAY_MS
    var older: Array = remote_state_buffer[0]
    var newer: Array = remote_state_buffer[-1]
    for i in range(remote_state_buffer.size() - 1):
        if remote_state_buffer[i][0] <= render_time and remote_state_buffer[i+1][0] >= render_time:
            older = remote_state_buffer[i]
            newer = remote_state_buffer[i+1]
            break
    # 线性插值
    var t := float(render_time - older[0]) / float(newer[0] - older[0])
    remote_visual.position = older[1].lerp(newer[1], t)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

extends Node3D

func _ready() -> void:
    var choice := await _show_menu()  # 弹个「按 1 启动 server,按 2 启动 client」 UI
    if choice == 1:
        _start_server()
    elif choice == 2:
        _start_client("127.0.0.1", 9999)

func _start_server() -> void:
    var peer := ENetMultiplayerPeer.new()
    peer.create_server(9999, 4)
    multiplayer.multiplayer_peer = peer
    $Server.start()   # 启动 server.gd 的 _physics_process

func _start_client(host: String, port: int) -> void:
    var peer := ENetMultiplayerPeer.new()
    peer.create_client(host, port)
    multiplayer.multiplayer_peer = peer
    # 客户端加载自己的角色
    var me := preload("res://scenes/player.tscn").instantiate()
    me.set_script(preload("res://scripts/client_player.gd"))
    me.peer_id = multiplayer.get_unique_id()  # 自己
    add_child(me)