The ComponentFactory class is responsible for creating and managing components for entities within the ECS architecture.

This factory reads configuration files, interprets component data, and attaches the respective components to the entities in the registry.

namespace ecs {
    class ComponentFactory {
      public:
        ComponentFactory(std::shared_ptr<Registry> &registry);
        ComponentFactory();
        ~ComponentFactory();

        void createEntity(const std::string &file);
        void createComponent(const Entity e, const std::string &component, const nlohmann::json &node);

      protected:
      private:
        std::shared_ptr<Registry> _r;

        void createPositionComponent(const Entity e, const nlohmann::json &node);
        void createSpriteComponent(const Entity e, const nlohmann::json &node);
        void createAnimationsComponent(const Entity e, const nlohmann::json &node);
        void createParallaxComponent(const Entity e, const nlohmann::json &node);
        void createTextComponent(const Entity e, const nlohmann::json &node);
        void createClickedComponent(const Entity e, const nlohmann::json &node);
        void createControllableComponent(const Entity e, const nlohmann::json &node);
        void createDrawableComponent(const Entity e, const nlohmann::json &node);
        void createFilledColorComponent(const Entity e, const nlohmann::json &node);
        void createHoverComponent(const Entity e, const nlohmann::json &node);
        void createMusicComponent(const Entity e, const nlohmann::json &node);
        void createOutlinedColorComponent(const Entity e, const nlohmann::json &node);
        void createScoreComponent(const Entity e, const nlohmann::json &node);
        void createShieldComponent(const Entity e, const nlohmann::json &node);
        void createSizeComponent(const Entity e, const nlohmann::json &node);
        void createSoundEffectComponent(const Entity e, const nlohmann::json &node);
        void createVelocityComponent(const Entity e, const nlohmann::json &node);
        std::unordered_map<std::string, std::function<void(const Entity, const nlohmann::json)>> functions;
    };

} // namespace ecs

Public Members:

• Constructor:
  • ComponentFactory(std::shared_ptr<Registry> &registry)
    • Initializes the ComponentFactory with a reference to a Registry instance to manage entities and components.
    • Registers various component creation functions (like position, drawable, sprite, etc.) in a map for later use.
  • ComponentFactory()
    • Default constructor for the ComponentFactory class.
  • Destructor:
    • ~ComponentFactory()
      • Destructor for cleaning up the ComponentFactory instance.
• void createEntity(const std::string &file)
  • Reads a configuration file (JSON format) to spawn a new entity and attach components to it based on the configuration.
  • Parameters:
    • file: The path to the configuration file that contains entity and component definitions.
  • Process:
    • Spawns a new entity using the registry.
    • Iterates through the components defined in the config file and creates them using createComponent.
• void createComponent(const Entity e, const std::string &component, const nlohmann::json &node)
  • Creates and attaches a component to an entity.
  • Parameters:
    • e: The entity to which the component will be attached.
    • component: The name of the component to create (like position, sprite, etc.).
    • node: A JSON node containing the component's properties and values.
  • Uses the function map (functions) to invoke the correct component creation function.

Private Members:

• std::shared_ptr<Registry> _r
  • Shared pointer to the Registry object that manages entities and their components.
  • Used for accessing and modifying entities and components.
• std::unordered_map<std::string, std::function<void(const Entity, const nlohmann::json)>> functions
  • A map of component names (std::string) to functions (std::function) that create components.
  • Each function takes an Entity and a nlohmann::json object (containing component data) as input.

Couple of Methods (main) :

