game_object.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
#include <typeinfo>
#include <cassert>
 
#include "../components/component.hpp"
#include "../../platform/mouse.hpp"
 
namespace cangine {
    class ObjectManager;
    class GameObject {
        private:
        std::vector<IComponent*> components; 
        bool pendingDestroy = false;         
        bool active = true;                  
        friend class ObjectManager;
        public:
        GameObject();
        virtual ~GameObject();
        virtual void onUpdate(double deltaTime);
        virtual void onMouseEvent(const MouseEvent* e);
        virtual void onDisable() {};
        virtual void onEnable() {};
 
        void destroy() {
            this->pendingDestroy = true;
        }
 
        template <typename T>
        void appendComponent(T* component) {
            if (component) {
                if (getComponent<T>() != nullptr && component->isUnique) {
                    assert(false && "Unique component already exist in gameobject");
                    return; 
                }
 
                component->gameObject = this;
                components.push_back(component);
 
                component->firstFrame();
            }
        }
        
        template <typename T>
        void destroyComponent() {
            for (auto it = components.begin(); it != components.end(); ++it) {
                if (dynamic_cast<T*>(*it)) {
                    delete *it;
                    components.erase(it);
                    return;
                }
            }
        }
 
        template <typename T>
        T* getComponent() {
            for (auto* component : components) {
                T* target = dynamic_cast<T*>(component);
                if (target != nullptr) {
                    return target;
                }
            }
            return nullptr;
        }
 
        template <typename T>
        std::vector<T*> getComponents() {
            std::vector<T*> result;
            for (auto* component : components) {
                T* target = dynamic_cast<T*>(component);
                if (target != nullptr) {
                    result.push_back(target);
                }
            }
            return result;
        }
 
        template <typename T, typename... Args>
        T* newComponent(Args&&... args) {
            T* component = new T(std::forward<Args>(args)...);
            this->appendComponent<T>(component);
            return component;
        }
 
        void setActive(bool a);
        bool isActive();
    };
}