The EntityManager class is responsible for managing entities within the ECS.

It stores and tracks entities in a vector, allows for their retrieval, and performs operations like adding and erasing entities.

namespace ecs {
    class EntityManager {
      public:
        EntityManager() = default;

        EntityManager(const std::size_t &id)
        {
            _entitys.push_back(id);
        }

        EntityManager(const Entity &id)
        {
            _entitys.push_back(id);
        }

        class EntityManagerError : std::exception {
          public:
            EntityManagerError(std::string message) : _message(message) {}

            ~EntityManagerError() = default;

            const char *what() const noexcept
            {
                return _message.c_str();
            }

          private:
            std::string _message;
        };

        void addEntity(const Entity &entity)
        {
            _entitys.push_back(entity);
        }

        Entity operator[](const std::size_t &idx)
        {
            if (idx > _entitys.size()) {
                throw EntityManagerError(ENTITY_MANAGER_ERROR_OUT_OF_RANGE);
            }
            return _entitys[idx];
        }

        void erase(const std::size_t &id)
        {
            for (std::size_t i = 0; i < _entitys.size(); ++i) {
                if (_entitys[i].getId() == id) {
                    _entitys.erase(_entitys.begin(), _entitys.begin() + i);
                    continue;
                }
                _entitys[i] = i + 1;
            }
        }

        std::size_t size() const
        {
            return _entitys.size();
        }

        Entity lastEntity() const
        {
            return _entitys[_entitys.size()];
        }

      private:
        std::vector<Entity> _entitys;
    };
}; // namespace ecs

Public Members:

• Constructors:
  • EntityManager()
    • Default constructor that initializes an empty EntityManager.
  • EntityManager(const std::size_t &id)
    • Constructor that creates an EntityManager with an initial entity based on a size/ID.
  • EntityManager(const Entity &id)
    • Constructor that creates an EntityManager with an initial entity based on an Entity object.

Public Methods:

• void addEntity(const Entity &entity)
  • Adds an Entity object to the manager by appending it to the internal vector of entities.
• Entity operator[](const std::size_t &idx)
  • Accesses an entity at the specified index.
  • Throws EntityManagerError if the index is out of range.
• void erase(const std::size_t &id)
  • Erases the entity with the specified ID from the manager.
  • This method loops through the internal entity vector and removes the entity matching the ID.
  • After removing, it adjusts the IDs of the remaining entities.
• std::size_t size() const
  • Returns the number of entities currently managed by the EntityManager.
• Entity lastEntity() const
  • Returns the last entity in the entity vector.
  • It may cause an out-of-bounds error if called when the entity vector is empty.

Nested Classes:

• EntityManagerError : public std::exception
  • Custom exception class for handling errors specific to the EntityManager.
  • Constructor:
    • EntityManagerError(std::string message): Initializes the error with a custom message.
  • Destructor:
    • ~EntityManagerError() = default: Default destructor.
  • const char *what() const noexcept:
    • Returns the error message. It overrides the standard std::exception::what() method to provide detailed information about the error.

Private Members:

• std::vector<Entity> _entitys:
  • The main data structure used to store the list of entities. It contains Entity objects.