Entity.hpp

Go to the documentation of this file.

#pragma once
 
#include "EntityToIDString.hpp"
#include "Id.hpp"
#include "Logger.hpp"
#include "core/Core.hpp"
#include "entity/EntityId.hpp"
#include <entt/entt.hpp>
#include <typeindex>
 
namespace Engine {

class Entity {
  public:
    Entity(Core &core, EntityId entityId) : _core(core), _entityId(entityId) {}

    ~Entity() = default;

    bool IsAlive() const;

    inline EntityId Id() const { return _entityId; }

    explicit(false) inline operator EntityId() const { return _entityId; }

    void Kill();

    template <typename TComponent> inline decltype(auto) AddComponent(TComponent &&component)
    {
        return _entityId.AddComponent(GetCore(), std::forward<TComponent>(component));
    }

    template <typename TComponent, typename... TArgs> inline decltype(auto) AddComponent(TArgs &&...args)
    {
        return _entityId.AddComponent<TComponent>(GetCore(), std::forward<TArgs>(args)...);
    }

    template <typename TComponent, typename... TArgs> inline decltype(auto) AddComponentIfNotExists(TArgs &&...args)
    {
        return _entityId.AddComponentIfNotExists<TComponent>(GetCore(), std::forward<TArgs>(args)...);
    }

    template <typename TTempComponent, typename... TArgs> inline decltype(auto) AddTemporaryComponent(TArgs &&...args)
    {
        return _entityId.AddTemporaryComponent<TTempComponent>(GetCore(), std::forward<TArgs>(args)...);
    }

    static inline void RemoveTemporaryComponents(Core &core) { EntityId::RemoveTemporaryComponents(core); }

    template <typename TComponent> inline void RemoveComponent() { _entityId.RemoveComponent<TComponent>(GetCore()); }

    template <typename... TComponent> inline bool HasComponents() const
    {
        return _entityId.HasComponents<TComponent...>(GetCore());
    }

    template <typename... TComponent> inline decltype(auto) GetComponents()
    {
        return _entityId.GetComponents<TComponent...>(GetCore());
    }

    template <typename... TComponent> inline decltype(auto) GetComponents() const
    {
        return _entityId.GetComponents<TComponent...>(GetCore());
    }

    template <typename TComponent> inline decltype(auto) TryGetComponent()
    {
        return _entityId.TryGetComponent<TComponent>(GetCore());
    }

    bool operator==(const Entity &rhs) const { return _entityId.value == rhs._entityId.value; }

    bool operator==(const EntityId &rhs) const { return _entityId.value == rhs.value; }
 
  private:
    constexpr Core &GetCore() const { return _core.get(); }

    std::reference_wrapper<Core> _core;
    EntityId _entityId;
};
 
} // namespace Engine

template <> struct fmt::formatter<Engine::Entity> : fmt::formatter<Engine::EntityId> {
    template <typename FormatContext> auto format(const Engine::Entity &entity, FormatContext &ctx) const
    {
        return fmt::formatter<Engine::EntityId>::format(entity.Id(), ctx);
    }
};