ChildrenHandeler.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
#pragma once
#include <cassert>
 
#include "Framework/GameObject.h"
#include <vector>
#include <functional>
#include <ranges>
#include <set>
#include "Component.h"

#define LOG_CHILDREN_HANDELER 0
 

template <class C = Component>
class ChildrenHandeler : public GameObject
{
public:
    ChildrenHandeler<C>()
        : GameObject("ChildrenHandler", gobj::Type::Node, gobj::Type::ChildrenHandler)
        , children()
    {
    }

    ChildrenHandeler(const ChildrenHandeler& other)
        : GameObject("ChildrenHandler", gobj::Type::Node, gobj::Type::ChildrenHandler)
    {
        *this = other;
    }

    auto operator=(const ChildrenHandeler& other) -> ChildrenHandeler&
    {
        if (this == &other)
        {
            return *this;
        }
        GameObject::operator =(other);
 
        for (auto& [key, pointer] : other.children)
        {
            using namespace std;
            // deep copy everything in the other's vector
            auto copy = pointer->clone();
            // static cast from GameObject* to the correct object type
            auto copyCast = static_cast<C*>(copy.release());
            // We have to do weird catch and release thing because of unique pointers
            children[copyCast->getKey()] = (std::unique_ptr<C>(copyCast));
        }
 
        return *this;
    }
 

    ChildrenHandeler(ChildrenHandeler&& other) noexcept
        : GameObject(std::move(other))
        , children(std::move(other.children))
    {
    }
 

    auto operator=(ChildrenHandeler&& other) noexcept -> ChildrenHandeler&
    {
        if (this == &other)
        {
            return *this;
        }
        GameObject::operator =(std::move(other));
        children = std::move(other.children);
        return *this;
    }
 

    ~ChildrenHandeler() override = default;
 
 
    auto showMenu() -> void override
    {
        for (auto& [key, child] : children)
        {
            child->showMenu();
        }
    }
 
    auto update(float dt) -> void override
    {
        GameObject::update(dt);
 
 
        constexpr auto pointer = 1; // the child pointer to the second object in the pair
        using namespace std;
        for (auto& [key, child] : children)
        {
            hlg::Debug("    {} is updating child {}"
                     , getFormattedName()
                     , child->getFormattedName());
 
            if (!child->getInternalParent())
            {
                hlg::Error("{} doesn't have a parent. Something is very wrong", child->getFormattedName());
            }
 
            if (key.getUUID() != child->getUUID())
            {
                hlg::Error("key uuid {} does not match {}", key.getUUID(), child->getFormattedName());
            }
 
            child->update(dt);
        }
 
        static auto to_erase = [](auto& pair)
        {
            if (pair.second->destroyed())
            {
                hlg::Trace("{} was found to be destroyed, it will be removed"
                         , pair.second->getFormattedName()
                        );
                return pair.second->destroyed();
            }
            return false;
        };
        erase_if(children, to_erase);
    }
 
private:
    auto onUpdate(float dt) -> void override
    {
 
    }
 
public:
    auto endWindow() -> void override
    {
    }; // for debug ImGUI
 
 
    auto render() -> void override
    {
        GameObject::render();
        for (auto&& [key, child] : children)
        {
            hlg::Debug("    {} is rendering child {}", getFormattedName(), child->getFormattedName());
            child->render();
        }
    }
 
    auto onRender() -> void override
    {
    }
 
    auto onEnterEngine() -> void override
    {
        for (auto&& child : std::views::values(children))
        {
            child->checkAddToSceneHook();
        }
    }
 
 
    auto load(Stream& stream) -> void override
    {
        // @todo implement load for ChildrenHandler
        *this = stream.data();
    }
 
 
    auto save(Stream& stream) const -> void override
    {
        stream.data() = *this;
    }
 
 
    auto clone() const -> std::unique_ptr<GameObject> override
    {
        return std::make_unique<ChildrenHandeler>(*this);
    }
 
    auto setShouldUpdate(const bool _shouldUpdate) -> void override
    {
        GameObject::setShouldUpdate(_shouldUpdate);
 
        for (auto&& [key, child] : children)
        {
            child->setShouldUpdate(_shouldUpdate);
        }
    }
 
