ReconciliationSystem.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "InputRingBuffer.hpp"
#include "ecs/components/InputSnapshot.hpp"
#include "ecs/components/LocalPlayer.hpp"
#include "ecs/physics/SweptCollision.hpp"
#include "ecs/registry/Registry.hpp"
#include "ecs/systems/CollisionSystem.hpp"
#include "ecs/systems/MovementSystem.hpp"
#include "systems/PredictionSystem.hpp"
 
#include <SDL3/SDL_log.h>
 
#include <cstdint>
#include <entt/entt.hpp>
 
namespace systems
{
 
struct ReconciliationStats
{
    std::uint32_t requestedTicks = 0;
    std::uint32_t replayedTicks = 0;
    std::uint32_t missingTicks = 0;
};

inline ReconciliationStats runReconciliation(Registry& registry,
                                             const InputRingBuffer& ring,
                                             uint32_t ackedTick,
                                             uint32_t currentTick,
                                             float dt,
                                             const physics::WorldGeometry& world)
{
    ReconciliationStats stats{};
    if (currentTick <= ackedTick)
        return stats; // already up to date — server state is the latest predicted state.
    stats.requestedTicks = currentTick - ackedTick;
 
    // Find the local player. Reconciliation is meaningless without one.
    auto localView = registry.view<LocalPlayer, InputSnapshot>();
    auto it = localView.begin();
    if (it == localView.end())
        return stats;
    const entt::entity local = *it;
 
    // Replay forward, one physics tick per stored input.
    int replayed = 0;
    int missing = 0;
    for (uint32_t t = ackedTick + 1; t <= currentTick; ++t) {
        const InputSnapshot* stored = ring.find(t);
        if (!stored) {
            // Ring overflow or we never sent for this tick — skip. The
            // gap means our prediction for this tick is lost, but
            // continuity is preserved (next stored input still applies).
            ++missing;
            continue;
        }
        registry.replace<InputSnapshot>(local, *stored);
        // runMovement+runCollision for the local player only. The
        // PlayerSimState filter (server-only component, only present on
        // the local player on the client) narrows the iteration
        // automatically — no per-entity filter needed.
        runMovement(registry, dt, world);
        runCollision(registry, dt, world);
        ++replayed;
    }
    stats.replayedTicks = static_cast<std::uint32_t>(replayed);
    stats.missingTicks = static_cast<std::uint32_t>(missing);
 
    if (missing > 0) {
        // Diagnostic: a non-trivial gap in the ring is unusual at sane
        // RTTs (256-tick capacity covers ~2 s of replay). Log so we can
        // notice if RTT or stalls drive the buffer beyond capacity.
        SDL_Log("[reconcile] %d ticks missing from input ring (replayed %d, range [%u..%u])",
                missing,
                replayed,
                ackedTick + 1,
                currentTick);
    }
    return stats;
}
 
} // namespace systems