spk_entity.hpp

#pragma once
 
#include "structure/design_pattern/spk_activable_object.hpp"
#include "structure/design_pattern/spk_inherence_object.hpp"
 
#include "structure/system/event/spk_keyboard_event.hpp"
#include "structure/system/event/spk_mouse_event.hpp"
#include "structure/system/event/spk_paint_event.hpp"
#include "structure/system/event/spk_system_event.hpp"
#include "structure/system/event/spk_update_event.hpp"
 
#include <atomic>
#include <mutex>
#include <set>
#include <span>
#include <string>
#include <type_traits>
#include <vector>
 
#include "structure/design_pattern/spk_contract_provider.hpp"
#include "structure/engine/spk_component.hpp"
 
#include "type/spk_binary_operator.hpp"
 
namespace spk
{
    class GameEngine;

    class Entity : public spk::InherenceObject<Entity>, public spk::ActivableObject
    {
    public:
        using Contract = spk::ActivableObject::Contract;
        using Job = spk::ActivableObject::Job;
 
    private:
        std::wstring _name;
        std::set<std::wstring> _tags;
 
        std::atomic<int> _priority = 0;
 
        mutable std::recursive_mutex _componentMutex;
        mutable std::recursive_mutex _childMutex;
 
        std::vector<std::unique_ptr<Component>> _components;
        GameEngine *_engine = nullptr;
 
        template <typename T>
        void _sortByPriority(std::vector<T> &p_container, std::recursive_mutex &p_mutex)
        {
            std::unique_lock<std::recursive_mutex> mutexLock(p_mutex);
 
            std::sort(
                p_container.begin(),
                p_container.end(),
                [](const T &p_a, const T &p_b) {
                    int priorityA = p_a->priority();
                    int priorityB = p_b->priority();
 
                    bool aNoPriority = (priorityA < 0);
                    bool bNoPriority = (priorityB < 0);
 
                    if (aNoPriority && bNoPriority)
                    {
                        return (false);
                    }
 
                    if (aNoPriority != bNoPriority)
                    {
                        return (!aNoPriority);
                    }
 
                    return (priorityA > priorityB);
                });
        }
 
        template <typename TCallback>
        void _forEachChild(TCallback &&p_callback)
        {
            std::vector<Entity *> childSnapshot;
 
            {
                std::lock_guard<std::recursive_mutex> lock(_childMutex);
                childSnapshot.assign(children().begin(), children().end());
            }
 
            for (auto child : childSnapshot)
            {
                if (child != nullptr)
                {
                    if constexpr (std::is_same_v<std::invoke_result_t<TCallback, Entity *>, bool>)
                    {
                        if (p_callback(child) == false)
                        {
                            break;
                        }
                    }
                    else
                    {
                        p_callback(child);
                    }
                }
            }
        }
 
        template <typename TCallback>
        void _forEachComponent(TCallback &&p_callback)
        {
            std::vector<spk::Component *> componentSnapshot;
 
            {
                std::lock_guard<std::recursive_mutex> lock(_componentMutex);
                componentSnapshot.reserve(_components.size());
                for (const auto &component : _components)
                {
                    if (component != nullptr)
                    {
                        componentSnapshot.emplace_back(component.get());
                    }
                }
            }
 
            for (auto component : componentSnapshot)
            {
                if (component != nullptr)
                {
                    if constexpr (std::is_same_v<std::invoke_result_t<TCallback, spk::Component *>, bool>)
                    {
                        if (p_callback(component) == false)
                        {
                            break;
                        }
                    }
                    else
                    {
                        p_callback(component);
                    }
                }
            }
        }
 
    public:
        Entity(const std::wstring &p_name, Entity *p_owner = nullptr);

        Entity();
 
        Entity(const Entity &) = delete;
        Entity &operator=(const Entity &) = delete;
 
        ~Entity() override;

        virtual void setName(const std::wstring &p_name);
        void setPriority(const int &p_priority);

        void addTag(const std::wstring &p_tag);
        void removeTag(const std::wstring &p_tag);
        void clearTags();
        bool containTag(const std::wstring &p_tag) const;

        void setEngine(GameEngine *p_engine);
        GameEngine *engine();
        const GameEngine *engine() const;

        const std::wstring &name() const;
        const std::set<std::wstring> &tags() const;
        int priority() const;
        size_t componentCount() const;

        void removeAllComponents();

        void addChild(Entity *p_child) override;
        void removeChild(Entity *p_child) override;
        void clearChildren();
        std::vector<Entity *> &children() override;
        const std::vector<Entity *> &children() const override;

        template <typename TComponentType, typename... TArgs>
        TComponentType &addComponent(TArgs &&...p_args)
        {
            static_assert(std::is_base_of_v<Component, TComponentType>, "TComponentType must inherit from Component");
            std::unique_ptr<TComponentType> newUniquePtr = std::make_unique<TComponentType>(std::forward<TArgs>(p_args)...);
            TComponentType *newComponent = newUniquePtr.get();
 
            {
                std::unique_lock<std::recursive_mutex> lock(_componentMutex);
 
                _components.emplace_back(std::move(newUniquePtr));
            }
 
            newComponent->_setOwner(this);
 
            newComponent->start();
            newComponent->activate();
            sortComponent();
 
            return (*newComponent);
        }

        void removeComponent(const std::wstring &p_name);

