LagCompMath.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cstdint>

namespace server::lagcomp
{

inline constexpr std::uint32_t msToTicks(std::uint32_t ms, std::uint32_t tickRateHz)
{
    return (ms * tickRateHz + 500u) / 1000u;
}

inline std::uint32_t computeRewindTicks(std::uint16_t rttMs,
                                        std::uint16_t interpDelayMs,
                                        std::uint8_t interpDelaySnapshots,
                                        std::uint32_t snapshotEveryNTicks,
                                        std::uint32_t tickRateHz,
                                        std::uint32_t maxLagCompTicks)
{
    // PR-20.7: full-RTT (NOT half-RTT).  Our client renders remote players
    // at `most_recent_snapshot_apply − cl_interp` rather than predicting
    // them forward to estimated server-now, so the rewind has to absorb
    // both the inbound and outbound legs of the RTT.  See
    // ServerGame::updateLagCompTargets for the full derivation.
    const std::uint32_t rttTicks = msToTicks(rttMs, tickRateHz);
 
    const std::uint32_t interpDelayTicks = (interpDelayMs > 0) ? msToTicks(interpDelayMs, tickRateHz)
                                                               : static_cast<std::uint32_t>(interpDelaySnapshots) *
                                                                     std::max<std::uint32_t>(1u, snapshotEveryNTicks);
 
    return std::min<std::uint32_t>(rttTicks + interpDelayTicks, maxLagCompTicks);
}
 
} // namespace server::lagcomp