Entity.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 "Component.hpp"
#include "EntityID.hpp"
#include "Event.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Tuple.hpp"
 
#include <iosfwd>
#include <type_traits>
 
namespace CeresEngine {
 
    template<CComponent... Components> class EntityObject;
 
    class CE_SCRIPT_EXPORT() Entity {
        template<typename T, typename Component> friend struct ComponentFieldMutator;
 
    public:
        EntityManager* entityManager = nullptr;
 
        EntityID entityID = {};
 
    public:
        CE_SCRIPT_EXPORT()
        Entity() noexcept = default;
 
        CE_SCRIPT_EXPORT()
        Entity(EntityManager& entityManager, EntityID id) noexcept;
 
        CE_EXPLICIT(false) Entity(std::nullptr_t) noexcept; // NOLINT
 
        Entity& operator=(std::nullptr_t) noexcept;
 
        CE_SCRIPT_EXPORT()
        Entity(const Entity& other) noexcept = default;
 
        Entity& operator=(const Entity& other) noexcept = default;
 
    public: // Entity management
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool valid() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Entity copy() const;
 
        // `block(entity)` right after copying.
        template<typename Block> [[nodiscard]] Entity copy(Block&& block) const;
 
        CE_SCRIPT_EXPORT()
        void destroy() const;
 
    public: // Component management
        [[nodiscard]] AbstractComponent& add(const ComponentType& type, const Box& initialValue = nullptr) const;
 
        template<CComponent C, typename... Args> inline C& add(Args&&... args) const noexcept(std::is_nothrow_constructible_v<C, Args...>);
 
        template<CComponent C, typename Block, typename... Args>
        inline C& addWith(Block&& block, Args&&... args) const noexcept(std::is_nothrow_constructible_v<C, Args...>);
 
        template<CComponent C, typename... Args> inline C& set(Args&&... args) const noexcept(std::is_nothrow_constructible_v<C, Args...>);
 
        void remove(const ComponentType& type) const;
 
        template<CComponent C> inline void remove() const noexcept(std::is_nothrow_destructible_v<C>);
 
        [[nodiscard]] AbstractComponent& get(const ComponentType& type) const;
 
        template<CComponent C> [[nodiscard]] inline C& get() const noexcept;
 
        template<CComponent C0, CComponent C1, CComponent... Cs> [[nodiscard]] inline Tuple<C0&, C1&, Cs&...> get() const noexcept;
 
        [[nodiscard]] AbstractComponent& getOr(const ComponentType& type) const;
 
        template<CComponent C> [[nodiscard]] inline C& getOr() const noexcept(std::is_nothrow_constructible_v<C>);
 
        template<CComponent C0, CComponent C1, CComponent... Cs> inline Tuple<C0&, C1&, Cs&...> getOr() const noexcept;
 
        [[nodiscard]] AbstractComponent* getIf(const ComponentType& type) const;
 
        template<CComponent C> [[nodiscard]] inline C* getIf() const noexcept;
 
        template<CComponent C0, CComponent C1, CComponent... Cs> [[nodiscard]] inline Tuple<C0*, C1*, Cs*...> getIf() const noexcept;
 
        // TODO Write docs.
        [[nodiscard]] Vector<AbstractComponent*> getComponents() const;
 
        [[nodiscard]] bool has(const ComponentType& type) const noexcept;
 
        template<CComponent C, CComponent... Cs> [[nodiscard]] inline bool has() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void clear() const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool empty() const noexcept;
 
    public: // EntityObject access
        template<typename E> [[nodiscard]] inline bool is() const noexcept;
 
        template<typename E> [[nodiscard]] inline E as() const;
 
        template<typename... Cs> [[nodiscard]] inline EntityObject<Cs...> having() const;
 
        template<typename E> [[nodiscard]] inline E being() const noexcept;
 
    public: // Parent & Children entities
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Entity getParent() const noexcept;
 
        template<typename P> [[nodiscard]] P getParent() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setParent(Entity parent) const;
 
        [[nodiscard]] const Vector<Entity>& getChildren() const noexcept;
 
        template<typename T> [[nodiscard]] Generator<T> getChildren() const noexcept;
 
        void setChildren(const Vector<Entity>& children);
 
    public: // Naming
        [[nodiscard]] CE_SCRIPT_EXPORT()
        StringView getName() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setName(String name) const;
 
    public: // Events
        template<CEntityEvent E, typename... Args> inline void emit(Args&&... args) const;
 
        template<CEntityEvent E> inline void emit(const E& event) const;
 
        template<CEntityEvent E, typename Listener> inline WeakEventConnection on(Listener&& listener) const;
 
    public: // Actions
        template<CEntityAction A, typename... Args> [[nodiscard]] inline bool canAct(Args&&... args) const;
 
