System.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "Action.hpp"
#include "ActionHandler.hpp"
#include "Component.hpp"
#include "Event.hpp"
#include "EventListener.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include <type_traits>
 
namespace CeresEngine {
 
    using SystemID = unsigned int;
 
    using SystemOrder = int;
 
    class CE_SCRIPT_EXPORT(external = true) AbstractSystem {
        friend class SystemManager;
 
    public:
        static const SystemOrder defaultOrder;
 
    private:
        EntityManager* mEntityManager = nullptr;
 
        SystemManager* mSystemManager = nullptr;
 
    public:
        virtual ~AbstractSystem() = default;
 
    public:
        virtual void update(double time) = 0;
 
        [[nodiscard]] virtual SystemOrder getOrder() const noexcept;
 
    protected:
        virtual void attached(EntityManager& entityManager, SystemManager& systemManager);
 
        virtual void detached(EntityManager& entityManager, SystemManager& systemManager);
 
    protected:
        [[nodiscard]] EntityManager& entities() noexcept;
 
        [[nodiscard]] const EntityManager& entities() const noexcept;
 
        [[nodiscard]] SystemManager& systems() noexcept;
 
        [[nodiscard]] const SystemManager& systems() const noexcept;
 
        [[nodiscard]] EntityEventManager& events() noexcept;
 
        [[nodiscard]] const EntityEventManager& events() const noexcept;
 
    private:
        template<typename T, typename EntityObjects, typename Components, typename Actions> friend class System;
 
        static inline SystemID nextSystemID = 0;
    };
 
    template<typename EO> struct SystemComponentListener : public EO::ComponentSet::template Apply<ComponentListener> {
        virtual void didAdd(const EO& entity) noexcept = 0;
 
        virtual void didRemove(const EO& entity) noexcept = 0;
 
        virtual void didChange(const EO& entity, const EntityChangeSet& changeSet) noexcept {}
 
    private:
        void componentsAdded(const Entity& entity) noexcept final { didAdd(entity.as<EO>()); }
 
        void componentsRemoved(const Entity& entity) noexcept final { didRemove(entity.as<EO>()); }
 
        void entityDirtied(const Entity& entity, const EntityChangeSet& changeSet) noexcept final { didChange(entity.as<EO>(), changeSet); }
    };
 
    template<typename T, typename EntityObjects = EntityObjectSet<>, typename Components = ComponentSet<>, typename Actions = EntityActionSet<>> class System;
 
    template<typename T, typename... EOs, typename... Cs, typename... As>
    class System<T, EntityObjectSet<EOs...>, ComponentSet<Cs...>, EntityActionSet<As...>>
            : public AbstractSystem, private SystemComponentListener<EOs>..., private EntityActionHandler<As>... {
    public:
        using InterfaceType = T;
 
    public:
        void attached(EntityManager& entityManager, SystemManager& systemManager) override;
 
        void detached(EntityManager& entityManager, SystemManager& systemManager) override;
 
    public:
        static inline const SystemID systemID = []() noexcept {
            static SystemID systemID = nextSystemID++;
            return systemID;
        }();
 
        static inline const ComponentMask mask = ComponentSet<Cs...>::getComponentMask();
    };
 
    template<typename S> constexpr bool isSystem = std::is_base_of<AbstractSystem, S>::value;
 
    template<typename... Ss> constexpr bool areSystems = (isSystem<Ss> && ...);
 
    template<typename T, typename S> using ifSystem = typename std::enable_if<isSystem<S>, T>::type;
 
    template<typename S> inline constexpr void checkSystem() { static_assert(isSystem<S>, "S must be a System type!"); }
 
    template<typename T>
    concept CSystem = isSystem<T>;
 
    template<typename T>
    concept CSystemImplementation = CSystem<T> && !std::is_abstract_v<T>;
 
} // namespace CeresEngine
 
#include "ActionManager.hpp"
#include "EventManager.hpp"
 
namespace CeresEngine {
 
    template<typename T, typename... EOs, typename... Cs, typename... As>
    void System<T, EntityObjectSet<EOs...>, ComponentSet<Cs...>, EntityActionSet<As...>>::attached(EntityManager& entityManager, SystemManager& systemManager) {
        AbstractSystem::attached(entityManager, systemManager);
        ((void)entityManager.actions().add(static_cast<EntityActionHandler<As>&>(*this)), ...);
        ((void)entityManager.addListener(static_cast<SystemComponentListener<EOs>&>(*this)), ...);
    }
 
    template<typename T, typename... EOs, typename... Cs, typename... As>
    void System<T, EntityObjectSet<EOs...>, ComponentSet<Cs...>, EntityActionSet<As...>>::detached(EntityManager& entityManager, SystemManager& systemManager) {
        ((void)entityManager.removeListener(static_cast<SystemComponentListener<EOs>&>(*this)), ...);
        ((void)entityManager.actions().remove(static_cast<EntityActionHandler<As>&>(*this)), ...);
        AbstractSystem::detached(entityManager, systemManager);
    }
 
} // namespace CeresEngine