Bot.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ecs/components/InputSnapshot.hpp"
#include "ecs/registry/Registry.hpp"
#include "network/Client.hpp"
// PR-23: prediction parity with the real client.  Header-only, so just
// pulling in InputRingBuffer is enough at the .hpp level.
#include "systems/InputRingBuffer.hpp"
 
#include <SDL3/SDL_stdinc.h>
 
#include <atomic>
#include <cstdint>
#include <glm/vec3.hpp>
#include <optional>
#include <string>
#include <thread>
 
// (Bot members keep the trailing-underscore convention used elsewhere
// in this file; the .clang-tidy member rule trips on it but the existing
// code base treats trailing-underscore as the established style.)
 
class Bot
{
public:
    static constexpr int k_tickHz = 128;
 
    Bot() = default;
    Bot(const Bot&) = delete;
    Bot& operator=(const Bot&) = delete;
    Bot(Bot&&) = delete;
    Bot& operator=(Bot&&) = delete;
    ~Bot();

    bool init(const std::string& host, Uint16 port, int botId);

    void setSimulatedLatencyMs(int totalMs);

    void setSimulatedLossPercent(int percent);

    void start(const std::atomic<bool>& stopFlag);

    void join();

    [[nodiscard]] float getCurrentRttMs() const;

    [[nodiscard]] bool isReady() const { return ready_.load(std::memory_order_relaxed); }
 
private:
    void runLoop(const std::atomic<bool>& stopFlag);
 
    Client client_;            
    Registry registry_;        
    std::thread thread_;       
    InputSnapshot input_{};    
    uint32_t predictTick_ = 0; 
    std::optional<registry_serialization::Loader>
        snapshotLoader_;       
    std::optional<entt::entity> mappedLocalPlayerEntity_; 
    int botId_ = 0;                                       
    bool initialized_ = false;                            

    std::atomic<bool> ready_{false};
 
    // ── PR-23: prediction + reconciliation (parity with real client) ────
    //
    // Client-side prediction lets the bot simulate its OWN movement
    // locally each physics tick.  Pre-PR-23 the bot's `Position` only
    // moved when a server snapshot applied, which meant the bot's view
    // of its own position lagged the server's by `RTT/2 + interpDelay`.
    // For lag-comp / hit-reg testing under simulated RTT that drift was
    // a measurement artifact (not a real-client behaviour), polluting
    // the PR-22 ray-origin-desync metric with self-position lag the
    // real client doesn't have.
    //
    // The bot now mirrors `client/game/Game.cpp::iterate`:
    //   * each physics tick, push (predictTick_, input_) into ring,
    //     run `systems::runPrediction` on the bot's local entity
    //   * after `client_.poll`, if a snapshot just applied, call
    //     `systems::runReconciliation` from `serverAckedClientTick`
    //     forward to `predictTick_`.
    // Same code paths the real client runs — divergence between bot
    // and real client is now data-only (different inputs), not
    // architectural.
    InputRingBuffer inputRing_;

    bool localPlayerReady_ = false;

    void setupLocalPlayerCallback();
    bool applyIncomingSnapshot(
        std::uint32_t snapshotTick, const std::uint8_t* bytes, Uint32 size, Uint64 captureNs, std::uint32_t& ackedTick);
    [[nodiscard]] std::optional<entt::entity> getLocalPlayerEntity() const;
 
    // ── PR-18: per-bot snapshot observation log ──────────────────────────
    //
    // Opened from `GROUP2_BOT_OBS_CSV_PREFIX` at init() if set; one CSV
    // file per bot, named `<prefix><botId>.csv`.  Each row records one
    // remote-entity sighting from the bot's perspective:
    //
    //     wallTimeNs,observerBotId,observedClientId,posX,posY,posZ
    //
    // Written ONCE per snapshot apply (not once per tick) — gated by
    // `Client::consumeSnapshotApplied()` so the row count matches the
    // snapshot stream, not the tick stream.
    //
    // The companion server-side `GROUP2_SERVER_TRUTH_CSV` log records the
    // SAME columns from the server's perspective (with `serverTick` for
    // alignment).  An offline Python tool (`scripts/netsync-analyze.py`)
    // joins the two by wall-clock + clientId, interpolates between
    // adjacent server samples, and reports euclidean desync per bot per
    // entity per (sim RTT, sim loss) bucket.
    //
    // This framework would have caught the FragmentReassembler stuck-
    // state bug (PR-17) instantly: bot's observation log freezes while
    // server truth keeps moving → enormous desync values.  Going forward
    // it lets us A/B-test future netcode changes (quantization, AoI
    // culling, snapshot-rate changes) with hard numbers, not feel.
    std::FILE* obsCsv_ = nullptr;
 
    // ── PR-21: bot-side shot-intent log ──────────────────────────────────
    //
    // Opened from `GROUP2_BOT_SHOTS_CSV_PREFIX` at init() if set.  One
    // CSV per bot, named `<prefix><botId>.csv`.  Each row records ONE
    // intentional fire (rising edge of `input.shooting`) with the
    // information needed to join against the server-side
    // `server_shots.csv` produced by PR-18b's `perf::shotlog`:
    //
    //   wallTimeNs,shooterClientId,shotInputTick,
    //   originX,originY,originZ,
    //   dirX,dirY,dirZ,
    //   intendedTargetClientId,
    //   intendedTargetX,intendedTargetY,intendedTargetZ,
    //   intendedTargetDist
    //
    // The matching key is `(shooterClientId, shotInputTick)` — the
    // server stamps the same pair on every shot in `server_shots.csv`.
    // The Python analyzer joins them and reports per-RTT hit rate,
    // intended-vs-actual target distribution, region match, etc.
    std::FILE* shotsCsv_ = nullptr;
    bool prevShootingForLog_ = false; 

    void openShotsLog();

    void writeShotIntent(std::uint16_t shooterClientId,
                         std::uint32_t shotInputTick,
                         const glm::vec3& origin,
                         const glm::vec3& direction,
                         std::uint16_t intendedTargetClientId,
                         const glm::vec3& intendedTargetPos,
                         float intendedTargetDist,
                         bool botRayHit,
                         std::uint16_t botHitClientId,
                         const glm::vec3& botHitPos,
                         float botHitDist);

    void closeShotsLog() noexcept;

    void openObservationLog();

    void writeObservationLog();

    void closeObservationLog() noexcept;
};