        template<CEntityAction A, typename... Args> inline decltype(auto) act(Args&&... args) const;
 
    public: // Entity component accessors
        template<typename T, CComponent Component> [[nodiscard]] CE_FORCE_INLINE auto mutate(T Component::*ptr) const;
 
        template<typename MutateFunc, typename T, CComponent Component> [[nodiscard]] CE_FORCE_INLINE decltype(auto) mutate(MutateFunc&& func, T Component::*ptr) const;
 
        template<typename T, CComponent Component> [[nodiscard]] CE_FORCE_INLINE const T& read(const T Component::*ptr) const;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT(property = "getter", name = "entityID")
        inline EntityID getEntityID() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT(property = "getter", name = "entityManager")
        inline EntityManager& getEntityManager() const noexcept;
 
    public: // Operators
        [[nodiscard]] inline explicit operator bool() const noexcept;
 
        friend bool operator==(const Entity& a, const Entity& b) noexcept;
 
        friend bool operator!=(const Entity& a, const Entity& b) noexcept;
 
        friend bool operator==(const Entity& a, const EntityID& b) noexcept;
 
        friend bool operator!=(const Entity& a, const EntityID& b) noexcept;
 
        friend bool operator==(const Entity& a, std::nullptr_t b) noexcept;
 
        friend bool operator!=(const Entity& a, std::nullptr_t b) noexcept;
 
        friend std::ostream& operator<<(std::ostream& os, const Entity& entity);
 
    public:
        [[nodiscard]] Entity operator[](const EntityIndex childIndex) const { return getChildren()[childIndex]; }
 
        [[nodiscard]] Entity operator[](const StringView childName) const {
            for(Entity entity : getChildren()) {
                if(entity.getName() == childName) {
                    return entity;
                }
            }
            return nullptr;
        }
 
        template<typename E> friend E unsafeCastEntityObject(EntityManager& entityManager, EntityID entityID) noexcept;
    };
 
    struct EntityChange final {
        const ComponentType* componentType;
 
        ComponentChangeSet change;
    };
 
    struct EntityChangeSet final {
        SmallVector<EntityChange, 3> changes;
    };
 
    struct EntityCreated final : public EntityEvent<EntityCreated> {};
 
    struct EntityDestroyed final : public EntityEvent<EntityDestroyed> {};
 
    struct EntityParentChanged final : public EntityEvent<EntityParentChanged> {
        Entity newParent;
 
        Entity oldParent;
 
        EntityParentChanged(const Entity newParent, const Entity oldParent) : newParent(newParent), oldParent(oldParent) {}
    };
 
    struct EntityNameChanged final : public EntityEvent<EntityNameChanged> {
        StringView newName;
 
        StringView oldName;
 
        EntityNameChanged(const StringView newName, const StringView oldName) : newName(newName), oldName(oldName) {}
    };
 
    template<CComponent C> struct ComponentAdded final : public EntityEvent<ComponentAdded<C>> {};
 
    template<CComponent C> struct ComponentRemoved final : public EntityEvent<ComponentRemoved<C>> {};
 
    struct EntityDirty final : public EntityEvent<EntityDirty> {
        EntityChangeSet changeSet;
 
        explicit EntityDirty(const EntityChangeSet& changeSet) : changeSet(changeSet) {}
    };
 
