Event.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2023
** R-Type
** File description:
** Event
*/
 
#ifndef EVENT_HPP_
#define EVENT_HPP_
#include <any>
#include <functional>
#include <unordered_map>
#include <vector>
#include <type_traits>
#include <algorithm>
#include <iterator>
#include <map>
#include <string>
 
namespace GameEngine
{
    using EventType = std::size_t;
    struct NoEventData
    {
    };
 
    enum class Event : EventType {
        WindowIsOpen,
        WindowCloseEvent,
        QuitEvent,
        PollEvent,
        GetWorldMousePos,
        WindowSetView,
        SetFpsLimitEvent,
        GetTransform,
        GetCollision,
        GetTexture,
        GetControllable,
        GetNewEntity,
        GetEntity,
        GetDestroy,
        SendInput,
        GetEndGame,
        GetStateTexture,
        GetScore,
        DeleteEntity,
        EnemiesSpawnedEvent,
        EnemiesMoveEvent,
        EnemiesDieEvent,
        PlayerMoveEvent,
        PlayerSpawnedEvent,
        PlayersDieEvent,
        PlayerShootEvent
    };
 
    static const std::map<EventType, std::string> InternalEventNames{
        {static_cast<EventType>(Event::WindowIsOpen), "WindowIsOpen"},
        {static_cast<EventType>(Event::WindowCloseEvent), "WindowCloseEvent"},
        {static_cast<EventType>(Event::PollEvent), "PollEvent"},
        {static_cast<EventType>(Event::GetWorldMousePos), "GetWorldMousePos"},
        {static_cast<EventType>(Event::WindowSetView), "WindowSetView"},
        {static_cast<EventType>(Event::SetFpsLimitEvent), "SetFpsLimitEvent"},
        {static_cast<EventType>(Event::GetTransform), "GetTransform"},
        {static_cast<EventType>(Event::GetCollision), "GetCollision"},
        {static_cast<EventType>(Event::GetTexture), "GetTexture"},
        {static_cast<EventType>(Event::GetControllable), "GetControllable"},
        {static_cast<EventType>(Event::GetNewEntity), "GetNewEntity"},
        {static_cast<EventType>(Event::GetEntity), "GetEntity"},
        {static_cast<EventType>(Event::SendInput), "SendInput"},
        {static_cast<EventType>(Event::DeleteEntity), "DeleteEntity"},
        {static_cast<EventType>(Event::EnemiesSpawnedEvent), "EnemiesSpawnedEvent"},
        {static_cast<EventType>(Event::EnemiesMoveEvent), "EnemiesMoveEvent"},
        {static_cast<EventType>(Event::EnemiesDieEvent), "EnemiesDieEvent"},
        {static_cast<EventType>(Event::PlayerMoveEvent), "PlayerMoveEvent"},
        {static_cast<EventType>(Event::PlayerSpawnedEvent), "PlayerSpawnedEvent"},
        {static_cast<EventType>(Event::PlayersDieEvent), "PlayersDieEvent"},
        {static_cast<EventType>(Event::PlayerShootEvent), "PlayerShootEvent"},
    };
#ifdef DEBUG
    static const int DEFAULT_MAX_EVENT_LOG_LENGTH = 100000;
#endif
 
    template <typename EventData = NoEventData>
    class EventHandler
    {
      public:
#ifdef DEBUG
        EventHandler(std::vector<EventType> &eventLog, const EventType eventType)
            : _eventLog(eventLog), _eventType(eventType){};
#else
        EventHandler(const EventType eventType) : _eventType(eventType){};
#endif
        void publish(EventData eventData) { _publish(eventData); }
        void publish() { _publish(NoEventData{}); }
        template <typename Function>
        void subscribe(const Function &function)
        {
            std::function<void(EventData)> callback = function;
            _callbacks.push_back(function);
        }
 
      private:
#ifdef DEBUG
        std::vector<EventType> &_eventLog;
#endif
        const EventType _eventType;
        void _publish(EventData eventData)
        {
#ifdef DEBUG
            if (_eventLog.size() >= DEFAULT_MAX_EVENT_LOG_LENGTH)
                _eventLog.clear();
            _eventLog.push_back(_eventType);
#endif
            for (std::function<void(EventData)> callback : _callbacks)
                callback(eventData);
        }
        std::vector<std::function<void(EventData)>> _callbacks;
    };
 
    class EventManager
    {
      public:
        template <class EventData = NoEventData>
        EventHandler<EventData> &addHandler(EventType eventType)
        {
#ifdef DEBUG
            _handlers.insert({eventType, EventHandler<EventData>(eventLog, eventType)});
#else
            _handlers.insert({eventType, EventHandler<EventData>(eventType)});
#endif
            return getHandler<EventData>(eventType);
        }
        void removeHandler(const EventType eventType) { _handlers.erase(eventType); }
        template <class EventData = NoEventData>
        void publish(const EventType eventType, EventData eventData)
        {
            getHandler<EventData>(eventType).publish(eventData);
        }
        template <class EventData = NoEventData>
        EventHandler<EventData> &getHandler(const EventType eventType)
        {
            return std::any_cast<EventHandler<EventData> &>(_handlers[eventType]);
        }
 
#ifdef DEBUG
        std::vector<EventType> eventLog;
#endif
 
      private:
        std::unordered_map<EventType, std::any> _handlers;
    };
 
} // namespace GameEngine
 
#endif /* !EVENT_HPP_ */