GameLoop.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** Created by samuelBleau on 26/11/2025.
** File description:
** GameLoop.hpp
*/
 
#ifndef GAMELOOP_HPP
#define GAMELOOP_HPP
 
#include <raylib.h>
#include <chrono>
#include <deque>
#include <iostream>
#include <memory>
#include <optional>
#include <unordered_set>
#include "../common/Logger/Logger.hpp"
#include "Capnp/Messages/Messages.hpp"
#include "Capnp/NetworkMessages.hpp"
#include "Core/EventBus/EventBus.hpp"
#include "Events/NetworkEvent/NetworkEvent.hpp"
#include "Events/UIEvent.hpp"
#include "Input/InputBuffer.hpp"
#include "Network/Replicator.hpp"
#include "Rendering/Rendering.hpp"
 
enum class GameScene { LOBBY, IN_GAME, PAUSED, GAME_OVER };
 
class GameLoop {
   public:
    GameLoop(EventBus &eventBus, Replicator &replicator, const std::string &playerName);
 
    ~GameLoop();
 
    bool initialize();
 
    void run();
 
    void shutdown();
 
    void stop();
 
    void setReconciliationThreshold(float threshold);
 
    float getReconciliationThreshold() const;
 
   private:
    void update(float deltaTime);
 
    void fixedUpdate(float fixedDeltaTime);
 
    void render();
 
    void processInput();
 
    float calculateDeltaTime();
 
    void handleNetworkMessage(const NetworkEvent &event);
    void handleUIEvent(const UIEvent &event);
 
    // Network message handlers
    void handleGameStart(const std::vector<uint8_t> &payload);
    void handleGameState(const std::vector<uint8_t> &payload);
    void handleGameruleUpdate(const std::vector<uint8_t> &payload);
    void handleRoomList(const std::vector<uint8_t> &payload);
    void handleRoomState(const std::vector<uint8_t> &payload);
    void handleEntityDestroyed(const std::vector<uint8_t> &payload);
    void handleChatMessage(const std::vector<uint8_t> &payload);
    void handleLeftRoom(const std::vector<uint8_t> &payload);
    void handleGameOver(const std::vector<uint8_t> &payload);
 
    // Helpers
    void processServerReconciliation(const RType::Messages::S2C::EntityState &entity);
    void simulateInputHistory(float &x, float &y);
 
    EventBus *_eventBus;  // Non-owning pointer (owned by Client)
    std::unique_ptr<InputBuffer> _inputBuffer;
    Replicator *_replicator;  // Non-owning pointer (owned by Client)
    std::unique_ptr<Rendering> _rendering;
 
    bool _running = false;
    bool _initialized = false;
 
    float _fixedTimestep = 1.0f / 60.0f;
    float _accumulator = 0.0f;
    uint32_t _currentFrame = 0;
 
    // Input tracking
    uint32_t _inputSequenceId = 0;
 
    // Input redundancy history
    static constexpr size_t INPUT_HISTORY_SIZE = 12;  // Send last 12 inputs (~200ms)
    std::deque<RType::Messages::C2S::PlayerInput::InputSnapshot> _inputHistory;
 
    // Player entity tracking
    std::optional<uint32_t> _myEntityId;  // Local player's entity ID (std::nullopt if not yet assigned)
    uint32_t _myPlayerId = 0;             // Local player's ID assigned by server
    bool _entityInitialized = false;
    bool _justCreatedRoom =
        false;  // Flag to track if we just created the current room           // True after first server update received
    std::string _playerName;                   // Local player's display name (for host detection)
    bool _isMoving = false;                    // True when player is actively moving
    float _playerSpeed = 300.0f;               // pixels per second (MUST MATCH SERVER!)
    bool _clientSidePredictionEnabled = true;  // Client-side prediction for smooth movement
    float _gameSpeedMultiplier = 1.0f;         // Game speed multiplier from server
 
    // Entity tracking for cleanup
    std::unordered_set<uint32_t> _knownEntityIds;  // Track all entities we've seen for proper cleanup
};
 
#endif