Game.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "IScreen.hpp"
#include "animation/AnimationLibrary.hpp"
#include "animation/AnimationTesterUI.hpp"
#include "animation/CharacterRig.hpp"
#include "animation/SkinningBackend.hpp"
#include "app/AppContext.hpp"
#include "debug/ClientPerfRecorder.hpp"
#include "debug/DebugUI.hpp"
#include "debug/FrameRecorder.hpp"
#include "ecs/AssetRegistry.hpp"
#include "ecs/components/Hitbox.hpp"
#include "ecs/components/InputSnapshot.hpp"
#include "ecs/components/PlayerSimState.hpp"
#include "ecs/components/PlayerVisState.hpp"
#include "ecs/components/Position.hpp"
#include "ecs/components/PreviousPosition.hpp"
#include "ecs/components/Velocity.hpp"
#include "ecs/components/ViewmodelConfig.hpp"
#include "ecs/physics/MapLoader.hpp"
#include "ecs/registry/Registry.hpp"
#include "hud/Hud.hpp"
#include "menus/pause/PauseMenu.hpp"
#include "network/Client.hpp"
#include "network/MatchStatus.hpp"
#include "network/RegistrySerialization.hpp"
#include "particles/ParticleSystem.hpp"
#include "renderer-new/NewRenderer.hpp"
#include "sfx/SfxSystem.hpp"
#include "systems/GamepadAimAssistSystem.hpp"
#include "systems/InputRingBuffer.hpp"
#include "systems/KillFeedEvent.hpp"
#include "util/WorkerPool.hpp"
#include "voice/VoiceChatSystem.hpp"
 
#include <SDL3/SDL.h>
 
#include <array>
#include <cstdint>
#include <deque>
#include <entt/entt.hpp>
#include <glm/glm.hpp>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>

class Game : public IScreen
{
public:
    bool initDebugUI(const AppContext& ctx);

    bool init(AppContext& ctx);

    SDL_AppResult event(SDL_Event* event) override;

    SDL_AppResult iterate() override;

    bool shouldReturnToLobby() const;

    bool consumeReturnToMainMenu();

    void quit() override;

    void shutdownAfterRenderer() override;

    void refreshRemotePlayerRenderables();

    void refreshRemoteProjectileRenderables();

    void refreshRemoteRespawnRenderables();

    void refreshRemotePowerupRenderables();

    void refreshDroppedWeaponRenderables();
 
private:
    bool applyIncomingSnapshot(
        std::uint32_t snapshotTick, const std::uint8_t* bytes, Uint32 size, Uint64 captureNs, std::uint32_t& ackedTick);
    void handleLocalPlayerReady(entt::entity local);
 
    struct PredictedPlayerState
    {
        std::uint32_t tick = 0;
        Position position{};
        PreviousPosition previousPosition{};
        Velocity velocity{};
        PlayerVisState vis{};
        PlayerSimState sim{};
        InputSnapshot input{};
        bool valid = false;
    };
 
    struct ReconciliationDecision
    {
        bool skip = false;
        bool missingHistory = false;
        float positionError = 0.0f;
        float velocityError = 0.0f;
    };
 
    void clearPredictedStateHistory() noexcept;
    void storePredictedPlayerState(std::uint32_t tick);
    [[nodiscard]] std::optional<PredictedPlayerState> captureLocalPredictedState() const;
    [[nodiscard]] const PredictedPlayerState* predictedStateForTick(std::uint32_t tick) const noexcept;
    void restoreLocalPredictedState(const PredictedPlayerState& state);
    [[nodiscard]] ReconciliationDecision
    evaluateReconciliationSkip(const PredictedPlayerState& authoritative,
                               const PredictedPlayerState* predictedAtAck,
                               const std::optional<PredictedPlayerState>& currentBeforeSnapshot) const noexcept;

    void openChat();

    void closeChat();

    void submitChat();

