Entity.hpp

Go to the documentation of this file.

//
// Created by Zoe Roux on 2021-05-14.
//
 
#pragma once
 
#include <string>
#include <unordered_map>
#include <typeinfo>
#include <memory>
#include "Component/Component.hpp"
#include "Exception/WalError.hpp"
#include "Models/TypeHolder.hpp"
 
namespace WAL
{
    class Scene;
 
    class Entity
    {
    private:
        unsigned _uid;
        std::string _name;
        bool _disabled = false;
        bool _shouldDelete = false;
        bool _notifyScene;
        std::unordered_map<std::type_index, std::unique_ptr<Component>> _components = {};
 
        static unsigned nextID;
 
        void _componentAdded(const std::type_index &type);
        void _componentRemoved(const std::type_index &type);
 
        friend Scene;
        friend class Wal;
    protected:
    public:
        Scene &_scene;
        unsigned getUid() const;
        std::string getName() const;
        void setName(std::string &name);
 
        bool isDisable() const;
        void setDisable(bool disabled);
 
        bool shouldDelete() const;
        void scheduleDeletion();
 
        template<typename T>
        T &getComponent()
        {
            T *ret = this->tryGetComponent<T>();
            if (ret == nullptr)
                throw NotFoundError("No component could be found with the type \"" + std::string(typeid(T).name()) + "\".");
            return *ret;
        }
 
        template<typename T>
        T *tryGetComponent()
        {
            const std::type_index &type = typeid(T);
            auto existing = this->_components.find(type);
            if (existing == this->_components.end())
                return nullptr;
            return static_cast<T *>(existing->second.get());
        }
 
        template<typename T>
        const T &getComponent() const
        {
            const T *ret = this->tryGetComponent<T>();
            if (ret == nullptr)
                throw NotFoundError("No component could be found with the type \"" + std::string(typeid(T).name()) + "\".");
            return *ret;
        }
 
        template<typename T>
        const T *tryGetComponent() const
        {
            const std::type_index &type = typeid(T);
            auto existing = this->_components.find(type);
            if (existing == this->_components.end())
                return nullptr;
            return static_cast<T *>(existing->second.get());
        }
 
        template<typename T>
        bool hasComponent() const
        {
            const std::type_info &type = typeid(T);
            return this->hasComponent(type);
        }
 
        bool hasComponent(const std::type_info &type) const;
 
        bool hasComponent(const std::type_index &type) const;
 
        template<typename T, typename ...TNested, typename ...Types>
        Entity &addComponent(Types &&...params)
        {
            const std::type_index &type = typeid(T);
            if (this->hasComponent(type))
                throw DuplicateError("A component of the type \"" + std::string(type.name()) + "\" already exists on " + this->_name + ".");
            this->_components[type] = std::make_unique<T>(*this, TypeHolder<TNested>()..., std::forward<Types>(params)...);
            if (this->_notifyScene)
                this->_componentAdded(type);
            return *this;
        }
 
        Entity &addComponent(const Component &component);
 
        template<typename T>
        Entity &removeComponent()
        {
            const std::type_info &type = typeid(T);
            auto existing = this->_components.find(type);
            if (existing == this->_components.end())
                throw NotFoundError("No component could be found with the type \"" + std::string(type.name()) + "\".");
            this->_components.erase(existing);
            if (this->_notifyScene)
                this->_componentRemoved(type);
            return *this;
        }
 
        explicit Entity(Scene &wal, std::string name, bool notifyScene = true);
        Entity(const Entity &);
        Entity(Entity &&) = default;
        ~Entity() = default;
        Entity &operator=(const Entity &) = delete;
 
        bool operator==(const Entity &) const;
    };
} // namespace WAL