ComponentFactory::ComponentFactory(std::shared_ptr<Registry> &r) : _r(r)
    {
        functions["position"] = [this](const Entity e, const nlohmann::json &node) {
            createPositionComponent(e, node);
        };
        functions["drawable"] = [this](const Entity e, const nlohmann::json &node) {
            createDrawableComponent(e, node);
        };
        functions["sprite"] = [this](const Entity e, const nlohmann::json &node) { createSpriteComponent(e, node); };
        functions["animations"] = [this](const Entity e, const nlohmann::json &node) {
            createAnimationsComponent(e, node);
        };
        functions["parallax"] = [this](const Entity e, const nlohmann::json &node) {
            createParallaxComponent(e, node);
        };
        functions["size"] = [this](const Entity e, const nlohmann::json &node) { createSizeComponent(e, node); };

        functions["text"] = [this](const Entity e, const nlohmann::json &node) { createTextComponent(e, node); };
        functions["clicked"] = [this](const Entity e, const nlohmann::json &node) { createClickedComponent(e, node); };
        functions["controllable"] = [this](const Entity e, const nlohmann::json &node) {
            createControllableComponent(e, node);
        };
        functions["filledColor"] = [this](const Entity e, const nlohmann::json &node) {
            createFilledColorComponent(e, node);
        };
        functions["hover"] = [this](const Entity e, const nlohmann::json &node) { createHoverComponent(e, node); };
        functions["music"] = [this](const Entity e, const nlohmann::json &node) { createMusicComponent(e, node); };
        functions["outlinedColor"] = [this](const Entity e, const nlohmann::json &node) {
            createOutlinedColorComponent(e, node);
        };
        functions["score"] = [this](const Entity e, const nlohmann::json &node) { createScoreComponent(e, node); };
        functions["shield"] = [this](const Entity e, const nlohmann::json &node) { createShieldComponent(e, node); };
        functions["soundEffect"] = [this](const Entity e, const nlohmann::json &node) {
            createSoundEffectComponent(e, node);
        };
        functions["velocity"] = [this](const Entity e, const nlohmann::json &node) {
            createVelocityComponent(e, node);
        };
    }

    ComponentFactory::~ComponentFactory() {}

    void ComponentFactory::createEntity(const std::string &file)
    {
        std::ifstream f(file);
        nlohmann::json config = nlohmann::json::parse(f);

        Entity e = _r->spawn_entity();
        _r->_entitys.addEntity(e);

        for (auto &c : config["active"]) {
            createComponent(e, c, config["components"][c]);
        }
    }

    void ComponentFactory::createComponent(const Entity e, const std::string &name, const nlohmann::json &node)
    {
        functions[name](e, node);
    }

    void ComponentFactory::createPositionComponent(const Entity e, const nlohmann::json &node)
    {
        auto &pos_array = _r->register_if_not_exist<component::Position>();

        pos_array[e.getId()] = component::Position{node["x"], node["y"]};
    }

    void ComponentFactory::createDrawableComponent(const Entity e, const nlohmann::json &node)
    {
        auto &drawable_array = _r->register_if_not_exist<component::Drawable>();

        drawable_array[e.getId()] = component::Drawable{node};
    }

    void ComponentFactory::createSpriteComponent(const Entity e, const nlohmann::json &node)
    {
        auto &sprite_array = _r->register_if_not_exist<component::Sprite>();

        sprite_array[e.getId()] = component::Sprite{node};
    }

    void ComponentFactory::createAnimationsComponent(const Entity e, const nlohmann::json &node)
    {
        auto &animations_array = _r->register_if_not_exist<component::Animations>();

        component::Object type = component::Background;
        if (node["type"] == "player")
            type = component::Player;
        else if (node["type"] == "weapon")
            type = component::Weapon;
        else if (node["type"] == "ennemies")
            type = component::Ennemies;
        else if (node["type"] == "background")
            type = component::Background;

        animations_array[e.getId()] = component::Animations{
            sf::Clock(), node["width"], node["height"], node["x"], node["y"], node["rotation"], type
        };
    }

Private Methods:

• Component Creation Methods:
  • These private methods handle the creation of specific components and register them with the entity.
  • void createPositionComponent(const Entity e, const nlohmann::json &node)
    • Creates a Position component and attaches it to the entity.
    • The position data (x and y coordinates) is extracted from the JSON node.
    • Component Data:
      • x: X-coordinate of the position.
      • y: Y-coordinate of the position.
  • void createDrawableComponent(const Entity e, const nlohmann::json &node)
    • Creates a Drawable component and attaches it to the entity.
    • Component Data:
      • Depends on the Drawable properties stored in the JSON node.
  • void createSpriteComponent(const Entity e, const nlohmann::json &node)
    • Creates a Sprite component and attaches it to the entity.
    • Component Data:
      • Information for the sprite is extracted from the JSON node.
  • void createAnimationsComponent(const Entity e, const nlohmann::json &node)
    • Creates an Animations component and attaches it to the entity.
    • Component Data:
      • Contains properties such as width, height, x/y coordinates, rotation, and the type of animation (like player, weapon, ennemies, background).
    • Uses the type field in the JSON node to determine the type of object the animation belongs to (e.g., Player, Weapon).
  • Other Component Creation Methods:
    • Similarly, the following methods create and attach respective components using the data from the JSON node:These methods follow the same pattern: extracting relevant component data from the JSON node and registering the component with the entity in the registry.
      • void createParallaxComponent(const Entity e, const nlohmann::json &node)
      • void createTextComponent(const Entity e, const nlohmann::json &node)
      • void createClickedComponent(const Entity e, const nlohmann::json &node)
      • void createControllableComponent(const Entity e, const nlohmann::json &node)
      • void createFilledColorComponent(const Entity e, const nlohmann::json &node)
      • void createHoverComponent(const Entity e, const nlohmann::json &node)
      • void createMusicComponent(const Entity e, const nlohmann::json &node)
      • void createOutlinedColorComponent(const Entity e, const nlohmann::json &node)
      • void createScoreComponent(const Entity e, const nlohmann::json &node)
      • void createShieldComponent(const Entity e, const nlohmann::json &node)
      • void createSoundEffectComponent(const Entity e, const nlohmann::json &node)
      • void createVelocityComponent(const Entity e, const nlohmann::json &node)