Rendering.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** Created by samuelBleau on 26/11/2025.
** File description:
** Rendering.hpp
*/
 
#ifndef RENDERING_HPP
#define RENDERING_HPP
 
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include "../common/Logger/Logger.hpp"
#include "Capnp/Messages/Shared/SharedTypes.hpp"
#include "Core/EventBus/EventBus.hpp"
#include "EntityRenderer.hpp"
#include "Events/UIEvent.hpp"
#include "Graphics/RaylibGraphics/RaylibGraphics.hpp"
 
// Audio
#include "Audio/SoundEffectManager.hpp"
 
// UI library
#include "Menu/AccessibilityMenu.hpp"
#include "Menu/AddServerMenu.hpp"
#include "Menu/ConfirmQuitMenu.hpp"
#include "Menu/ConnectionMenu.hpp"
#include "Menu/CreateRoomMenu.hpp"
#include "Menu/DefeatMenu.hpp"
#include "Menu/KeyBindingsMenu.hpp"
#include "Menu/LoginMenu.hpp"
#include "Menu/MainMenu.hpp"
#include "Menu/RoomListMenu.hpp"
#include "Menu/ServerListMenu.hpp"
#include "Menu/SettingsMenu.hpp"
#include "Menu/VictoryMenu.hpp"
#include "Menu/WaitingRoomMenu.hpp"
#include "UI/ChatWidget.hpp"
#include "UI/IButton.hpp"
#include "UI/IMenu.hpp"
#include "UI/Raylib/RaylibUIFactory.hpp"
 
class Rendering {
   public:
    explicit Rendering(EventBus &eventBus);
 
    ~Rendering();
 
    bool Initialize(uint32_t width, uint32_t height, const std::string &title);
 
    void Shutdown();
 
    void ClearWindow();
 
    void Render();
 
    [[nodiscard]] bool IsWindowOpen() const;
 
    void StartGame();
 
    bool LoadTexture(const std::string &textureName, const std::string &path);
 
    void DrawSprite(const std::string &textureId, float xPosition, float yPosition, float rotation = 0.0,
                    float scale = 1.0);
 
    void DrawText(const std::string &text, float xPosition, float yPosition, uint32_t size = 24);
 
    [[nodiscard]] uint32_t GetWidth() const;
 
    [[nodiscard]] uint32_t GetHeight() const;
 
    [[nodiscard]] bool WindowShouldClose() const;
 
    // ═══════════════════════════════════════════════════════════
    // Entity Rendering API (delegated to EntityRenderer)
    // ═══════════════════════════════════════════════════════════
 
    void UpdateEntity(uint32_t id, RType::Messages::Shared::EntityType type, float x, float y, int health,
                      const std::string &currentAnimation, int srcX, int srcY, int srcW, int srcH);
 
    void RemoveEntity(uint32_t id);
 
    void SetMyEntityId(uint32_t id);
 
    void ClearAllEntities();
 
    void SetBackground(const std::string &mainBackground, const std::string &parallaxBackground,
                       float scrollSpeed, float parallaxSpeedFactor);
 
    void ClearBackground();
 
    void UpdateBackground(float deltaTime);
 
    void ShowGameOver(const std::string &reason);
 
    bool IsKeyDown(int key) const;
 
    bool IsGamepadAvailable(int gamepad) const;
 
    bool IsGamepadButtonDown(int gamepad, int button) const;
 
    void UpdateInterpolation(float deltaTime);
 
    void UpdatePingTimer(float deltaTime);
 
    void MoveEntityLocally(uint32_t entityId, float deltaX, float deltaY);
 
    void UpdateRoomList(const std::vector<RoomData> &rooms);
 
    void UpdateWaitingRoom(const std::vector<Game::PlayerInfo> &players, const std::string &roomName,
                           bool isHost, bool isSpectator = false);
 
    void AddChatMessage(uint32_t playerId, const std::string &playerName, const std::string &message,
                        uint64_t timestamp);
 
    void SetOnChatMessageSent(std::function<void(const std::string &)> callback);
 
    void UpdateChatVisibility();
 
    void SetClientSidePredictionEnabled(bool enabled);
 
    void SetReconciliationThreshold(float threshold);
 
    float GetReconciliationThreshold() const;
 
    void SetLocalPlayerMoving(bool moving);
 
    void SetPing(uint32_t pingMs);
 
    void SetShowPing(bool enabled);
 
