EntityId.hpp

Go to the documentation of this file.

#pragma once
 
#include "Id.hpp"
#include "core/Core.hpp"
#include <fmt/format.h>
 
namespace Engine {
struct EntityId : Id {
    using ValueType = Id::ValueType;

    constexpr EntityId(ValueType v = NullValue()) : Id{v} {}

    constexpr EntityId(Id id) : Id{id} {}

    constexpr operator ValueType() const { return value; }

    static constexpr EntityId Null() { return EntityId{NullValue()}; }

    inline bool IsValid(const Engine::Core &core) const { return core.IsEntityValid(value); }

    template <typename TComponent> inline decltype(auto) AddComponent(Engine::Core &core, TComponent &&component)
    {
        Log::Debug(fmt::format("[EntityID:{}] AddComponent: {}", value, typeid(TComponent).name()));
        return core.GetRegistry().emplace<TComponent>(value, std::forward<TComponent>(component));
    }

    template <typename TComponent, typename... TArgs>
    inline decltype(auto) AddComponent(Engine::Core &core, TArgs &&...args)
    {
        Log::Debug(fmt::format("[EntityID:{}] AddComponent: {}", value, typeid(TComponent).name()));
        return core.GetRegistry().emplace<TComponent>(value, std::forward<TArgs>(args)...);
    }

    template <typename TComponent, typename... TArgs>
    inline decltype(auto) AddComponentIfNotExists(Engine::Core &core, TArgs &&...args)
    {
        if (this->HasComponents<TComponent>(core))
        {
            return this->GetComponents<TComponent>(core);
        }
        return this->AddComponent<TComponent>(core, std::forward<TArgs>(args)...);
    }

    template <typename... TComponent> inline bool HasComponents(const Engine::Core &core) const
    {
        return core.GetRegistry().all_of<TComponent...>(value);
    }

    template <typename TTempComponent, typename... TArgs>
    inline decltype(auto) AddTemporaryComponent(Engine::Core &core, TArgs &&...args)
    {
        if (!temporaryComponent.contains(std::type_index(typeid(TTempComponent))))
        {
            temporaryComponent[std::type_index(typeid(TTempComponent))] = [](Core &c) {
                Log::Debug(fmt::format("RemoveTemporaryComponent: {}", typeid(TTempComponent).name()));
                c.GetRegistry().clear<TTempComponent>();
            };
        }
 
        return this->AddComponent<TTempComponent>(core, std::forward<TArgs>(args)...);
    }

    template <typename... TComponent> inline decltype(auto) GetComponents(Engine::Core &core)
    {
        return core.GetRegistry().get<TComponent...>(this->value);
    }

    template <typename... TComponent> inline decltype(auto) GetComponents(Engine::Core &core) const
    {
        return core.GetRegistry().get<TComponent...>(this->value);
    }

    template <typename TComponent> inline decltype(auto) TryGetComponent(Engine::Core &core)
    {
        return core.GetRegistry().try_get<TComponent>(this->value);
    }

    template <typename TComponent> inline void RemoveComponent(Engine::Core &core)
    {
        Log::Debug(fmt::format("[EntityID:{}] RemoveComponent: {}", value, typeid(TComponent).name()));
        core.GetRegistry().remove<TComponent>(value);
    }

    static void RemoveTemporaryComponents(Core &core)
    {
        if (temporaryComponent.empty())
        {
            return;
        }
        for (const auto &[typeIndex, func] : temporaryComponent)
        {
            func(core);
        }
        temporaryComponent.clear();
    }
 
  private:
    inline static std::unordered_map<std::type_index, std::function<void(Core &)>> temporaryComponent = {};
};

static_assert(sizeof(EntityId) == sizeof(EntityId::ValueType), "EntityId size must be equal to Id size");
} // namespace Engine

template <> struct std::hash<Engine::EntityId> {
    std::size_t operator()(const Engine::EntityId &entityId) const noexcept
    {
        return std::hash<entt::id_type>{}(entityId.value);
    }
};

template <> struct fmt::formatter<Engine::EntityId> : fmt::formatter<std::string> {
    template <typename FormatContext> auto format(const Engine::EntityId &entityId, FormatContext &ctx) const
    {
        if (entityId.IsNull())
        {
            return fmt::formatter<std::string>::format("null_entity", ctx);
        }
        return fmt::formatter<std::string>::format(Log::EntityToDebugString(entityId.value), ctx);
    }
};