System.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <stdexcept>
#include <unordered_map>
#include <utility>
#include <queue>
#include <functional>
#include <atomic>
#include <memory>
#include <mutex>
#include <vector>
#include <chrono>
#include <concepts>
#include <type_traits>
#include <libecs-cpp/json.hpp>
#include <libecs-cpp/Component.hpp>
#include <libecs-cpp/Clock.hpp>
#include <libecs-cpp/Timing.hpp>
 
namespace ecs
{
    class Container;
    class System;
 
    class Timer
    {
      public:
        Timer(std::string name,
          std::function<void()> callback,
          std::chrono::microseconds interval = std::chrono::seconds(30),
          bool repeat = true)
          : Repeat(repeat), length(interval)
        {
            this->Name = name;
            this->callback = callback;
            if(interval.count() >= 0 && interval <= MAX_INTERVAL)
            {
                this->timing.SetInterval(interval);
            }
        }
 
        template<std::integral T>
        [[deprecated("pass a std::chrono duration such as std::chrono::seconds(n) instead of a bare number")]]
        Timer(std::string name,
          std::function<void()> callback,
          T seconds,
          bool repeat = true)
          : Timer(std::move(name), std::move(callback), Timer::fromSeconds(seconds), repeat)
        {
        }
 
        bool CallbackRun()
        {
            if(this->valid() && this->timing.ShouldUpdate() && this->callback)
            {
                this->callback();
                return true;
            }
            return false;
        }
        std::string Name;
        bool Repeat;
 
      private:
        friend class ecs::System;
        bool discarded = false;
        std::chrono::microseconds length;
 
        bool valid() const
        {
            return this->length.count() >= 0 && this->length <= MAX_INTERVAL;
        }
        void start(std::chrono::microseconds now)
        {
            this->timing.SetInterval(this->length);
            this->timing.Restart(now);
        }
        bool due(std::chrono::microseconds now)
        {
            return this->timing.ShouldUpdate(now) && this->callback;
        }
        void fire()
        {
            this->callback();
        }
        template<typename T>
        static std::chrono::microseconds fromSeconds(T seconds)
        {
            constexpr long long maximum = std::chrono::duration_cast<std::chrono::seconds>(MAX_INTERVAL).count();
            if constexpr(std::is_signed_v<T>)
            {
                const long long value = seconds;
                if(value < 0) return std::chrono::microseconds(-1);
                if(value > maximum) return MAX_INTERVAL + std::chrono::microseconds(1);
                return std::chrono::seconds(value);
            }
            else
            {
                const unsigned long long value = seconds;
                if(value > static_cast<unsigned long long>(maximum)) return MAX_INTERVAL + std::chrono::microseconds(1);
                return std::chrono::seconds(static_cast<long long>(value));
            }
        }
        ecs::Timing timing;
        std::function<void()> callback = nullptr;
    };
 
    /* Hand-off point for messages sent to one system. Internal: use System::MessageSubmit().
     *
     * Any thread appends to pending under lock. The container thread moves pending into the system's
     * message queue. count mirrors pending.size() so the empty case needs no lock.
     */
    struct Mailbox
    {
        std::mutex lock;
        std::vector<nlohmann::json> pending;
        std::atomic<std::size_t> count{0};
    };
    class System
    {
      public:
        System();
        System(const std::string &handle);
        virtual ~System() = default;
        virtual void Initialize() {};
        virtual void Shutdown() {};
        virtual void Configure(const nlohmann::json &config);
        virtual void Update() {};
        void UpdateSystem();
        const std::string Handle;
        ecs::Container *Container = nullptr;
        void MessageSubmit(const nlohmann::json &message);
        virtual nlohmann::json Export() const = 0;
        ecs::TypeEntityComponentList *Components = nullptr;
        ecs::Timing Timing;
        size_t MessagesWaiting();
        std::chrono::microseconds ElapsedGet() const;
        double ElapsedSecondsGet() const;
        void ClockSet(const ecs::Clock *clock);
        [[deprecated("use ElapsedGet() or ElapsedSecondsGet() instead")]]
        uint32_t DeltaTimeGet();
        void TimerClear(const std::string &name);
        void TimerAdd(Timer timer);
        void Log(const std::string &message, const std::string &level = "info");
      private:
        friend class ecs::Container;
        std::shared_ptr<ecs::Mailbox> mailbox = std::make_shared<ecs::Mailbox>();
        std::vector<nlohmann::json> staging;
        void mailboxDrain();
        uint32_t timerWalkDepth = 0;
        bool timersDiscarded = false;
        std::vector<ecs::Timer> timersAdded;
        bool removed = false;
        void timerWalkFinish();
        void bufferedDeliver();
        void updateSystem(std::chrono::microseconds now);
        void elapsedMeasure(std::chrono::microseconds now);
        const ecs::Clock *clock = &ecs::SteadyClock::Instance();
        bool updated = false;
        std::chrono::microseconds previousUpdate{0};
        std::chrono::microseconds elapsed{0};
        std::chrono::microseconds millisecondCarry{0};
        uint32_t elapsedMilliseconds = 0;
      protected:
        std::queue<nlohmann::json> messages;
        [[deprecated("use ElapsedGet() or ElapsedSecondsGet() instead")]]
        std::chrono::steady_clock::time_point lastTime = std::chrono::steady_clock::now();
        std::unordered_map<std::string, std::vector<std::string>> componentsToDelete;
        void componentsClear();
        std::vector<ecs::Timer> timers;
        std::vector<std::pair<std::string, std::string>> bufferedLogMessages;
    };
}