LagCompensation.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ecs/components/CollisionShape.hpp"
#include "ecs/components/Hitbox.hpp"
#include "ecs/components/HitboxHistory.hpp"
#include "ecs/components/LagCompTarget.hpp"
#include "ecs/components/Position.hpp"
#include "ecs/components/Velocity.hpp"
#include "ecs/physics/Raycast.hpp"
#include "ecs/registry/Registry.hpp"
 
#include <cstdint>
#include <glm/common.hpp> // glm::abs
#include <glm/vec3.hpp>
#include <utility>
#include <vector>
 
namespace systems
{

class RewindHitboxesGuard
{
public:
    RewindHitboxesGuard() = default;
 
    ~RewindHitboxesGuard() noexcept { restore(); }
 
    RewindHitboxesGuard(const RewindHitboxesGuard&) = delete;
    RewindHitboxesGuard& operator=(const RewindHitboxesGuard&) = delete;
 
    RewindHitboxesGuard(RewindHitboxesGuard&& other) noexcept
        : registry_(other.registry_), saved_(std::move(other.saved_))
    {
        other.registry_ = nullptr;
    }
 
    RewindHitboxesGuard& operator=(RewindHitboxesGuard&& other) noexcept
    {
        if (this != &other) {
            restore();
            registry_ = other.registry_;
            saved_ = std::move(other.saved_);
            other.registry_ = nullptr;
        }
        return *this;
    }
 
private:
    void restore() noexcept
    {
        if (registry_ == nullptr)
            return;
        for (auto& [entity, capsules] : saved_) {
            if (!registry_->valid(entity))
                continue;
            if (auto* inst = registry_->try_get<HitboxInstance>(entity))
                inst->capsules = std::move(capsules);
        }
        saved_.clear();
        registry_ = nullptr;
    }
 
    Registry* registry_ = nullptr;
    std::vector<std::pair<entt::entity, std::vector<WorldCapsule>>> saved_;
 
    friend RewindHitboxesGuard
    rewindHitboxes(Registry&, entt::entity, const glm::vec3*, const glm::vec3*, float, float);
};

inline RewindHitboxesGuard rewindHitboxes(Registry& registry,
                                          entt::entity shooter,
                                          const glm::vec3* rayOrigin = nullptr,
                                          const glm::vec3* rayDirection = nullptr,
                                          float rayMaxDistance = 0.0f,
                                          float bulletRadius = 0.0f)
{
    RewindHitboxesGuard guard;
 
    const auto* target = registry.try_get<LagCompTarget>(shooter);
    if (target == nullptr || target->targetServerTick == 0)
        return guard; // no-op: no rewind requested for this shooter
 
    const uint32_t targetTick = target->targetServerTick;
    const bool haveFilter = rayOrigin != nullptr && rayDirection != nullptr && rayMaxDistance > 0.0f;
 
    // PR-24 (broad-phase fix): how far back in time we're rewinding,
    // in seconds.  The pre-PR-24 broad-phase filter tested ray vs the
    // entity's LIVE AABB (live position ± live halfExtents).  At
    // sprint speed (~700 u/s) and 100 ms RTT the entity has moved
    // ~70 u between the rewind tick and now — well outside the 32 u
    // X/Z width of the default player AABB.  Result: fast-moving
    // targets whose live position was OFF the ray but whose
    // historical position was ON the ray got broad-phase REJECTED.
    // Their capsules stayed LIVE (no rewind), so the raycast tested
    // against the unrewound capsules and reported a miss; the user
    // saw the shot-debug visualizer's red capsules at the LIVE
    // position, identical to "no rollback at all".  Original PR-5
    // assumed 72 u half-extent — that's our Y, but X/Z is only 16 u.
    //
    // Fix: dilate the broad-phase AABB by `|velocity| × lagWindow` on
    // each axis to cover the full range of positions the entity could
    // have occupied during the rewind window.  Cheap (one mul + one
    // add) and rarely false-rejects even at sprint+200ms.
    const float lagWindowSec = static_cast<float>(target->lagTicks) / 128.0f;
 
    auto view = registry.view<HitboxInstance, HitboxHistory>();
    view.each([&](entt::entity entity, HitboxInstance& inst, const HitboxHistory& hist) {
        if (entity == shooter)
            return;
 
        // PR-5/PR-24: ray-AABB broad-phase pre-filter, dilated by
        // possible motion over the rewind window so fast-moving
        // entities aren't false-rejected (see comment above).
        if (haveFilter) {
            const auto* pos = registry.try_get<Position>(entity);
            const auto* shape = registry.try_get<CollisionShape>(entity);
            if (pos != nullptr && shape != nullptr) {
                glm::vec3 expand = shape->halfExtents;
                if (const auto* vel = registry.try_get<Velocity>(entity)) {
                    expand += glm::abs(vel->value) * lagWindowSec;
                }
                // Match the inflated narrow-phase hit shape ("cylinder hitreg"):
                // dilate the broad-phase AABB by the bullet radius so a thick
                // shot that grazes this player isn't pruned before rewind.
                expand += glm::vec3{bulletRadius};
                const physics::WorldAABB bounds{
                    .min = pos->value - expand,
                    .max = pos->value + expand,
                };
                float aabbDist = rayMaxDistance;
                glm::vec3 aabbNormal{0.0f};
                if (!physics::raycastAABB(*rayOrigin, *rayDirection, bounds, rayMaxDistance, aabbDist, aabbNormal)) {
                    return; // skip rewind for this player — ray doesn't reach their motion-extruded AABB
                }
            }
        }
 
        // Linear scan over the ring (≤ 32 slots). Find the sample
        // with the latest tick that's still ≤ targetTick. Empty slots
        // (tick == 0) and slots newer than targetTick are skipped.
        const HitboxHistorySample* best = nullptr;
        for (std::size_t i = 0; i < hist.count; ++i) {
            const auto& sample = hist.ring[i];
            if (sample.tick == 0)
                continue;
            if (sample.tick > targetTick)
                continue;
            if (best == nullptr || sample.tick > best->tick)
                best = &sample;
        }
        if (best == nullptr)
            return; // no usable historical sample (target predates the ring)
 
        // Save the live capsules (move out, no copy) and copy the
        // historical sample in. Move-out leaves `inst.capsules`
        // empty; the assignment from `best->capsules` repopulates
        // it. The destructor move-restores in reverse.
        guard.saved_.emplace_back(entity, std::move(inst.capsules));
        inst.capsules = best->capsules;
    });
 
    if (!guard.saved_.empty())
        guard.registry_ = &registry;
 
    return guard;
}
 
} // namespace systems