    void appendChatMessage(ClientId sender, std::string_view message);

    void appendLocalChatMessage(std::string_view message);

    void clearGameplayInputForChat();
 
    static constexpr int k_physicsHz = 128;                                      
    static constexpr float k_physicsDt = 1.0f / static_cast<float>(k_physicsHz); 
    static constexpr int k_maxTicksPerFrame = 2;
    static constexpr int k_fpsHistorySize = 512;                   
 
    SDL_Window* window = nullptr;                                  
    DebugUI debugUI;                                               
    NewRenderer* renderer = nullptr;                               
    Registry registry;                                             
    Client* client = nullptr;                                      
    UserSettings* userSettings = nullptr;                          
    std::string_view userSettingsPath_;                            
    std::optional<registry_serialization::Loader> snapshotLoader_; 
    std::optional<entt::entity>
        mappedLocalPlayerEntity_;  
    ParticleSystem particleSystem; 
    SfxSystem sfxSystem;           
    VoiceChatSystem voiceChat_;    
    Hud hud_;                      
    entt::dispatcher dispatcher;   
 
    Uint64 prevTime = 0;           
    float accumulator = 0.0f;      
    int tickCount = 0;             
    uint32_t clientPredictTick = 0;

    bool prevShootingForDebug_ = false;

    InputRingBuffer inputRing_;
 
    std::array<PredictedPlayerState, InputRingBuffer::k_capacity> predictedStateHistory_{};
    bool mouseCaptured = true; 

    SDL_Gamepad* activeGamepad_ = nullptr;
    SDL_JoystickID activeGamepadId_ = 0;
    float gamepadLookSensitivity = 6.0f;

    systems::GamepadAimAssistConfig aimAssistCfg_;

    systems::GamepadAimAssistState aimAssistState_;

    std::unique_ptr<WorkerPool> workerPool_;
 
    // Runtime-tunable loop settings (exposed via ImGui)
    float mouseSensitivity = 0.0007f;      
    float horizontalFovDegrees = 90.0f;    
    bool renderSeparateFromPhysics = true; 
    bool inputSyncedWithPhysics = true;    
    bool limitFPSToMonitor = true;         
 
    Uint64 softLimitPeriod = 0;            
    Uint64 softLimitNextFrame = 0;         

    void applyFrameRateLimit();
 
    FrameRecorder recorder;  
    uint64_t frameCount = 0; 
 
    // Cached camera state — updated each iterate(), used by event() key shortcuts.
    glm::vec3 cachedEye_{0.f, 100.f, 0.f};
    glm::vec3 cachedCamFwd_{0.f, 0.f, 1.f};
    bool cachedGravFlipped_{false}; 
    float currentCameraRoll_{0.0f}; 
 
    // Map collision data — loaded from GLB, owns the vectors that back activeWorld().
    physics::MapCollisionData mapCollision_;
 
    // Central asset registry — maps human-readable names to renderer model indices.
    AssetRegistry assets_;
 
    // Legacy model index aliases (for code that still uses raw indices).
    // TODO: migrate all call sites to assets_.modelIndex("name") and remove these.
    int weaponModelIndices_[4] = {-1, -1, -1, -1};
    int weaponAssetIds_[4] = {-1, -1, -1, -1};
 
    int rocketProjectileModelIdx_ = -1;
 
