TimerManager.h

#pragma once
 
#include <cstdint>
#include <functional>
#include <vector>
 
#include <entt/entt.hpp>
 
namespace Engine
{
    class EngineKern;
}
 
namespace Engine::Entities
{
    class Actor;
}
 
namespace Engine::Core
{
    class TimerManager
    {
    public:
        struct TimerHandle
        {
            uint64_t id = 0;  

            [[nodiscard]] explicit operator bool() const
            {
                return id != 0;
            }
        };

        using Callback = std::function<void()>;

        TimerManager() = default;

        explicit TimerManager( EngineKern * engine );

        TimerHandle setTimer( double delaySeconds, Callback callback );

        TimerHandle setActorTimer(
            Entities::Actor * owner,
            double            delaySeconds,
            std::function<void( Entities::Actor & )> callback
        );

        void cancelTimer( TimerHandle handle );

        void cancelTimersFor( const Entities::Actor * owner );

        void clear();

        void tick( double nowSeconds );
 
    private:
        struct TimerEvent
        {
            TimerHandle      handle;
            double           fireTimeSeconds = 0.0;
            Entities::Actor * owner          = nullptr;
            entt::entity     ownerEntity     = entt::null;
            Callback         callback;
        };
 
        [[nodiscard]] double getCurrentTimeSeconds() const;
        [[nodiscard]] bool   isEventStillValid( const TimerEvent & event ) const;
        void                 insertTimer( TimerEvent event );
 
        EngineKern *            engine_            = nullptr;
        std::vector<TimerEvent> timers_;
        uint64_t                nextTimerId_       = 1;
        double                  currentTimeSeconds_ = 0.0;
    };
}  // namespace Engine::Core