ServerGame.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "client/animation/AnimationLibrary.hpp"
#include "client/animation/CharacterAnimator.hpp"
#include "client/animation/CharacterRig.hpp"
#include "ecs/abilities/AbilityRegistry.hpp"
#include "ecs/components/AnimSnapshot.hpp"
#include "ecs/components/ClientId.hpp"
#include "ecs/components/Hitbox.hpp"
#include "ecs/components/PlayerColors.hpp"
#include "ecs/components/PlayerNicknames.hpp"
#include "ecs/physics/ContactCache.hpp"
#include "ecs/physics/MapLoader.hpp"
#include "ecs/registry/Registry.hpp"
#include "ecs/systems/PlayerStatusSystem.hpp"
#include "network/NetworkConfig.hpp"
#include "network/Server.hpp"
#include "server/lobby/LobbyManager.hpp"
#include "systems/Event.hpp" // PR-27: ShotIntentPayload
#include "systems/MatchController.hpp"
 
#include <SDL3/SDL.h>
 
#include <array>
#include <entt/entity/entity.hpp>
#include <functional>
#include <memory>
#include <unordered_map>
#include <vector>

class ServerGame
{
public:
    bool init(Server& server, int tickRateHz = 128, int snapshotHz = 32, bool skipLobby = false);

    void run();

    void shutdown();

    [[nodiscard]] bool isHost(ClientId clientId) const;

    void onMatchConfigUpdated(std::function<void(const MatchConfig&)> fn) { matchConfigUpdatedFn_ = std::move(fn); }

    void onDiscoverySettingsUpdated(std::function<void(const DiscoverySettings&)> fn)
    {
        discoverySettingsUpdatedFn_ = std::move(fn);
    }

    bool setMatchConfig(const MatchConfig& config);

    bool setKillsToWin(int kills);

    bool setMaxPlayers(int maxPlayers);

    bool setIdleShutdownMinutes(int minutes);
 
private:
    void eventHandler(const Event& event);
    void applyInputEvent(ClientId clientId, const InputSnapshot& inputSnapshot);

    void tick(float dt, Uint64 nextTick);

    void initNewPlayerEntity(ClientId clientId);

    void deletePlayerEntity(ClientId clientId);

    void initAnimation();

    void attachServerAnimator(entt::entity player);

    void detachServerAnimator(entt::entity player);

    void updateAnimationAndHitboxes(float dt);

    void updateLagCompTargets();

    void selectMatchAbilityPool();
    void applyMatchAbilityChoices(AbilityState& state) const;
 
    physics::MapCollisionData mapCollision_;        
 
    Server* server = nullptr;                       
    Registry registry;                              
    AbilityRegistry abilityRegistry;                
    std::vector<AbilityType> matchPrimaryAbilities; 
    std::vector<AbilityType> matchSecondaryAbilities;
    LobbyManager lobbyManager;                      
    MatchController matchController;                
    std::function<void(const MatchConfig&)> matchConfigUpdatedFn_; 
    std::function<void(const DiscoverySettings&)>
        discoverySettingsUpdatedFn_;                               
    bool lobbyStartCountdownActive = false; 
    float lobbyStartCountdownTimer = 0.0f;  
    ClientId lobbyStartRequester{-1};       
    std::unordered_map<ClientId, entt::entity> clientEntities; 
    std::vector<NetKillEvent> pendingKillEvents; 

    std::array<int, player_colors::k_paletteSize> colorSlotUseCounts_{};

    std::array<int, player_nicknames::k_nicknameCount> nicknameSlotUseCounts_{};
    bool running = false; 
    int tickRateHz = 128; 
    int tickCount = 0;    

    int snapshotEveryNTicks = 4;
    bool shotDebugEnabled_ = false; 
 
    // ── Phase 6+ rigid-body dynamics state ──
    physics::ContactCache contactCache_;
 
    // ── Server-side animation subsystem ──
    CharacterRig serverRig_;             
    AnimationLibrary serverAnimLibrary_; 
    HitboxRig hitboxRig_;                
    float rigScale_ = 1.0f;              
    float rigMeshMinY_ = 0.0f;           
    bool animationLoaded_ = false;       

    std::unordered_map<entt::entity, std::unique_ptr<CharacterAnimator>> serverAnimators_;
 
    // ── PR-18: server-side ground-truth log ──────────────────────────────
    //
    // Opened from `GROUP2_SERVER_TRUTH_CSV` env var if set.  One global
    // CSV file containing one row per replicated player per logged tick:
    //
    //     wallTimeNs,serverTick,clientId,posX,posY,posZ
    //
    // Throttled to every Nth tick (default 4 = 32 Hz at the 128 Hz tick
    // rate; tunable via `GROUP2_SERVER_TRUTH_HZ_DIVIDER`).  Log rate is
    // chosen to be high enough that linear interpolation between
    // adjacent samples is a good approximation of "the server's
    // position at any wall-clock time T", which is what the offline
    // analyzer compares against bot-side observations.  At 32 Hz × 100
    // bots × ~50 B/row = ~160 KB/s — trivial disk I/O cost on any
    // reasonable test rig.
    //
    // No mutex needed: this runs on the game thread, on the same path
    // as the existing tick logic, after the per-tick physics + lag-comp
    // updates have settled.
    std::FILE* truthCsv_ = nullptr;
    int truthHzDivider_ = 4;

    void openGroundTruthLog();

    void writeGroundTruthLogIfDue();

    void closeGroundTruthLog() noexcept;

    void resetPlayersForCountdown();

    [[nodiscard]] bool isGameplayInputAllowed(MatchPhase phase) const;

    [[nodiscard]] bool isLobbyPhase(MatchPhase phase) const;
 
    // ── PR-27: pending client SHOT_INTENTs ───────────────────────────────
    //
    // The network thread enqueues `EventType::ShotIntent` events into
    // `eventQueue`; the game thread's `processEvent` drains them and
    // stashes the payload here, keyed by `(shooterClientId,
    // shotInputTick)`.  When the weapon-system path resolves a shot
    // for the same shooter at the same input tick, it looks up the
    // intent here, computes the anim-state delta vs the historical
    // sample, and emits the result to `server_shots.csv`.
    //
    // Bounded at `k_pendingShotIntentsMax = 256` entries (~2 s of
    // shots at the 128 Hz fire-rate ceiling).  The map is single-
    // threaded read/write on the game thread.
    struct ShotIntentKey
    {
        std::uint16_t shooterClientId = 0;
        std::uint32_t shotInputTick = 0;
        bool operator==(const ShotIntentKey& o) const noexcept
        {
            return shooterClientId == o.shooterClientId && shotInputTick == o.shotInputTick;
        }
    };
    struct ShotIntentKeyHash
    {
        std::size_t operator()(const ShotIntentKey& k) const noexcept
        {
            // Mix shooter into the high bits so two shots from the
            // same shooter at adjacent ticks aren't bucket-adjacent.
            return (static_cast<std::size_t>(k.shooterClientId) << 32) ^ k.shotInputTick;
        }
    };
    static constexpr std::size_t k_pendingShotIntentsMax = 256;
    std::unordered_map<ShotIntentKey, ShotIntentPayload, ShotIntentKeyHash> pendingShotIntents_;
 
    bool idleShutdownEnabled_ = false; 
    uint64_t idleShutdownMs_ = 0;      
    uint64_t lastNonEmptyMs_ = 0;      
};