    // Dynamic lighting test controls (ImGui-tunable)
    bool showDynLightUI_ = false;                        
    bool showHudDebug_ = false;                          
    bool flashlightEnabled_ = false;                     
    float flashlightIntensity_ = 8.0f;                   
    float flashlightRange_ = 800.0f;                     
    float flashlightOffset_ = 30.0f;                     
    bool movableSphereEnabled_ = false;                  
    float sphereFollowDist_ = 150.0f;                    
    float sphereIntensity_ = 5.0f;                       
    float sphereRange_ = 500.0f;                         
    bool beamEnabled_ = false;                           
    glm::vec3 beamStartOff_{30.0f, -5.0f, 10.0f};        
    glm::vec3 beamEndOff_{200.0f, -5.0f, 10.0f};         
    float beamRadius_ = 3.0f;                            
    glm::vec3 beamColor_{0.6f, 0.1f, 1.0f};              
    float beamLightIntensity_ = 4.0f;                    
    float beamLightRange_ = 300.0f;                      
    float beamLightSpacing_ = 60.0f;                     
    WeaponType currentEquippedType_ = WeaponType::Rifle; 
    WeaponType lastEquippedType_ = WeaponType::Rifle; 
    bool viewmodelDefaultsApplied_ = false;
 
    // Sound state tracking
    bool wasChargingRailgun_ = false; 
    bool wasBeamActive_ = false;      
    SfxSystem::SourceHandle beamLoopHandle_ = SfxSystem::kInvalidSource;
    std::unordered_map<entt::entity, std::array<float, 5>> footstepPhases_;
    std::unordered_map<entt::entity, float> footstepCooldowns_;
 
    // Movement / ability transition tracking for SFX.
    struct PlayerSfxState
    {
        bool initialized = false;
        bool grounded = false;
        bool isDead = false;
        int moveMode = 0;
        bool gravityFlipped = false;
        bool grappleActive = false;
        float primaryCooldown = 0.0f;
        float secondaryCooldown = 0.0f;
        SfxSystem::SourceHandle slideLoopHandle = SfxSystem::kInvalidSource;
    };
    std::unordered_map<entt::entity, PlayerSfxState> playerSfxState_;
 
    // Hitmarker
    float hitmarkerTimer_ = 0.0f;       
    bool hitmarkerIsHeadshot_ = false;  
    bool hitmarkerShieldBreak_ = false; 
 
    // Floating damage numbers — queued from replicated particle events, consumed by HUD each frame.
    struct PendingDamageNumber
    {
        glm::vec3 pos;
        float damage;
        bool headshot;
        bool shielded;
    };
    std::vector<PendingDamageNumber> pendingDamageNumbers_;
 
    // Damage accumulator — tracks continuous damage to a single target.
    entt::entity accumTarget_ = entt::null; 
    int accumTotal_ = 0;                    
    float accumResetTimer_ = 0.f;           
    uint8_t accumLastHitType_ = 0;          
 
    // Vignette state: track previous frame health/armor for delta detection.
    float prevHealth_ = 100.f;
    float prevArmor_ = 100.f;
 
    // ── Voidfall HUD bookkeeping ────────────────────────────────────────
    float matchElapsedSeconds_ = 0.f;

    int prevPrimaryWeaponType_ = -1;
    int prevSecondaryWeaponType_ = -1;
    int prevAmmoReserve_ = -1; 

    std::vector<HudPickupNotification> pendingPickupNotifications_;
    std::vector<HudChatMessage> chatMessages_;
    std::vector<HudVoiceSpeaker> voiceSpeakers_;
    std::string chatDraft_;
    std::deque<std::string> pendingLocalChatEchoes_;
    bool chatOpen_ = false;
 
    // (No additional bookkeeping needed — name strings are constructed
    // each frame into the thread_local vector inside Game.cpp.)
 
    // Viewmodel tuning (live-adjustable via ImGui)
    float vmScale = 1.0f;         
    float vmForward = 0.0f;       
    float vmRight = 0.0f;         
    float vmDown = 0.0f;          
    float vmYawOffset = 0.0f;     
    float vmPitchOffset = 0.0f;   
    float vmRollOffset = 0.0f;    
    bool showViewmodelUI = false; 
 
    // Weapon sway state (CoD-style barrel lead)
    float prevSwayYaw_ = 0.0f;
    float prevSwayPitch_ = 0.0f;
    float swayOffsetX_ = 0.0f;     
    float swayOffsetY_ = 0.0f;     
    bool swayInitialized_ = false; 
 
