EntityRenderer.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** rtype
** File description:
** EntityRenderer.hpp - Specialized renderer for game entities
*/
 
#pragma once
 
#include <cstdint>
#include <deque>
#include <string>
#include <unordered_map>
#include <vector>
#include "Capnp/Messages/Shared/SharedTypes.hpp"
#include "Graphics/RaylibGraphics/RaylibGraphics.hpp"
 
class EntityRenderer {
   public:
    struct RenderableEntity {
        struct Snapshot {
            float x;              
            float y;              
            float velocityX;      
            float velocityY;      
            uint64_t timestamp;   
            uint32_t serverTick;  
        };
 
        uint32_t entityId;                         
        RType::Messages::Shared::EntityType type;  
        float x;                                   
        float y;                                   
        int health;                                
 
        // Snapshot buffer for time-based interpolation (ring buffer of last 3 snapshots)
        std::deque<Snapshot> snapshots;  
        uint64_t interpolationDelay;     
        bool extrapolationEnabled;       
 
        // Legacy fields for backward compatibility (remove after migration)
        float prevX;                
        float prevY;                
        float targetX;              
        float targetY;              
        float interpolationFactor;  
 
        int startPixelX;               
        int startPixelY;               
        int spriteSizeX;               
        int spriteSizeY;               
        int offsetX;                   
        int offsetY;                   
        float scale;                   
        std::string currentAnimation;  
        std::vector<int>
            animationFrameIndices;  
        int currentFrame;  
    };
 
    struct BackgroundConfig {
        std::string textureName;  
        std::string texturePath;  
        float scrollSpeed;        
        float scrollOffset;       
        int textureWidth;         
        int textureHeight;        
        bool loaded;              
    };
 
    explicit EntityRenderer(Graphics::RaylibGraphics &graphics);
 
    ~EntityRenderer() = default;
 
    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,
                      float velocityX = 0.0f, float velocityY = 0.0f, uint32_t serverTick = 0);
 
    void removeEntity(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 setMyEntityId(uint32_t id);
 
    void render();
 
    size_t getEntityCount() const { return _entities.size(); }
 
    bool hasEntity(uint32_t id) const { return _entities.count(id) > 0; }
 
    void setDebugMode(bool enabled) { _showDebugInfo = enabled; }
 
    void setInterpolationEnabled(bool enabled) { _interpolationEnabled = enabled; }
 
    void setInterpolationSpeed(float speed) { _interpolationSpeed = speed; }
 
    void setClientSidePredictionEnabled(bool enabled) { _clientSidePredictionEnabled = enabled; }
 
    void setReconciliationThreshold(float threshold) { _reconciliationThreshold = threshold; }
 
    [[nodiscard]] float getReconciliationThreshold() const { return _reconciliationThreshold; }
 
    void updateInterpolation(float deltaTime);
 
    void moveEntityLocally(uint32_t entityId, float deltaX, float deltaY);
 
    void setLocalPlayerMoving(bool moving) { _localPlayerIsMoving = moving; }
 
   private:
    void renderPlayer(const RenderableEntity &entity, bool isLocalPlayer);
 
    void renderEnemy(const RenderableEntity &entity);
 
    void renderProjectile(const RenderableEntity &entity);
 
    void renderWall(const RenderableEntity &entity);
 
    void renderOrbitalModule(const RenderableEntity &entity);
 
    void renderHealthBar(float x, float y, int health, int maxHealth);
 
    void renderDebugInfo(const RenderableEntity &entity);
 
    void renderBackground();
 
    [[nodiscard]] float lerp(float start, float end, float t) const;
 
    [[nodiscard]] float clamp(float value, float min, float max) const;
 
    [[nodiscard]] uint64_t getCurrentTimeMs() const;
 
    std::unordered_map<uint32_t, RenderableEntity> _entities;
 
    uint32_t _myEntityId = 0;
 
    Graphics::RaylibGraphics &_graphics;
 
    bool _showDebugInfo = true;
 
    bool _interpolationEnabled = true;
 
    float _interpolationSpeed = 10.0f;
 
    bool _clientSidePredictionEnabled = true;
 
    float _reconciliationThreshold = 15.0f;
 
    bool _localPlayerIsMoving = false;
 
    // ===== Background configuration =====
 
    BackgroundConfig _mainBackground;
 
    BackgroundConfig _parallaxBackground;
 
    bool _backgroundActive = false;
};