Buff.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** RTYPE
** File description:
** Buff - Component for temporary and permanent buffs
*/
 
#pragma once
 
#include <algorithm>
#include <vector>
#include "IComponent.hpp"
 
namespace ecs {
 
    enum class BuffType {
        // Temporary buffs (duration-based)
        SpeedBoost,     
        DamageBoost,    
        FireRateBoost,  
        Shield,         
        HealthRegen,    
 
        // Permanent buffs (modify behavior permanently)
        MultiShot,          
        PiercingShot,       
        HomingShot,         
        MaxHealthIncrease,  
        DoubleShot,         
        TripleShot          
    };
 
    struct BuffInstance {
        BuffType type;     
        float duration;    
        float value;       
        bool isPermanent;  
 
        BuffInstance(BuffType t, float dur, float val, bool perm = false)
            : type(t), duration(dur), value(val), isPermanent(perm) {}
    };
 
    class Buff : public IComponent {
       public:
        Buff() = default;
 
        Buff(BuffType type, float duration, float value) { addBuff(type, duration, value); }
 
        ~Buff() override = default;
 
        void addBuff(BuffType type, float duration, float value) {
            bool isPermanent = (duration <= 0.0f);
 
            // Check if buff already exists
            for (auto &buff : _buffs) {
                if (buff.type == type) {
                    // Refresh duration and update value
                    buff.duration = duration;
                    buff.value = value;
                    buff.isPermanent = isPermanent;
                    return;
                }
            }
 
            // Add new buff
            _buffs.emplace_back(type, duration, value, isPermanent);
        }
 
        void removeBuff(BuffType type) {
            _buffs.erase(std::remove_if(_buffs.begin(), _buffs.end(),
                                        [type](const BuffInstance &b) { return b.type == type; }),
                         _buffs.end());
        }
 
        bool hasBuff(BuffType type) const {
            for (const auto &buff : _buffs) {
                if (buff.type == type)
                    return true;
            }
            return false;
        }
 
        float getBuffValue(BuffType type) const {
            for (const auto &buff : _buffs) {
                if (buff.type == type)
                    return buff.value;
            }
            return 1.0f;
        }
 
        const std::vector<BuffInstance> &getBuffs() const { return _buffs; }
 
        std::vector<BuffInstance> &getBuffsMutable() { return _buffs; }
 
        bool hasAnyBuffs() const { return !_buffs.empty(); }
 
        void clearAllBuffs() { _buffs.clear(); }
 
        ComponentType getType() const override { return getComponentType<Buff>(); }
 
       private:
        std::vector<BuffInstance> _buffs;  
    };
 
}  // namespace ecs