    // Sway tuning (ImGui-adjustable)
    float swayAmplitudeYaw_ = 3.0f;
    float swayAmplitudePitch_ = 2.0f;
    float swayDecayRate_ = 8.0f;  
    float swaySmoothing_ = 0.15f; 
 
    // Visual recoil state (viewmodel-only, does not affect aim)
    float recoilPitch_ = 0.0f;    
    float recoilPushBack_ = 0.0f; 
    float recoilRoll_ = 0.0f;     
 
    // Local weapon fire cooldown (mirrors server's per-weapon cooldown for VFX)
    float localFireCooldown_ = 0.0f; 
 
    int pendingScrollSwitch_ = 0;    
 
    // Third-person weapon tuning (per weapon type, live-adjustable via ImGui)
    ThirdPersonWeaponParams tpWeaponParams_[4]; 
    int tpTuneWeaponIdx_ = 0;                   
    bool showTPWeaponUI_ = false;               
 
    // Weapon spawner model tuning (per weapon type, live-adjustable via ImGui)
    WeaponSpawnerModelParams spawnerWeaponParams_[4]; 
    int spawnerTuneWeaponIdx_ = 0;                    
    bool showWeaponSpawnerModelUI_ = false;           
 
    // Animation subsystem — shared rig + clip library + skinning backend.
    // CharacterAnimators (one per animated entity) hold non-owning refs.
    CharacterRig charRig_;              
    AnimationLibrary animLibrary_;      
    CpuLbsSkinningBackend skinBackend_; 
    AnimationTesterState animUI_;       
    HitboxRig clientHitboxRig_;         
    float kRigScale_ = 1.0f;            
    float kRigVerticalOffset_ =
        -90.0f;                
    float rigMeshMinY_ = 0.0f; 
 
    // FPS ring buffer -- inter-render deltas, newest at (head-1) % size
    float fpsHistory[k_fpsHistorySize] = {}; 
    int fpsHistoryHead = 0;                  
    int fpsHistoryCount = 0;                 
    Uint64 prevRenderTime = 0;               
 
    // Network ping timer
    float pingTimer = 0.0f; 
 
    // Performance stats -- refreshed every 0.5 s
    Uint64 statsPrevTime = 0;       
    int statsPhysTicks = 0;         
    float measuredPhysicsHz = 0.0f; 
    float statsFPSCurrent = 0.0f;   
    float statsFPSMin = 0.0f;       
    float statsFPSMax = 0.0f;       
    float statsFPS1pLow = 0.0f;     
    float statsFPS5pLow = 0.0f;     
 
    // Benchmark mode: when BENCH_SECONDS env var is set to a positive number,
    // the client runs for that many seconds, prints a one-line FPS summary to
    // stderr, then quits.  Powers `scripts/perf-100bots.sh`.
    float benchSeconds_ = 0.0f;                         
    Uint64 benchStartTime_ = 0;                         
    bool benchActive_ = false;                          
    static constexpr float k_benchWarmupSeconds = 2.0f; 
    std::vector<float> benchFrameTimesMs_;              

    std::vector<ClientPerfFrame> benchFrameStats_;
    ClientPerfRecorder perfRecorder_;
    float perfSnapshotApplyMs_ = 0.0f;
    std::uint32_t perfSnapshotApplyCount_ = 0;

    void attachAnimatedCharacter(entt::entity e);
 
    // Match State
    MatchPhase currentMatchPhase = MatchPhase::LOBBY; 
    float countdownTimer = 0.0f; 
    bool returnToLobbyRequested = false;     
    bool returnToMainMenuRequested_ = false; 
 
    // Kill Feed State
    std::vector<KillFeedEvent> killFeed; 
 
    PauseMenu pauseMenu; 
 
    // Bullet tracer muzzle
    glm::vec3 cachedMuzzleWorld_{0.0f};
    bool cachedMuzzleValid_ = false;
};