GameObject.hpp

#ifndef GAME_OBJECT_H
#define GAME_OBJECT_H

#include <string>

namespace ae3d
{
    class GameObject
    {
    public:
        static const unsigned InvalidComponentIndex = 99999999;

        template< class T > void AddComponent()
        {
            const unsigned index = GetNextComponentIndex();
            
            if (index != InvalidComponentIndex)
            {
                components[ index ].handle = T::New();
                components[ index ].type = T::Type();
                GetComponent< T >()->gameObject = this;
            }            
        }

        template< class T > void RemoveComponent()
        {
            for (unsigned i = 0; i < nextFreeComponentIndex; ++i)
            {
                if (components[ i ].type == T::Type())
                {
                    GetComponent< T >()->gameObject = nullptr;
                    components[ i ].handle = 0;
                    components[ i ].type = -1;
                    return;
                }
            }
        }

        template< class T > T* GetComponent() const
        {
            for (const auto& component : components)
            {
                if (T::Type() == component.type)
                {
                    return T::Get( component.handle );
                }
            }

            return nullptr;
        }

        GameObject() = default;

        GameObject( const GameObject& other );

        GameObject& operator=( const GameObject& go );

        void SetName( const char* aName ) { name = aName; }
        
        void SetEnabled( bool enabled ) { isEnabled = enabled; }
        
        bool IsEnabled() const;
    
        const std::string& GetName() const { return name; }
        
        void SetLayer( unsigned aLayer ) { layer = aLayer; }

        unsigned GetLayer() const { return layer; }

        std::string GetSerialized() const;

    private:
        struct ComponentEntry
        {
            int type = -1;
            unsigned handle = 0;
        };

        unsigned GetNextComponentIndex();

        static const int MaxComponents = 10;
        unsigned nextFreeComponentIndex = 0;
        ComponentEntry components[ MaxComponents ];
        std::string name;
        unsigned layer = 1;
        bool isEnabled = true;
    };
}
#endif