1
// 核心思想：不等服务器，客户端先按输入移动
2
class PredictionSystem {
3
    struct InputRecord {
4
        uint32_t seq;        // 输入序号
5
        Input input;         // 玩家输入
6
        Vec3 predicted_pos;  // 预测后的位置
7
    };
8

9
    std::deque<InputRecord> _pending_inputs;
10
    Vec3 _position;
11

12
public:
13
    void onLocalInput(const Input& input) {
14
        // 1. 立即应用输入（预测）
15
        _position = applyInput(_position, input);
16

17
        // 2. 发送给服务器
18
        uint32_t seq = sendToServer(input);
19

20
        // 3. 保存到待确认队列
21
        _pending_inputs.push_back({seq, input, _position});
22
    }
23

24
    void onServerState(uint32_t ack_seq, Vec3 server_pos) {
25
        // 4. 移除已确认的输入
26
        while (!_pending_inputs.empty() &&
27
               _pending_inputs.front().seq <= ack_seq) {
28
            _pending_inputs.pop_front();
29
        }
30

31
        // 5. 和解 (Reconciliation)
32
        _position = server_pos;
33
        for (auto& record : _pending_inputs) {
34
            _position = applyInput(_position, record.input);
35
            record.predicted_pos = _position;
36
        }
37
    }
38
};

1
// 简化的延迟补偿
2
class LagCompensation {
3
    struct Snapshot {
4
        uint32_t tick;
5
        std::vector<PlayerState> players;
6
    };
7

8
    std::deque<Snapshot> _history;  // 保存过去 1 秒的快照
9

10
public:
11
    void saveSnapshot(uint32_t tick, const std::vector<PlayerState>& states) {
12
        _history.push_back({tick, states});
13
        // 只保留 1 秒内的快照
14
        while (_history.size() > 128) _history.pop_front();
15
    }
16

17
    bool checkHit(uint32_t shooter_tick, const Ray& shot) {
18
        // 找到射击时刻的快照
19
        auto it = std::find_if(_history.begin(), _history.end(),
20
            [shooter_tick](const Snapshot& s) { return s.tick >= shooter_tick; });
21

22
        if (it == _history.end()) return false;
23

24
        // 在那个时刻的状态中做射线检测
25
        for (auto& player : it->players) {
26
            if (rayIntersectsBox(shot, player.hitbox)) {
27
                return true;  // 命中！
28
            }
29
        }
30
        return false;
31
    }
32
};

1
// 实体插值系统
2
struct InterpolationBuffer {
3
    struct State {
4
        float time;
5
        Vec3 position;
6
        Quat rotation;
7
    };
8

9
    std::deque<State> _buffer;
10
    float _interp_delay = 0.1f;  // 100ms 的插值延迟
11

12
    void addState(float time, Vec3 pos, Quat rot) {
13
        _buffer.push_back({time, pos, rot});
14
        while (_buffer.size() > 20) _buffer.pop_front();
15
    }
16

17
    std::pair<Vec3, Quat> getInterpolated(float current_time) {
18
        float render_time = current_time - _interp_delay;
19

20
        // 找到 render_time 前后的两个状态
21
        for (size_t i = 0; i + 1 < _buffer.size(); ++i) {
22
            if (_buffer[i].time <= render_time &&
23
                _buffer[i + 1].time >= render_time) {
24
                float t = (render_time - _buffer[i].time) /
25
                          (_buffer[i + 1].time - _buffer[i].time);
26
                return {
27
                    lerp(_buffer[i].position, _buffer[i + 1].position, t),
28
                    slerp(_buffer[i].rotation, _buffer[i + 1].rotation, t)
29
                };
30
            }
31
        }
32
        // 没有足够数据 → 外推
33
        auto& last = _buffer.back();
34
        return {last.position, last.rotation};
35
    }
36
};

1
1. 量化 (Quantization)
2
   float 位置 (32bit) → 16bit 定点数
3
   浮点角度 (32bit) → 8bit (256 个方向足够了)
4

5
2. 位打包 (Bit Packing)
6
   bool 用 1 bit 而不是 1 byte
7
   HP/MP 用 10 bit（0~1023）而不是 32 bit
8

9
3. 兴趣管理 (Area of Interest)
10
   只同步玩家视野范围内的实体
11
   MMO 中离你 100 米外的人 → 不同步
12
   通过九宫格/AOI 算法实现
13

14
4. 降频策略
15
   近处实体：30fps 同步
16
   远处实体：10fps 同步
17
   极远实体：不同步

1
// 抖动缓冲区 (Jitter Buffer)
2
// 原理：增加固定延迟来吸收网络波动
3
class JitterBuffer {
4
    struct TimedPacket {
5
        float recv_time;
6
        float server_time;
7
        std::vector<uint8_t> data;
8
    };
9

10
    std::deque<TimedPacket> _buffer;
11
    float _buffer_delay;  // 缓冲延迟（通常 = 平均抖动的 2~3 倍）
12

13
public:
14
    JitterBuffer(float delay = 0.05f) : _buffer_delay(delay) {}
15

16
    void push(float recv_time, float server_time,
17
              std::vector<uint8_t> data) {
18
        _buffer.push_back({recv_time, server_time, std::move(data)});
19
    }
20

21
    // 取出"够老"的数据包
22
    bool pop(float current_time, std::vector<uint8_t>& out) {
23
        if (_buffer.empty()) return false;
24
        if (current_time - _buffer.front().recv_time >= _buffer_delay) {
25
            out = std::move(_buffer.front().data);
26
            _buffer.pop_front();
27
            return true;
28
        }
29
        return false;
30
    }
31

32
    // 动态调整缓冲延迟（根据实际抖动）
33
    void adaptDelay(float measured_jitter) {
34
        _buffer_delay = measured_jitter * 2.5f;
35
        _buffer_delay = std::clamp(_buffer_delay, 0.02f, 0.2f);
36
    }
37
};

1
问题：客户端和服务器的时钟不一样！
2
  客户端时间 12:00:00.000
3
  服务器时间 12:00:00.150  -> 差 150ms
4

5
解决方案：类似 NTP 的时钟同步
6
  1. 客户端发 Ping（带本地时间戳 T1）
7
  2. 服务器收到，记录到达时间 T2，处理后返回 Pong（T2, T3=发送时间）
8
  3. 客户端收到 Pong，记录时间 T4
9

10
  RTT = (T4 - T1) - (T3 - T2)       // 去除服务器处理时间
11
  单程延迟 = RTT / 2
12
  时差 = T2 - T1 - 单程延迟
13

14
  多次采样取中位数 -> 得到稳定的时间偏移
15
  客户端的服务器时间 = 本地时间 + 时差