    template<CComponent... Components> class EntityObject : public Entity {
    public:
        using ComponentSet = CeresEngine::ComponentSet<Components...>;
 
        using Type = EntityObject<Components...>;
 
        static_assert(areComponents<Components...>, "All parameters in Components must be components.");
 
        template<typename C> static inline constexpr bool includes = ComponentSet::template includes<C>;
 
        struct _MaskObject {
            operator ComponentMask() const noexcept { return ComponentSet::getComponentMask(); }
        };
        static inline const _MaskObject mask;
 
        //        static inline const ComponentMask mask = ComponentSet::getComponentMask();
 
        static inline EntityObject make(Entity entity);
 
    public:
        inline EntityObject() = default;
 
        inline EntityObject(std::nullptr_t) noexcept; // NOLINT
 
        CE_SCRIPT_EXPORT()
        inline explicit EntityObject(EntityManager& entityManager);
 
        CE_SCRIPT_EXPORT()
        inline explicit EntityObject(EntityManager& entityManager, const Entity& parent);
 
        CE_SCRIPT_EXPORT()
        inline explicit EntityObject(EntityManager& entityManager, String name);
 
        CE_SCRIPT_EXPORT()
        inline explicit EntityObject(EntityManager& entityManager, const Entity& parent, String name);
 
        template<typename... OtherComponents>
        requires(EntityObject<OtherComponents...>::ComponentSet::template includes<Components>&&...) inline EntityObject(
            const EntityObject<OtherComponents...>& entity)
                : Entity(static_cast<const Entity&>(entity)) {}
 
        inline EntityObject(const EntityObject& other) noexcept = default;
 
        inline EntityObject& operator=(const EntityObject& other) noexcept = default;
 
    private:
        friend class EntityManager;
 
        inline EntityObject(EntityManager& entityManager, EntityID entityID);
 
    public:
        CE_FLATTEN_INLINE
        decltype(auto) operator->() const { // NOLINT(readability-const-return-type)
            struct AccessHelper final : public Components::Accessor... {
                CE_FLATTEN_INLINE
                explicit AccessHelper(EntityObject& entity) : Components::Accessor(entity)... {}
 
                CE_FLATTEN_INLINE
                decltype(auto) operator->() && { return this; }
            };
            return AccessHelper(const_cast<EntityObject&>(*this));
        }
 
    public:
        [[nodiscard]] UInt64 getHash() const { return hash(get<Components>()...); }
 
        [[nodiscard]] bool compareHash(UInt64& hash) const {
            const UInt64 prevHash = hash;
            hash = getHash();
            return hash == prevHash;
        }
 
    public: // Operators
//        template<CComponent... ACs, CComponent... BCs> friend bool operator==(const EntityObject<ACs...>& a, const EntityObject<BCs...>& b);
 
//        template<CComponent... ACs, CComponent... BCs> friend bool operator!=(const EntityObject<ACs...>& a, const EntityObject<BCs...>& b);
 
//        template<CComponent... ACs> friend bool operator==(const EntityObject<ACs...>& a, const Entity& b);
 
//        template<CComponent... ACs> friend bool operator!=(const EntityObject<ACs...>& a, const Entity& b);
 
//        template<CComponent... ACs> friend bool operator==(const EntityObject<ACs...>& a, const EntityID& b);
 
//        template<CComponent... ACs> friend bool operator!=(const EntityObject<ACs...>& a, const EntityID& b);
 
//        template<CComponent... ACs> friend bool operator==(const EntityObject<ACs...>& a, std::nullptr_t b);
//
//        /// Checks if a entity is not empty.
//        /// \param a The left hand side operator argument
//        /// \param b The right hand side operator argument
//        /// \return True if the entity is not empty
//        template<CComponent... ACs> friend bool operator!=(const EntityObject<ACs...>& a, std::nullptr_t b);
 
        template<CComponent... ACs> friend std::ostream& operator<<(std::ostream& os, const EntityObject<ACs...>& entity);
    };
 
    template<typename E> struct EntityObjectTraits {
        static constexpr bool isEntityObjectType = false;
    };
 
    template<typename... Components> struct EntityObjectTraits<EntityObject<Components...>> {
        static constexpr bool isEntityObjectType = true;
    };
 
    template<typename E>
    constexpr bool isEntityObject = (EntityObjectTraits<E>::isEntityObjectType || EntityObjectTraits<typename E::Type>::isEntityObjectType) &&
        sizeof(typename E::Type) == sizeof(E);
 
    template<typename... Es> constexpr bool areEntityObjects = (isEntityObject<Es> && ...);
 
    template<typename O, typename T = void> using ifEntityObject = typename std::enable_if<isEntityObject<O>, T>::type;
 
    template<typename T>
    concept CEntityObject = isEntityObject<T>;
 
    template<CEntityObject E> inline constexpr void checkEntityObject() { static_assert(isEntityObject<E>, "E must be an EntityObject type!"); }
 
    template<CEntityObject... EOs> struct EntityObjectSet {
        static_assert(areEntityObjects<EOs...>, "All parameters in EOs must be components.");
 
        template<CEntityObject EO> static inline constexpr bool includes = (std::is_same_v<EO, EOs> || ...);
 
        static inline const ComponentMask mask = (EOs::ComponentSet::getComponentMask() | ...);
    };
 
    template<> struct EntityObjectSet<> {
        template<CEntityObject EO> static inline constexpr bool includes = false;
 
        static inline const ComponentMask mask = ComponentMask();
    };
 
    template<typename E> static constexpr E entity_cast(const Entity& entity) { return entity.as<E>(); }
 
#define CE_ENTITY_OBJECT_HASH(T) \
    template<> struct std::hash<T> : public std::hash<CeresEngine::Entity> {}
 
} // namespace CeresEngine
 
#include "Component.inl"
#include "Entity.inl"
 
template<> struct std::hash<CeresEngine::Entity> {
    size_t operator()(const CeresEngine::Entity& entity) const { return CeresEngine::hash(entity.entityManager, entity.getEntityID()); }
};
 
template<CeresEngine::CComponent... Components> struct std::hash<CeresEngine::EntityObject<Components...>> {
    size_t operator()(const CeresEngine::EntityObject<Components...>& entity) const { return CeresEngine::hash(entity.entityManager, entity.getEntityID()); }
};