Action.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 "CeresEngine/Macros.hpp"
 
#include <type_traits>
 
namespace CeresEngine {
 
    using EntityActionID = unsigned int;
 
    struct CE_EXPORT CE_SCRIPT_EXPORT(external = true) AbstractEntityAction {};
 
    template<typename T, typename R = void> struct EntityAction : public AbstractEntityAction {
    public:
        using ReturnType = R;
 
    private:
        [[nodiscard]] static EntityActionID getActionID() noexcept;
 
    public:
        static inline const EntityActionID actionID = getActionID();
    };
 
    template<typename A> constexpr bool isEntityAction = std::is_base_of<AbstractEntityAction, A>::value;
 
    template<typename... As> constexpr bool areEntityActions = (isEntityAction<As> && ...);
 
    template<typename T, typename A> using ifEntityAction = typename std::enable_if<isEntityAction<A>, T>::type;
 
    template<typename T, typename... As> using ifEntityActions = typename std::enable_if<areEntityActions<As...>, T>::type;
 
    template<typename T>
    concept CEntityAction = isEntityAction<T>;
 
    template<CEntityAction A> inline constexpr void checkAction() {
        static_assert(isEntityAction<A>, "A must be an Action type!");
        static_assert(std::is_final_v<A>, "Actions must be final!");
    }
 
    template<typename A> class EntityActionHandler;
    class EntityActionManager;
 
    template<CEntityAction... As> struct EntityActionSet {
        static_assert(areEntityActions<As...>, "All parameters in As must be actions.");
 
        template<CEntityAction A> static inline constexpr bool includes = (std::is_same_v<A, As> || ...);
    };
 
    template<> struct EntityActionSet<> {
        template<CEntityAction A> static inline constexpr bool includes = false;
    };
 
    class EntityActionType {
    public:
        const EntityActionID actionID;
 
    protected:
        explicit EntityActionType(const EntityActionID actionID) : actionID(actionID) {}
 
    public:
        EntityActionType(const EntityActionType&) = delete;
        EntityActionType& operator=(const EntityActionType&) = delete;
        EntityActionType(EntityActionType&&) = delete;
        EntityActionType& operator=(EntityActionType&&) = delete;
 
    protected: // EntityActionID allocation
        static inline EntityActionID nextActionID = 0;
 
    public:
        friend bool operator==(const EntityActionType& lhs, const EntityActionType& rhs) noexcept {
            // NOTE: This is safe as we only ever create a single instance for
            //       any given action type.
            //
            return &lhs == &rhs;
        }
 
        friend bool operator!=(const EntityActionType& lhs, const EntityActionType& rhs) noexcept { return !(lhs == rhs); }
 
    public:
        template<typename A> static const EntityActionType& get() noexcept;
    };
 
    template<typename A> class TEntityActionType : public EntityActionType {
    private:
        friend class EntityActionType;
 
        explicit TEntityActionType() : EntityActionType(getActionID()) {}
 
    protected: // EntityAction ID generation & retrieval
        [[nodiscard]] static EntityActionID getActionID() noexcept {
            static EntityActionID id = nextActionID++;
            return id;
        }
    };
 
    template<typename A> inline const EntityActionType& EntityActionType::get() noexcept {
        static const TEntityActionType<A> instance;
        return instance;
    }
 
    template<typename A, typename R> [[nodiscard]] EntityActionID EntityAction<A, R>::getActionID() noexcept { return EntityActionType::get<A>().actionID; }
 
#define CE_EXTERN_ENTITY_ACTION_BASE(T, EXTERN)                \
    EXTERN template struct ::CeresEngine::EntityAction<T>;     \
    EXTERN template class ::CeresEngine::TEntityActionType<T>; \
    EXTERN template const ::CeresEngine::EntityActionType& ::CeresEngine::EntityActionType::get<T>() noexcept;
#define CE_EXTERN_ENTITY_ACTION(T) CE_EXTERN_ENTITY_ACTION_BASE(T, extern)
#define CE_EXTERN_ENTITY_ACTION_IMPL(T) CE_EXTERN_ENTITY_ACTION_BASE(T, )
 
} // namespace CeresEngine