C++游戏引擎中的帧同步与物理更新：实现高精度、低延迟的Tick Rate控制

大家好，今天我们来探讨一个在多人游戏开发中至关重要的话题：帧同步与物理更新，以及如何实现高精度、低延迟的Tick Rate控制。在网络游戏中，尤其是需要精确同步的实时对战游戏（如MOBA、FPS），保证所有客户端看到相同的游戏世界状态是核心目标。而这依赖于精确的时间管理和确定性的物理模拟。

一、帧同步与状态同步：选择合适的同步策略

在讨论Tick Rate控制之前，我们需要先理解帧同步和状态同步这两种常见的同步策略。

状态同步 (State Synchronization): 每个客户端独立运行游戏逻辑和物理模拟，只定期将自身的游戏状态（例如，位置、速度、生命值等）发送给服务器。服务器收到后，可能进行状态校正，然后将校正后的状态广播给所有客户端。
帧同步 (Lockstep Synchronization): 所有客户端同步执行游戏逻辑和物理模拟。客户端只将玩家的输入指令发送给服务器。服务器收集所有玩家的输入，然后将这些输入广播给所有客户端。每个客户端收到所有输入后，按照相同的顺序和逻辑执行游戏帧，从而保证游戏状态的一致性。

特性	状态同步	帧同步
数据传输量	游戏状态数据 (相对较多)	玩家输入数据 (相对较少)
网络延迟容忍度	较高	较低
确定性	不需要	必须保证
实现难度	较低	较高
适用游戏类型	MMORPG, 对同步要求不高的游戏	MOBA, FPS, RTS 等需要精确同步

本次分享主要聚焦于帧同步，因为它对Tick Rate的精度要求更高。帧同步的核心在于保证所有客户端在同一Tick执行相同的逻辑，因此对Tick Rate的控制至关重要。

二、Tick Rate 的重要性与影响

Tick Rate (也称为Update Rate) 指的是游戏逻辑和物理模拟每秒更新的次数。例如，一个Tick Rate为60Hz的游戏，每秒会执行60次游戏逻辑和物理模拟。

精度: 更高的Tick Rate可以提供更精细的物理模拟和更快的响应速度。例如，在FPS游戏中，60Hz的Tick Rate比30Hz的Tick Rate能提供更流畅的操作体验和更精确的碰撞检测。
延迟: Tick Rate影响着玩家输入指令到游戏世界产生反应的延迟。更高的Tick Rate意味着更短的延迟。
网络带宽: 更高的Tick Rate意味着需要传输更多的数据（例如，玩家输入），因此会占用更多的网络带宽。
计算资源: 更高的Tick Rate意味着需要更多的计算资源来执行游戏逻辑和物理模拟。

因此，选择合适的Tick Rate需要在精度、延迟、网络带宽和计算资源之间进行权衡。

三、实现高精度 Tick Rate 的挑战

实现高精度Tick Rate面临以下几个挑战：

操作系统的不确定性: 操作系统并不是一个实时操作系统，无法保证每个Tick都能在精确的时间点执行。
硬件差异: 不同的硬件性能会导致不同的执行时间。
垃圾回收 (Garbage Collection): 垃圾回收可能会导致程序暂停，从而影响Tick Rate的稳定性。
帧率波动: 渲染线程的帧率波动可能会影响游戏逻辑线程的Tick Rate。

四、C++ 实现高精度 Tick Rate 的方法

以下是一些使用C++实现高精度Tick Rate的方法，并提供代码示例：

使用高精度计时器: 使用std::chrono库提供的高精度计时器来测量时间。

#include <iostream>
#include <chrono>
#include <thread>

class Timer {
public:
    Timer() : start(std::chrono::high_resolution_clock::now()) {}

    double elapsedMilliseconds() {
        auto now = std::chrono::high_resolution_clock::now();
        return std::chrono::duration<double, std::milli>(now - start).count();
    }

private:
    std::chrono::time_point<std::chrono::high_resolution_clock> start;
};

int main() {
    Timer timer;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "Elapsed time: " << timer.elapsedMilliseconds() << " ms" << std::endl;
    return 0;
}

