GameObject.hpp

/*
** EPITECH PROJECT, 2022
** gameEngine2
** File description:
** GameObject
*/
 
#ifndef GAMEOBJECT_HPP_
#define GAMEOBJECT_HPP_
 
#include "Component.hpp"
#include "Scene.hpp"
#include "Entity.hpp"
#include "Type.hpp"
 
#if KAPENGINE_BETA_ACTIVE
    #if KAPENGINE_THREAD_ACTIVE
        #include <mutex>
    #endif
#endif
 
namespace KapEngine {
 
    class Component;
    class KEngine;
    class Entity;
 
    namespace SceneManagement {
        class Scene;
    }
}
 
#include <vector>
#include <memory>
#include <string>
#include <typeinfo>
 
namespace KapEngine {
 
    class GameObject : public Entity {
        public:
            GameObject(SceneManagement::Scene &scene, std::string const& name);
            ~GameObject();
 
            //all function can be called by dev
 
            void addComponent(std::shared_ptr<Component> comp);
            void removeComponent(std::shared_ptr<Component> comp);
            void removeComponent(std::size_t id);
 
            Component &getComponent(std::string const& componentName);
 
            template<typename T, typename = std::enable_if<std::is_base_of<Component, T>::value>>
            T &getComponent(std::string const& componentName) {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return dynamic_cast<T &>(getComponent(componentName));
            }
            template<typename T, typename = std::enable_if<std::is_base_of<Component, T>::value>>
            T &getComponent() {
                std::size_t hash = Type::getHashCode<T>();
                for (std::size_t i = 0; i < _components.size(); i++) {
                    std::size_t componentHash = Type::getHashCode(*_components[i]);
                    if (_components[i] && componentHash == hash) {
                        return dynamic_cast<T &>(*_components[i]);
                    }
                }
                for (std::size_t i = 0; i < _componentsRun.size(); i++) {
                    std::size_t componentHash = Type::getHashCode(*_componentsRun[i]);
                    if (_componentsRun[i] && componentHash == hash) {
                        return dynamic_cast<T &>(*_componentsRun[i]);
                    }
                }
                throw Errors::GameObjectError("No component found");
            }
            template<typename T, typename = std::enable_if<std::is_base_of<Component, T>::value>>
            std::vector<std::shared_ptr<T>> getComponents() {
                PROFILER_FUNC_START();
                std::vector<std::shared_ptr<T>> components;
                std::size_t hash = Type::getHashCode<T>();
                for (std::size_t i = 0; i < _components.size(); i++) {
                    std::size_t componentHash = Type::getHashCode(*_components[i]);
                    if (_components[i] && componentHash == hash)
                        components.push_back(std::dynamic_pointer_cast<T>(_components[i]));
                }
                for (std::size_t i = 0; i < _componentsRun.size(); i++) {
                    std::size_t componentHash = Type::getHashCode(*_componentsRun[i]);
                    if (_componentsRun[i] && componentHash == hash)
                        components.push_back(std::dynamic_pointer_cast<T>(_componentsRun[i]));
                }
                PROFILER_FUNC_END();
                return components;
            }
 
            bool hasComponent(std::string const& componentName) const;
 
            template<typename T, typename = std::enable_if<std::is_base_of<Component, T>::value>>
            bool hasComponent() const {
                PROFILER_FUNC_START();
                std::size_t hash = Type::getHashCode<T>();
                for (std::size_t i = 0; i < _components.size(); i++) {
                    std::size_t componentHash = Type::getHashCode(*_components[i]);
                    if (_components[i] && componentHash == hash) {
                        PROFILER_FUNC_END();
                        return true;
                    }
                }
                for (std::size_t i = 0; i < _componentsRun.size(); i++) {
                    std::size_t componentHash = Type::getHashCode(*_componentsRun[i]);
                    if (_componentsRun[i] && componentHash == hash) {
                        PROFILER_FUNC_END();
                        return true;
                    }
                }
                return false;
            }
 
            KEngine &getEngine();
 
            #if KAPENGINE_BETA_ACTIVE
                #if KAPENGINE_THREAD_ACTIVE
                    void __updatePhysics();
                    void __updateComponents();
                    void __updateDisplay();
                #else
                    void __update();
                    void __updateDisplay();
                #endif
            #else
 
                void __update(bool physics = false, bool runDisplay = true);
                void __updateDisplay();
            #endif
 
            void setActive(bool b);
            bool isActive() const {
                return _active;
            }
            bool isDestroyed() const {
                return _destroyed;
            }
 
            SceneManagement::Scene &getScene() {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _scene;
            }
 
            SceneManagement::Scene &getSceneConst() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _scene;
            }
 
            Component &getTransform();
 
            void __engineStop();
 
            std::string getName() const {
                return _name;
            }
 
            Entity &getEntity() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return (Entity &)*this;
            }
 
            void __destroyIt();
            void __init();
            void __stoppingGame();
            void __onSceneGonnaUpdated();
            void __onSceneUpdated();
 
            void dump(bool displayComponent = false, std::string prefix = "");
 
            std::vector<std::shared_ptr<Component>> getAllComponents() const;
 
            void destroy();
 
            void __setPrefab(std::string const& name);
 
            std::string getPrefabName() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _prefabName;
            }
 
            void setName(std::string const& name) {
                PROFILER_FUNC_START();
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.lock();
                    #endif
                #endif
                _name = name;
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.unlock();
                    #endif
                #endif
                PROFILER_FUNC_END();
            }
 
            void setTag(std::string const& tag) {
                PROFILER_FUNC_START();
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.lock();
                    #endif
                #endif
                _tag = tag;
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.unlock();
                    #endif
                #endif
                PROFILER_FUNC_END();
            }
 
            std::string getTag() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _tag;
            }
 
            void __onSceneChanged();
 
        protected:
        private:
            std::string _name;
            bool _active = true;
            bool _startActive = true;
            bool _destroyed = false;
            bool _firstUpdateDone = false;
            std::vector<std::shared_ptr<Component>> _components;
            std::vector<std::shared_ptr<Component>> _componentsRun;
            SceneManagement::Scene &_scene;
            std::size_t _idComp = 0;
            std::string _prefabName;
            std::string _tag;
            #if KAPENGINE_BETA_ACTIVE
                #if KAPENGINE_THREAD_ACTIVE
                    std::mutex _mutex;
                #endif
            #endif
    };
 
}
 
#endif /* !GAMEOBJECT_HPP_ */