帧同步（Lockstep）

#include <cstdint>

// Q16.16 定点数：高 16 位整数部分，低 16 位小数部分
struct Fixed {
    int32_t raw;

    static Fixed fromInt(int32_t v)   { return {v << 16}; }
    static Fixed fromFloat(float v)   { return {(int32_t)(v * 65536.0f)}; }

    float toFloat() const { return raw / 65536.0f; }

    Fixed operator+(const Fixed& o) const { return {raw + o.raw}; }
    Fixed operator-(const Fixed& o) const { return {raw - o.raw}; }
    Fixed operator*(const Fixed& o) const {
        return {(int32_t)(((int64_t)raw * o.raw) >> 16)};
    }
    Fixed operator/(const Fixed& o) const {
        return {(int32_t)(((int64_t)raw << 16) / o.raw)};
    }
    bool operator<(const Fixed& o) const { return raw < o.raw; }
    bool operator==(const Fixed& o) const { return raw == o.raw; }
};

#include <cstdint>

struct DeterministicRng {
    uint64_t state;

    explicit DeterministicRng(uint64_t seed) : state(seed) {}

    uint32_t next() {
        // LCG: Numerical Recipes 参数
        state = state * 6364136223846793005ULL + 1442695040888963407ULL;
        return (uint32_t)(state >> 33);
    }

    int32_t nextRange(int32_t lo, int32_t hi) {
        return lo + (int32_t)(next() % (uint32_t)(hi - lo));
    }
};

#include <cstdint>
#include <array>
#include <unordered_map>

// 每帧每个玩家的操作指令
struct PlayerInput {
    uint32_t frameNo;   // 帧号
    uint8_t  playerId;
    uint16_t buttons;   // bit flags: MOVE_UP=1, MOVE_DOWN=2, ATTACK=4...
    int8_t   moveX;     // 方向输入 [-100, 100]
    int8_t   moveY;

    // 序列化（网络传输）
    void serialize(uint8_t* buf) const {
        memcpy(buf, this, sizeof(PlayerInput));
    }
    static PlayerInput deserialize(const uint8_t* buf) {
        PlayerInput inp;
        memcpy(&inp, buf, sizeof(PlayerInput));
        return inp;
    }
};

// 一帧所有玩家的输入集合
struct FrameInputs {
    uint32_t frameNo;
    std::array<PlayerInput, 4> inputs;  // 最多 4 人
    uint8_t  playerCount;
};

#include <vector>
#include <mutex>
#include <optional>

class InputBuffer {
public:
    explicit InputBuffer(uint32_t capacity = 256)
        : buffer_(capacity), capacity_(capacity) {}

    // 网络线程写入
    void push(const FrameInputs& fi) {
        std::lock_guard<std::mutex> lk(mu_);
        buffer_[fi.frameNo % capacity_] = fi;
    }

    // 逻辑线程读取
    std::optional<FrameInputs> get(uint32_t frameNo) const {
        std::lock_guard<std::mutex> lk(mu_);
        const auto& slot = buffer_[frameNo % capacity_];
        if (slot.frameNo == frameNo) return slot;
        return std::nullopt;
    }

private:
    mutable std::mutex mu_;
    std::vector<FrameInputs> buffer_;
    uint32_t capacity_;
};

#include <chrono>
#include <thread>

class LockstepSimulator {
public:
    static constexpr int  LOGIC_FPS       = 20;           // 逻辑帧率
    static constexpr int  FRAME_MS        = 1000 / LOGIC_FPS;  // 50ms/帧
    static constexpr int  INPUT_DELAY     = 2;            // 输入延迟帧数
    static constexpr int  WAIT_TIMEOUT_MS = 200;          // 等帧超时

    void run() {
        using Clock = std::chrono::steady_clock;
        auto nextTick = Clock::now();

        while (!gameOver_) {
            // 1. 采集本地输入，打上延迟帧号
            PlayerInput localInput = collectLocalInput();
            localInput.frameNo = currentFrame_ + INPUT_DELAY;
            network_->sendInput(localInput);

            // 2. 等待当前帧所有玩家输入（含超时补帧）
            FrameInputs fi = waitForInputs(currentFrame_);

            // 3. 确定性模拟
            simulate(fi);
            currentFrame_++;

            // 4. 定时推进（固定帧率）
            nextTick += std::chrono::milliseconds(FRAME_MS);
            std::this_thread::sleep_until(nextTick);
        }
    }

private:
    FrameInputs waitForInputs(uint32_t frameNo) {
        auto deadline = std::chrono::steady_clock::now()
                      + std::chrono::milliseconds(WAIT_TIMEOUT_MS);

        while (true) {
            auto fi = inputBuffer_.get(frameNo);
            if (fi && fi->playerCount == expectedPlayers_) {
                return *fi;
            }
            if (std::chrono::steady_clock::now() >= deadline) {
                // 超时：补帧（复用上一帧输入）
                return holdInputs(frameNo);
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    }

    FrameInputs holdInputs(uint32_t frameNo) {
        FrameInputs fi = lastInputs_;
        fi.frameNo = frameNo;
        return fi;
    }

    void simulate(const FrameInputs& fi) {
        // 按确定性顺序处理（玩家 ID 排序保证顺序）
        for (uint8_t i = 0; i < fi.playerCount; ++i) {
            applyInput(fi.inputs[i]);
        }
        world_.step(Fixed::fromFloat(FRAME_MS / 1000.0f));
        lastInputs_ = fi;
    }

    PlayerInput   collectLocalInput();
    void          applyInput(const PlayerInput&);

    uint32_t      currentFrame_    = 0;
    uint8_t       expectedPlayers_ = 2;
    bool          gameOver_        = false;
    FrameInputs   lastInputs_      = {};
    InputBuffer   inputBuffer_;
    World         world_;      // 游戏世界（确定性）
    Network*      network_;
};

#include <cstdint>

// 每 N 帧对关键状态做 hash，上报服务端比对
uint32_t computeChecksum(const World& world) {
    uint32_t h = 2166136261u;  // FNV-1a
    for (const auto& unit : world.units()) {
        auto x = unit.pos.x.raw;
        auto y = unit.pos.y.raw;
        auto hp = unit.hp;
        h ^= (uint32_t)x;  h *= 16777619u;
        h ^= (uint32_t)y;  h *= 16777619u;
        h ^= (uint32_t)hp; h *= 16777619u;
    }
    return h;
}

// 每 5 帧上报一次
if (currentFrame_ % 5 == 0) {
    network_->sendChecksum(currentFrame_, computeChecksum(world_));
}