    [[nodiscard]] bool GetShowPing() const;
 
    void SetShowFps(bool enabled);
 
    [[nodiscard]] bool GetShowFps() const;
 
    void SetPlayerName(const std::string &name);
 
   private:
    enum class Scene { MENU, IN_GAME, GAME_OVER };
 
    Scene _scene = Scene::MENU;
    std::string _gameOverReason;  // Stores the reason for game over
 
    EventBus &_eventBus;
    bool _initialized = false;
    bool _quitRequested = false;
    uint32_t _width = 0;
    uint32_t _height = 0;
    Graphics::RaylibGraphics _graphics;
 
    // ===== Audio =====
    std::unique_ptr<Audio::SoundEffectManager> _soundEffectManager;
 
    // ===== Menu UI (business) =====
    std::unique_ptr<UI::RaylibUIFactory> _uiFactory;
    std::unique_ptr<Game::MainMenu> _mainMenu;
    std::unique_ptr<Game::ServerListMenu> _serverListMenu;
    std::unique_ptr<Game::AddServerMenu> _addServerMenu;
    std::unique_ptr<Game::RoomListMenu> _roomListMenu;
    std::unique_ptr<Game::CreateRoomMenu> _createRoomMenu;
    std::unique_ptr<Game::WaitingRoomMenu> _waitingRoomMenu;
    std::unique_ptr<Game::ConnectionMenu> _connectionMenu;
    std::unique_ptr<Game::SettingsMenu> _settingsMenu;
    std::unique_ptr<Game::AccessibilityMenu> _accessibilityMenu;
    std::unique_ptr<Game::KeyBindingsMenu> _keyBindingsMenu;
    std::unique_ptr<Game::ConfirmQuitMenu> _confirmQuitMenu;
    std::unique_ptr<Game::LoginMenu> _loginMenu;
    std::unique_ptr<Game::DefeatMenu> _defeatMenu;
    std::unique_ptr<Game::VictoryMenu> _victoryMenu;
 
    bool _settingsOverlay = false;
    bool _confirmQuitOverlay = false;
    bool _loginOverlay = false;
    bool _keyBindingsOverlay = false;
 
    // Selected server for connection
    std::string _selectedServerIp = "127.0.0.1";
    uint16_t _selectedServerPort = 4242;
    bool _isConnecting = false;
    std::string _connectingServerName;
 
    // Selected room for joining
    std::string _selectedRoomId;
 
    // Entity rendering subsystem
    std::unique_ptr<EntityRenderer> _entityRenderer;
 
    // Chat widget
    std::unique_ptr<Game::ChatWidget> _chatWidget;
 
    // Network stats display (updated once per second for optimization)
    uint32_t _currentPing = 0;
    uint32_t _displayedPing = 0;                         // The ping value currently displayed
    float _pingUpdateTimer = 0.0f;                       // Timer for ping update throttling
    static constexpr float PING_UPDATE_INTERVAL = 1.0f;  // Update every 1 second
 
    bool _showPing = true;
    bool _showFps = true;
 
    // ===== HUD stats =====
    uint32_t _fps = 0;
    float _fpsAccumulator = 0.0f;
    uint32_t _fpsFrameCount = 0;
 
    void InitializeMenus();
 
    void ApplyInitialMenuSettings();
 
    // ===== Menu initialization helpers (SOLID: Single Responsibility) =====
    void InitializeConfirmQuitMenu();
    void InitializeSettingsMenu();
    void InitializeAccessibilityMenu();
    void InitializeKeyBindingsMenu();
    void InitializeMainMenu();
    void InitializeLoginMenu();
    void InitializeServerListMenu();
    void InitializeAddServerMenu();
    void InitializeRoomListMenu();
    void InitializeCreateRoomMenu();
    void InitializeWaitingRoomMenu();
    void InitializeDefeatMenu();
    void InitializeVictoryMenu();
    void InitializeConnectionMenu();
    void InitializeChatWidget();
    void SubscribeToConnectionEvents();
 
    // ===== Accessibility settings persistence =====
    void LoadAccessibilitySettings();
    void SaveAccessibilitySettings();
 
    // ===== Helper methods for Render() to reduce cognitive complexity =====
 
    void UpdateFpsCounter();
 
    void HandleEscapeKeyInput();
 
    void UpdateUI();
 
    void RenderGameScene();
 
    void RenderUI();
 
    void RenderHUD();
};
#endif