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/Path/Path.h"
 
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));
    }

    [[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 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;
 
 
    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);
    }
    
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;
};
 
// 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 test
{
auto entityTest() -> void;
}
 
namespace gobj
{

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