        template <typename TComponentType>
        TComponentType *getComponent(const std::wstring &p_name = L"")
        {
            std::unique_lock<std::recursive_mutex> lock(_componentMutex);
 
            for (std::unique_ptr<Component> &component : _components)
            {
                TComponentType *castedComponent = dynamic_cast<TComponentType *>(component.get());
                if (castedComponent != nullptr)
                {
                    if (p_name.empty() || castedComponent->name() == p_name)
                    {
                        return (castedComponent);
                    }
                }
            }
 
            return (nullptr);
        }

        template <typename TComponentType>
        std::vector<TComponentType *> getComponents()
        {
            std::unique_lock<std::recursive_mutex> lock(_componentMutex);
            std::vector<TComponentType *> result;
 
            for (std::unique_ptr<Component> &component : _components)
            {
                TComponentType *castedComponent = dynamic_cast<TComponentType *>(component.get());
                if (castedComponent != nullptr)
                {
                    result.emplace_back(castedComponent);
                }
            }
 
            return (result);
        }

        template <typename TComponentType>
        const TComponentType *getComponent(const std::wstring &p_name = L"") const
        {
            std::unique_lock<std::recursive_mutex> lock(_componentMutex);
            for (const std::unique_ptr<Component> &component : _components)
            {
                TComponentType *castedComponent = dynamic_cast<TComponentType *>(component.get());
                if (castedComponent != nullptr)
                {
                    if (p_name.empty() || castedComponent->name() == p_name)
                    {
                        return (castedComponent);
                    }
                }
            }
 
            return (nullptr);
        }

        template <typename TComponentType>
        std::vector<const TComponentType *> getComponents() const
        {
            std::unique_lock<std::recursive_mutex> lock(_componentMutex);
            std::vector<const TComponentType *> result;
 
            for (const std::unique_ptr<Component> &component : _components)
            {
                const TComponentType *castedComponent = dynamic_cast<const TComponentType *>(component.get());
                if (castedComponent != nullptr)
                {
                    result.emplace_back(castedComponent);
                }
            }
 
            return (result);
        }

        virtual void handleGeometryChange(const spk::Extend2D &p_geometry) final;
        virtual void handlePaintEvent(spk::PaintEvent &p_event) final;
        virtual void handleKeyPressEvent(spk::KeyPressEvent &p_event) final;
        virtual void handleKeyReleaseEvent(spk::KeyReleaseEvent &p_event) final;
        virtual void handleGlyphEvent(spk::GlyphEvent &p_event) final;
        virtual void handleMousePressEvent(spk::MousePressEvent &p_event) final;
        virtual void handleMouseReleaseEvent(spk::MouseReleaseEvent &p_event) final;
        virtual void handleMouseDoubleClickEvent(spk::MouseDoubleClickEvent &p_event) final;
        virtual void handleMouseMotionEvent(spk::MouseMotionEvent &p_event) final;
        virtual void handleMouseWheelEvent(spk::MouseWheelEvent &p_event) final;
        virtual void handleEnterResizeModeEvent(spk::EnterResizeModeEvent &p_event) final;
        virtual void handleResizeEvent(spk::ResizeEvent &p_event) final;
        virtual void handleExitResizeModeEvent(spk::ExitResizeModeEvent &p_event) final;
        virtual void handleQuitEvent(spk::QuitEvent &p_event) final;
        virtual void handleMoveEvent(spk::MoveEvent &p_event) final;
        virtual void handleFullScreenModeEvent(spk::FullScreenModeEvent &p_event) final;
        virtual void handleMaximizedModeEvent(spk::MaximizedModeEvent &p_event) final;
        virtual void handleFocusEvent(spk::FocusEvent &p_event) final;
        virtual void handleUpdateEvent(spk::UpdateEvent &p_event) final;

        void sortChildren();
        void sortComponent();

        Entity *getChild(const std::wstring &p_name);
        const Entity *getChild(const std::wstring &p_name) const;
        std::vector<Entity *> getChildren(const std::wstring &p_name);
        std::vector<const Entity *> getChildren(const std::wstring &p_name) const;
        bool contains(const std::wstring &p_name) const;
        size_t count(const std::wstring &p_name) const;

        Entity *getChildByTag(const std::wstring &p_tag);
        const Entity *getChildByTag(const std::wstring &p_tag) const;
        std::vector<Entity *> getChildrenByTag(const std::wstring &p_tag);
        std::vector<const Entity *> getChildrenByTag(const std::wstring &p_tag) const;
        bool containsTag(const std::wstring &p_tag) const;
        size_t countTag(const std::wstring &p_tag) const;

        Entity *getChildByTags(
            const std::span<const std::wstring> &p_tags, spk::BinaryOperator p_binaryOperator = spk::BinaryOperator::And);
        const Entity *getChildByTags(
            const std::span<const std::wstring> &p_tags, spk::BinaryOperator p_binaryOperator = spk::BinaryOperator::And) const;
        std::vector<Entity *> getChildrenByTags(
            const std::span<const std::wstring> &p_tags, spk::BinaryOperator p_binaryOperator = spk::BinaryOperator::And);
        std::vector<const Entity *> getChildrenByTags(
            const std::span<const std::wstring> &p_tags, spk::BinaryOperator p_binaryOperator = spk::BinaryOperator::And) const;
        bool containsTags(const std::span<const std::wstring> &p_tags, spk::BinaryOperator p_binaryOperator = spk::BinaryOperator::And) const;
        size_t countTags(const std::span<const std::wstring> &p_tags, spk::BinaryOperator p_binaryOperator = spk::BinaryOperator::And) const;
    };
}