wEntity.hpp

Go to the documentation of this file.

/*
+---------------------------------------------------------------------------------------------------------------------------------------------------+
Created by Wilfried Koch.
Copyright @ 2025 Wilfried Koch. All rights reserved.
+---------------------------------------------------------------------------------------------------------------------------------------------------+
*/
 
#ifndef W_ENTITY_HPP
#define W_ENTITY_HPP
 
#include <memory>
#include <unordered_map>
#include <stdexcept>
#include <type_traits>
 
#include "wComponent.hpp"
 
namespace wEngine
{
 
    /*
     * @brief Generates a new unique component type ID.
     * @return A unique integer for component type identification.
     */
    inline std::size_t getNextComponentTypeID( )
    {
        static std::size_t componentTypeCounter = 0;
        return componentTypeCounter++;
    }
 
    /*
     * @brief Returns the unique type ID associated with a specific component type.
     * @tparam ComponentType The type of the component.
     * @return A unique integer identifying the component type.
     */
    template< typename ComponentType >
    std::size_t getComponentTypeID( ) noexcept
    {
        static std::size_t componentTypeID = getNextComponentTypeID( );
        return componentTypeID;
    }

    class Entity
    {
        public:
            /*
             * @brief Default constructor. Generates a new entity with a unique ID.
             */
            Entity( );
 
            /*
             * @brief Destructor. Disables all attached components before destruction.
             */
            virtual ~Entity( );

            [[nodiscard]] unsigned int getEntityID( ) const;

            void clearComponents( );

            static void resetEntityIDCounter( );

            template< typename T, typename... Args >
            std::shared_ptr< T > addComponent( Args&&... args )
            {
                static_assert( std::is_base_of< Component, T >::value, "T must be derived from Component" );
 
                auto typeID = getComponentTypeID< T >( );
                if (mComponents.contains( typeID ))
                {
                    std::cerr << "Warning: Component " << typeid( T ).name( )
                              << " already exists in entity " << mEntityID << std::endl;
                    throw std::runtime_error( "Component already exists in entity" );
                }
 
                auto component = std::make_shared< T >( std::forward< Args >( args )... );
                component->setParent( this );
                mComponents[ typeID ] = component;
 
                return component;
            }

            template< typename T >
            void removeComponent( )
            {
                static_assert( std::is_base_of< Component, T >::value, "T must be derived from Component" );
 
                auto typeID = getComponentTypeID< T >( );
                mComponents.erase( typeID );
            }

            template< typename T >
            [[nodiscard]] bool hasComponent( ) const noexcept
            {
                static_assert( std::is_base_of< Component, T >::value, "T must be derived from Component" );
 
                return mComponents.contains( getComponentTypeID< T >( ) );
            }

            template< typename T >
            [[nodiscard]] std::shared_ptr< T > getComponent( ) const
            {
                static_assert( std::is_base_of< Component, T >::value, "T must be derived from Component" );
 
                auto typeID = getComponentTypeID< T >( );
                auto it = mComponents.find( typeID );
                if (it != mComponents.end( ))
                {
                    return std::dynamic_pointer_cast< T >( it->second );
                }
 
                return nullptr;
            }

            template< typename T >
            [[nodiscard]] std::shared_ptr< T > requireComponent( const std::string& context = "" ) const
            {
                static_assert( std::is_base_of< Component, T >::value, "T must be derived from Component" );
 
                if (!hasComponent< T >( ))
                {
                    std::string msg = "Missing required component: ";
                    msg += typeid( T ).name( );
                    if (!context.empty( ))
                    {
                        msg += " in context: " + context;
                    }
                    throw std::runtime_error( msg );
                }
 
                return getComponent< T >( );
            }

            template< typename Interface >
            [[nodiscard]] std::shared_ptr< Interface > getInterfaceComponent( ) const
            {
                for (const auto& [ typeID, component ] : mComponents)
                {
                    auto interfaceComponent = std::dynamic_pointer_cast< Interface >( component );
                    if (interfaceComponent)
                    {
                        return interfaceComponent;
                    }
                }
                return nullptr;
            }
 
        private:
            unsigned int mEntityID;
            std::unordered_map< std::size_t, std::shared_ptr< Component > > mComponents;
 
            static unsigned int sEntityIDCounter;
            static unsigned int generateNextEntityID( );
    };
 
}// End of namespace wEngine
 
#endif