Component.hpp

/*
** EPITECH PROJECT, 2022
** gameEngine2
** File description:
** Component
*/
 
#ifndef COMPONENT_HPP_
#define COMPONENT_HPP_
 
#include "GameObject.hpp"
#include "IComponent.hpp"
#include "Input.hpp"
#include "Mouse.hpp"
#include "Profiler/KapProfiler.hpp"
 
namespace KapEngine {
    class GameObject;
    class Transform;
    class KEngine;
 
    namespace Events {
        class Input;
        class Mouse;
    }
 
    namespace SceneManagement {
        class Scene;
    }
}
 
#include <memory>
#include <vector>
#include <string>
 
namespace KapEngine {
 
    class Component : public IComponent {
        public:
            Component(std::shared_ptr<GameObject> &go, std::string const& name);
            Component(GameObject &go, std::string const& name);
            ~Component();
 
            void __update(bool runDisplay = true);
 
            bool __setId(std::size_t i) {
                PROFILER_FUNC_START();
                if (_id != 0) {
                    PROFILER_FUNC_END();
                    return false;
                }
                _id = i;
                PROFILER_FUNC_END();
                return true;
            }
 
            GameObject &getGameObject() const;
            std::size_t getGameObjectId() const;
 
            //updates functions
            virtual void onInit() override {}
            virtual void onAwake() override {}
            virtual void onStart() override {}
            virtual void onUpdate() override {}
            virtual void onFixedUpdate() override {}
 
            virtual void onDisplay() override {}
 
            virtual void onTriggerEnter(std::shared_ptr<GameObject> go) override {}
            virtual void onTriggerStay(std::shared_ptr<GameObject> go) override {}
            virtual void onTriggerExit(std::shared_ptr<GameObject> go) override {}
 
            virtual void onMouseEnter() override {}
            virtual void onMouseStay() override {}
            virtual void onMouseExit() override {}
 
            virtual bool checkComponentValidity() override {
                return true;
            }
 
            virtual void onGameQuit() override {}
            virtual void onDestroy() override {}
            virtual void onDisable() override {}
            virtual void onEnable() override {}
 
            virtual void onSceneUpdated() override {}
            virtual void onSceneGonnaUpdated() override {}
            virtual void onSceneChanged() override {}
 
            std::size_t getLevel() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _level;
            }
            void setLevel(std::size_t lvl) {
                PROFILER_FUNC_START();
                _level = lvl;
                PROFILER_FUNC_END();
            }
 
            bool isEnable() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _enable;
            }
 
            bool isDisable() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return !_enable;
            }
 
            void setActive(bool b) {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                _enable = b;
            }
 
            std::string getName() const {
                return _name;
            }
 
            void __engineStop() {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
            }
 
            int getThreadRunning() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return threadRunning;
            }
 
            Events::Input getInput();
            Events::Mouse getMouse();
 
            void addRequireComponent(std::string const& componentName) {
                PROFILER_FUNC_START();
                _componentsNeeded.push_back(componentName);
                PROFILER_FUNC_END();
            }
 
            void __fixedUpdate();
 
            void __awake();
 
            Transform &getTransform();
 
            std::size_t getId() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _id;
            }
 
            void __setPhysics(bool b) {
                PROFILER_FUNC_START();
                _physics = b;
                PROFILER_FUNC_END();
            }
 
            bool __isPhysics() const {
                return _physics;
            }
 
            void __sceneChanged() {
                PROFILER_FUNC_START();
                onSceneChanged();
                _awakeDone = false;
                _startDone = false;
                PROFILER_FUNC_END();
            }
 
            SceneManagement::Scene &getScene() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _scene;
            }
 
            KEngine &getEngine() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _engine;
            }
 
        protected:
            std::string _name;
        private:
            bool _physics = false;
            int threadRunning = 2;
            std::size_t _id = 0;
            std::size_t _level = 0;
            bool _enable = true;
            bool _awakeDone = false;
            bool _startDone = false;
            void __start();
            std::vector<std::string> _componentsNeeded;
            SceneManagement::Scene &_scene;
            KEngine &_engine;
            GameObject &obj;
 
            bool __checkValidity();
    };
 
}
 
#endif /* !COMPONENT_HPP_ */