Entity.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
 
#pragma once
 
 
#include <vector>
 
#include "Component.h"
#include "ChildrenHandeler.h"
#include "Framework/Engine.h"
#include "System/Messaging.h"
#include "Framework/Factory.h"
#include <memory>
 
#include "Component/ActionList.h"
#include "Utility/Messages/AddedComponentMessage.h"
#include "Utility/Path/Path.h"
 
struct Script;
class Action;
 
class Entity : public GameObject
{
public:
#define HAS(type) GetComponent<type>(Component::c##type)
 
    Entity();
    Entity(const Entity& other);
    ~Entity() override;
 
    auto clone() const -> std::unique_ptr<GameObject> override;
 
    auto showMenu() -> void override;
    auto update(float dt) -> void override;
    auto onUpdate(float dt) -> void override;
 
    auto endWindow() -> void override
    {
    }; // for debug ImGUI
    auto render() -> void override;
    auto onRender() -> void override;
    auto onEnterEngine() -> void override;
    auto onSceneStart(const std::string& sceneName) -> void override;
    auto onSceneExit(const std::string& sceneName) -> void override;
    auto for_each(std::function<void(GameObject&)> func) -> void override;
    auto for_each(std::function<void(const GameObject&)> func) const -> void override;
    auto load(const Stream& stream) -> void override;       // we may need to return something, not sure
    auto save(Stream& stream) const -> void override; // we may need to return something, not sure
 
 
    auto getParent() const -> Entity* override;
    auto destroy() -> void override;
 

    auto setShouldUpdate(bool _shouldUpdate) -> void override;

    auto setShouldRender(bool _shouldRender) -> void override;

    auto setShouldReceiveMessages(bool _shouldReceiveMessages) -> void override;

    auto pop() -> std::unique_ptr<Node>;

    template <typename type>
    auto GetComponent(Component::ComponentTypeEnum typeId) -> type*
    {
        return static_cast<type*>(this->Get(typeId));
    }
    
    template <typename comp>
    auto GetComponent() -> comp*
    {
        auto typeId = comp::getEnum();
        return static_cast<comp*>(this->Get(typeId));
    }

    [[nodiscard]] auto addChild(std::unique_ptr<GameObject> newChild) -> bool override;
 
    auto addChild(std::unique_ptr<Entity> newChild) -> bool;

    auto addComponent(std::unique_ptr<Component>&& component) -> void;

    auto addComponent(std::unique_ptr<GameObject> component) -> bool;

    template <std::derived_from<Component> T>
    auto addComponent(const T& component) -> void
    {
        addComponent(component.clone());
    }
 

    template <std::derived_from<Component> T>
    auto addComponent(std::unique_ptr<T> component) -> void
    {
        addComponent(std::unique_ptr<Component>(component.release()));
    }

    auto popComponent(const Key& key) -> std::unique_ptr<Component>;
    
    auto deregisterComponents() const -> void
    {
        auto messaging = Engine::getSystem<sys::Messaging>();
        // call remove all with every component
        components.for_each([&](const Component& component)
        {
            messaging->removeAll(&component);
        });
    }
 
    friend auto to_json(json& j, const Entity& obj) -> void;
    friend auto from_json(const json& j, Entity& obj) -> void;
 

    auto showComponentsMenu() -> void;
 
 
// We have action_functions inside of entity for easier access (you don't need to get the ActionList component 
//   every time)
#pragma region action_functions
 
    template<typename ActionType>
    auto operator<<(const ActionType& action) -> Entity&
    {
        auto actionList = GetComponent<ActionList>(Component::cActionList);
        assert(actionList && "Tried adding an action to an entity without an actionList");
        actionList->pushBack(action);
    
        return *this;
    }
 
    
    template<typename ActionType>
    auto addAction(const ActionType& action) -> void
    {
        ActionList* actionList;
        if (!((actionList = GetComponent<ActionList>(Component::cActionList))))
        {
            addComponent(th::Factory::make<ActionList>("Default/ActionList"));
            actionList = GetComponent<ActionList>(Component::cActionList);
        }
        assert(actionList && "failed adding an Action to an Entity");
        actionList->pushBack(action);
    }
    
    template<typename ActionType>
    auto addActionToFront(const ActionType& action) -> void
    {
        ActionList* actionList;
        if (!((actionList = GetComponent<ActionList>(Component::cActionList))))
        {
            addComponent(th::Factory::make<ActionList>("Default/ActionList"));
            actionList = GetComponent<ActionList>(Component::cActionList);
        }
        assert(actionList && "failed adding an Action to an Entity");
        actionList->pushFront(action);
    }
    
    template<typename ActionType>
    auto insertAction(const ActionType& action, int position) -> void
    {
        ActionList* actionList;
        if (!((actionList = GetComponent<ActionList>(Component::cActionList))))
        {
            addComponent(th::Factory::make<ActionList>("Default/ActionList"));
            actionList = GetComponent<ActionList>(Component::cActionList);
        }
        assert(actionList && "failed adding an Action to an Entity");
        actionList->pushFront(action);
    }

    auto clearActions() -> void
    {
        if (auto actionList = GetComponent<ActionList>(Component::cActionList))
        {
            actionList->clear();
        }
    }
 

    auto getAction(const std::string& actionName) -> Action*
    {
        if (auto actionList = GetComponent<ActionList>(Component::cActionList))
        {
            return actionList->getAction(actionName);
        }
        return nullptr;
    }
    
    auto removeAction(const std::string& actionName) -> void
    {
        if (auto actionList = GetComponent<ActionList>(Component::cActionList))
        {
            actionList->removeAction(actionName);
        }
    }
    
#pragma endregion
    
    auto operator[](const std::string& scriptName) -> Script&;
 

    auto contains(const std::string& scriptName) -> bool;

    auto getScript(const std::string& scriptName ) -> Script&;
    

    static auto bindLuaTypes(sol::state& lua) -> void;
 
protected:
    auto getChildren() const -> std::shared_ptr<std::vector<GameObject*>> override;
 
 
    //------------------------------------------------------------------------------
    // Private Variables:
    //------------------------------------------------------------------------------
private:
    ChildrenHandeler<Component> components;
 
    //------------------------------------------------------------------------------
    // Private Functions:
    //------------------------------------------------------------------------------

    auto Get(Component::ComponentTypeEnum typeId) -> Component*;
 

    auto addComponentButton() -> void;

    auto showUpdateRenderMessagesFlagButtons() -> void;

    auto showNameInputMenu() -> void;

    auto sendAddedComponentMessage(AddedComponentMessage& message) -> void;
    
    auto addChildLua(std::unique_ptr<GameObject>& newChild) -> bool;
};
 
// This two have be non-member functions

template<typename ActionType>
auto operator<<(gobj::Path<Entity>& entity, const ActionType& action) -> gobj::Path<Entity>&
{
    auto actionList = entity->GetComponent<ActionList>(Component::cActionList);
    assert(actionList && "Tried adding an action to an entity without an actionList");
    actionList->pushBack(action);
    
    return entity;
}
 

template<typename ActionType>
auto operator<<(Entity* entity, const ActionType& action) -> Entity&
{
    auto actionList = entity->GetComponent<ActionList>(Component::cActionList);
    assert(actionList && "Tried adding an action to an entity without an actionList");
    actionList->pushBack(action);
    
    return *entity;
}
 
namespace gobj
{

auto moveEntity(Entity& entityToMove, Entity& newParent) -> void;
 
 
}