GameObject.h

#ifndef HB_GAME_OBJECT_H
#define HB_GAME_OBJECT_H
#include <algorithm>
#include <initializer_list>
#include <map>
#include <string>
#include <typeindex>
#include <unordered_map>
#include <vector>
#include "DataRepository.h"
#include "Log.h"
#include "MessageManager.h"
#include "Transform.h"

namespace hb
{
    typedef MessageManager<DataRepository> GameObjectMessageManager;
    class GameObject : public Transform
    {
    public:
        class Component
        {
        public:
            friend class GameObject;
            Component():
            m_active(true),
            m_game_object(nullptr)
            {}
            virtual ~Component(){}
            virtual void init(){}
            virtual void preUpdate(){}
            virtual void update(){}
            virtual void postUpdate(){}
            GameObject* getGameObject() const {return m_game_object;}
            void setActive(bool active)
            {m_active = active;}
            bool isActive() const
            {return m_active;}

        protected:
            void addListenerToGameObject(const std::string& name, std::function<void(DataRepository&)>&& listener)
            {
                hb_assert(m_game_object != nullptr, "Accessing Component's GameObject before being assigned.");
                getGameObject()->m_message_manager.listen(name, std::move(listener));
            }
            void ignoreToGameObject(const GameObjectMessageManager::ListenerId<DataRepository>& listener_id)
            {
                hb_assert(m_game_object != nullptr, "Accessing Component's GameObject before being assigned.");
                getGameObject()->m_message_manager.ignore(listener_id);
            }

        private:
            void setGameObject(GameObject* game_object)
            {m_game_object = game_object;}

            bool m_active;
            GameObject* m_game_object;
        };

        static GameObject* getGameObjectById(int id);
        static const std::vector<GameObject*>& getGameObjectsByName(const std::string& name);
        static void destroyAll();
        static void updateAll();

        GameObject();
        GameObject(const std::initializer_list<Component*>& components);
        ~GameObject();
        int getId() const;
        const std::string& getName() const;
        void setName(const std::string& name);
        void setActive(bool active);
        bool isActive() const;
        void preUpdate();
        void update();
        void postUpdate();
        void destroy();
        void addComponent(Component* component);
        void addComponents(const std::vector<Component*>& components);
        template <typename ComponentType>
        ComponentType* getComponent() const
        {
            for (Component* component : m_components)
            {
                if (dynamic_cast<ComponentType*>(component))
                    return dynamic_cast<ComponentType*>(component);
            }
            return nullptr;
        }
        template <typename ComponentType>
        std::vector<ComponentType*> getComponents() const
        {
            std::vector<ComponentType*> r;
            for (Component* component : m_components)
            {
                if (dynamic_cast<ComponentType*>(component))
                    r.push_back(dynamic_cast<ComponentType*>(component));
            }
            return r;
        }
        void sendMessage(const std::string& name, DataRepository& data);
        static void setNextGameObjectId(int id);
        GameObject(int id);

    private:
        static int s_game_object_identifier;
        static std::unordered_map<int, GameObject*> s_game_objects_by_id;
        static std::unordered_map<std::string, std::vector<GameObject*>> s_game_objects_by_name;
        static DataRepository s_data_repository;

        bool m_active, m_marked_to_destroy;
        int m_identifier;
        std::string m_name;
        std::vector<Component*> m_components;
        GameObjectMessageManager m_message_manager;
    };
}
#endif