    auto setShouldRender(const bool _shouldRender) -> void override
    {
        GameObject::setShouldRender(_shouldRender);
 
        for (auto&& [key, child] : children)
        {
            child->setShouldRender(_shouldRender);
        }
    }
 
    auto setShouldReceiveMessages(const bool _shouldReceiveMessages) -> void override
    {
        GameObject::setShouldReceiveMessages(_shouldReceiveMessages);
 
        for (auto&& [key, child] : children)
        {
            child->setShouldReceiveMessages(_shouldReceiveMessages);
        }
    }
 
 
    auto add(std::unique_ptr<C> newChild) -> void
    {
        assert(newChild && "ChildHandler add was passed null unique_ptr");
        children[newChild->getKey()] = std::move(newChild);
    }

    auto for_each(std::function<void(C&)> func) -> void
    {
        for (auto& [key, child] : children)
        {
            func(*child);
        }
    }

    auto for_each(std::function<void(const C&)> func) const -> void
    {
        for (auto& [key, child] : children)
        {
            func(*child);
        }
    }

    auto for_each(std::function<void(GameObject&)> func) -> void
    {
        for (auto& [key, child] : children)
        {
            func(*child);
        }
    }

    auto for_each(std::function<void(const GameObject&)> func) const -> void override
    {
        for (auto& [key, child] : children)
        {
            func(*child);
        }
    }

    auto find(std::function<bool(C&)> predicate) -> C*
    {
        using namespace std;
        constexpr auto obj_ptr = 1;
        for (auto& child : children)
        {
            if (predicate(*get<obj_ptr>(child)))
            {
                // Get second part of pair, dereference that unique pointer,
                // then get the address of the object it's pointing at
                return &*get<obj_ptr>(child);
            }
 
        }
        return nullptr;
    }
 
    auto count() -> size_t
    {
        return children.size();
    }
 
    auto getChildren() const -> std::shared_ptr<std::vector<GameObject*>> override
    {
        return getChildrenRange();
    }

    auto getChildrenRange() const -> std::shared_ptr<std::vector<GameObject*>>
    {
 
        auto result = std::make_shared<std::vector<GameObject*>>();
        // copies every child from children to the vector
        for (auto& [key, ptr] : children)
        {
            result->push_back(ptr.get());
        }
        return result;
    }

    auto pop(Key key) -> std::unique_ptr<C>
    {
        auto itrToPtr = children.find(key);
        if (itrToPtr == children.end())
        {
            assert(false && "Tried to remove an object that doesn't exist");
            hlg::Error("Tried to remove an object that doesn't exist");
        }
        auto& [mapKey, ptr]        = *itrToPtr;
        std::unique_ptr<C> pointer = std::move(ptr);
        children.erase(itrToPtr);
        return pointer;
    }

    auto setParents(GameObject& parent) -> void
    {
        using namespace std;
        for (auto& child : children)
        {
            if (!(get<1>(child)->parentTo(&parent))) // second object at pos 1 is unique ptr to gameobject
            {
                assert(0 && "Setting parents in children handeler");
            }
        }
    }
 
    // these are the regular overload functions  
    template <typename C>
    friend auto to_json(json& j, const ChildrenHandeler<C>& ch) -> void;
    template <typename C>
    friend auto from_json(const json& j, ChildrenHandeler<C>& ch) -> void;
 
    // this is too access component and node ChildrenHandler from_json functions
    friend auto from_json(const json& j, ChildrenHandeler<C>& ch) -> void;
 
private:
    std::map<Key, std::unique_ptr<C>> children;
 
 
};
 
 
template <typename C>
inline auto to_json(json& j, const ChildrenHandeler<C>& ch) -> void
{
    j["GameObject"] = ch.getGameObjectJson();
    for (auto& child : ch.children)
    {
        j["children"].push_back(*(get<1>(child)));
    }
}

template <typename C>
auto from_json(const json& j, ChildrenHandeler<C>& ch) -> void
{
    /*for (const auto& child : j.at("children"))
    {
        C c = child.get<C>();
        ch.add(std::make_unique<C>(c));
    }*/
    assert(0 && "Children Handler with non-Node and non-Component");
    ch.setGameObjectJson(j.at("GameObject"));
}
 
auto BuildComponent(unsigned int comp, const json& j) -> Component*;