固定时间步长 (Fixed Timestep): 使用固定时间步长来更新游戏逻辑和物理模拟。这意味着每个Tick的时间间隔是固定的，例如1/60秒。即使渲染线程的帧率发生波动，游戏逻辑线程的Tick Rate仍然保持稳定。

#include <iostream>
#include <chrono>
#include <thread>

const double TARGET_FPS = 60.0;
const double TICK_RATE = 60.0;
const double TIME_PER_TICK = 1.0 / TICK_RATE; // Seconds per tick

void gameLogic(double deltaTime) {
    // Simulate game logic and physics updates
    std::cout << "Game logic update with deltaTime: " << deltaTime << std::endl;
}

int main() {
    auto previousTime = std::chrono::high_resolution_clock::now();
    double lag = 0.0;

    while (true) {
        auto currentTime = std::chrono::high_resolution_clock::now();
        double elapsedTime = std::chrono::duration<double>(currentTime - previousTime).count();
        previousTime = currentTime;

        lag += elapsedTime;

        // Process as many ticks as necessary
        while (lag >= TIME_PER_TICK) {
            gameLogic(TIME_PER_TICK);
            lag -= TIME_PER_TICK;
        }

        // Render the game (example: simulate rendering time)
        // This is decoupled from the game logic update.
        std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int>(1000.0 / TARGET_FPS)));
    }

    return 0;
}

在这个例子中，TIME_PER_TICK 定义了每个Tick的时间间隔。lag 变量用于累积未处理的时间。当 lag 大于等于 TIME_PER_TICK 时，就执行一次游戏逻辑更新。这种方法可以保证游戏逻辑以固定的Tick Rate运行，即使渲染线程的帧率发生波动。

时间校正 (Time Correction): 如果Tick Rate仍然存在偏差，可以使用时间校正来补偿。时间校正的原理是测量实际的Tick时间，然后根据实际的Tick时间来调整游戏逻辑的执行。

#include <iostream>
#include <chrono>
#include <thread>

const double TARGET_FPS = 60.0;
const double TICK_RATE = 60.0;
const double TIME_PER_TICK = 1.0 / TICK_RATE; // Seconds per tick

void gameLogic(double deltaTime) {
    // Simulate game logic and physics updates
    std::cout << "Game logic update with deltaTime: " << deltaTime << std::endl;
    // Simulate some work being done.
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

int main() {
    auto previousTime = std::chrono::high_resolution_clock::now();
    double lag = 0.0;

    while (true) {
        auto currentTime = std::chrono::high_resolution_clock::now();
        double elapsedTime = std::chrono::duration<double>(currentTime - previousTime).count();
        previousTime = currentTime;

        lag += elapsedTime;

        // Process as many ticks as necessary
        while (lag >= TIME_PER_TICK) {
            auto tickStartTime = std::chrono::high_resolution_clock::now();
            gameLogic(TIME_PER_TICK);
            auto tickEndTime = std::chrono::high_resolution_clock::now();
            double actualTickTime = std::chrono::duration<double>(tickEndTime - tickStartTime).count();

            // Time correction: Adjust lag based on the actual tick time
            lag -= actualTickTime;
        }

        // Render the game (example: simulate rendering time)
        std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int>(1000.0 / TARGET_FPS)));
    }

    return 0;
}

在这个例子中，我们测量了每次Tick的实际执行时间 actualTickTime，然后使用这个值来调整 lag 变量。这样可以补偿由于硬件差异或操作系统的不确定性造成的Tick Rate偏差。

使用多线程: 将游戏逻辑和渲染逻辑分离到不同的线程中可以提高游戏的性能和稳定性。游戏逻辑线程负责更新游戏状态，渲染线程负责渲染游戏画面。这样可以避免渲染线程的帧率波动影响游戏逻辑线程的Tick Rate。

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <condition_variable>

const double TARGET_FPS = 60.0;
const double TICK_RATE = 60.0;
const double TIME_PER_TICK = 1.0 / TICK_RATE; // Seconds per tick

std::mutex mtx;
std::condition_variable cv;
bool gameLogicDone = false;
double deltaTime = 0.0; // Store the last calculated deltaTime

void gameLogic(double dt) {
    // Simulate game logic and physics updates
    std::cout << "Game logic update with deltaTime: " << dt << std::endl;
    // Simulate some work being done.
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

void gameLogicThread() {
    auto previousTime = std::chrono::high_resolution_clock::now();
    double lag = 0.0;

    while (true) {
        auto currentTime = std::chrono::high_resolution_clock::now();
        double elapsedTime = std::chrono::duration<double>(currentTime - previousTime).count();
        previousTime = currentTime;

        lag += elapsedTime;

        // Process as many ticks as necessary
        while (lag >= TIME_PER_TICK) {
            auto tickStartTime = std::chrono::high_resolution_clock::now();
            deltaTime = TIME_PER_TICK;  // Store deltaTime here
            gameLogic(deltaTime);
            auto tickEndTime = std::chrono::high_resolution_clock::now();
            double actualTickTime = std::chrono::duration<double>(tickEndTime - tickStartTime).count();

            // Time correction: Adjust lag based on the actual tick time
            lag -= actualTickTime;

            // Notify rendering thread that game logic is done
            {
                std::lock_guard<std::mutex> lock(mtx);
                gameLogicDone = true;
            }
            cv.notify_one();
        }
    }
}

void renderThread() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return gameLogicDone; });
        gameLogicDone = false;

        // Render the game (example: simulate rendering time)
        std::cout << "Rendering frame with deltaTime: " << deltaTime << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int>(1000.0 / TARGET_FPS)));
    }
}

int main() {
    std::thread logicThread(gameLogicThread);
    std::thread renderThread(renderThread);

    logicThread.detach(); // Detach so the main thread can exit. Consider proper thread management in production code.
    renderThread.detach();

    // Keep main thread alive.  In a real game, main thread would handle input, etc.
    while(true) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    return 0;
}

在这个例子中，gameLogicThread 负责更新游戏逻辑，renderThread 负责渲染游戏画面。std::mutex 和 std::condition_variable 用于线程同步。gameLogicThread 在完成一次游戏逻辑更新后，会通知 renderThread 进行渲染。

确定性物理引擎: 为了保证帧同步的正确性，需要使用确定性的物理引擎。确定性的物理引擎是指在相同的输入下，总是产生相同的输出。这对于在不同的客户端上保持游戏状态的一致性至关重要。常见的确定性物理引擎包括：
- Fixed-point arithmetic: 使用定点数代替浮点数可以避免由于浮点数运算的精度问题导致的不同客户端上的计算结果不一致。
- Bitwise determinism: 确保物理引擎的每个操作都是按位确定的。
- Deterministic random number generation: 使用确定性的随机数生成器可以保证在不同的客户端上生成相同的随机数序列。
例如，可以使用 fixmathlib 这样的库来实现定点数运算。
输入缓冲与回滚 (Input Buffering and Rollback): 由于网络延迟的存在，客户端可能无法及时收到所有玩家的输入。为了解决这个问题，可以使用输入缓冲和回滚技术。
- 输入缓冲: 客户端将收到的输入存储在一个缓冲区中。
- 回滚: 如果客户端在某个Tick没有收到所有玩家的输入，就使用之前的输入进行预测。当收到缺失的输入后，就回滚到之前的状态，然后重新执行游戏逻辑。
这种方法可以减少由于网络延迟造成的卡顿和延迟。

五、总结与建议

高精度、低延迟的Tick Rate控制是实现流畅、稳定的多人游戏的关键。选择合适的同步策略（帧同步或状态同步），利用高精度计时器，固定时间步长，时间校正，多线程，确定性物理引擎以及输入缓冲与回滚等技术，可以有效地提高Tick Rate的精度和稳定性。

在实际开发中，需要根据游戏的具体需求和目标平台来选择合适的Tick Rate和优化策略。需要考虑的因素包括：

游戏类型: 不同类型的游戏对Tick Rate的要求不同。例如，FPS游戏对Tick Rate的要求比MMORPG游戏更高。
网络环境: 网络延迟越高，对Tick Rate的精度要求越高。
硬件性能: 硬件性能越低，Tick Rate的上限越低。

希望今天的分享对大家有所帮助。谢谢！

更多IT精英技术系列讲座，到智猿学院

C++游戏引擎中的帧同步与物理更新：实现高精度、低延迟的Tick Rate控制

发表回复 取消回复

发表回复取消回复