World.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
#include "Core/Diagnostics/Assert.h"
#include "Core/Ecs/ComponentPool.h"
#include "Core/Ecs/Entity.h"
#include "Core/Ecs/EntityManager.h"
#include "Core/Ecs/ISystem.h"
#include "Core/Ecs/View.h"

 
namespace core {

class World {
public:
    [[nodiscard]] Entity createEntity();

    void destroyEntity(Entity entity);

    [[nodiscard]] bool isAlive(Entity entity) const;

    template <typename T>
    void addComponent(Entity entity, const T& component) {
        JADG_ASSERT(isAlive(entity), "Ajout d'un composant sur une entite morte.");
        poolFor<T>().add(entity, component);
    }

    template <typename T>
    [[nodiscard]] bool hasComponent(Entity entity) const {
        const ComponentPool<T>* pool = findPool<T>();
        return pool != nullptr && pool->has(entity);
    }

    template <typename T>
    [[nodiscard]] T& getComponent(Entity entity) {
        JADG_ASSERT(hasComponent<T>(entity), "L'entite ne possede pas ce composant.");
        return poolFor<T>().get(entity);
    }

    template <typename T>
    void removeComponent(Entity entity) {
        JADG_ASSERT(hasComponent<T>(entity), "L'entite ne possede pas ce composant.");
        poolFor<T>().remove(entity);
    }

    template <typename... Components>
    [[nodiscard]] View<Components...> view() {
        return View<Components...>(poolFor<Components>()...);
    }

    void addSystem(std::unique_ptr<ISystem> system);

    void update(float fixedDelta);

    [[nodiscard]] std::size_t systemCount() const;
 
private:
    template <typename T>
    ComponentPool<T>& poolFor() {
        const std::type_index key(typeid(T));
        auto iterator = _pools.find(key);
        if (iterator == _pools.end()) {
            iterator = _pools.emplace(key, std::make_unique<ComponentPool<T>>()).first;
        }
        return *static_cast<ComponentPool<T>*>(iterator->second.get());
    }

    template <typename T>
    const ComponentPool<T>* findPool() const {
        const auto iterator = _pools.find(std::type_index(typeid(T)));
        if (iterator == _pools.end()) {
            return nullptr;
        }
        return static_cast<const ComponentPool<T>*>(iterator->second.get());
    }

    EntityManager _entities;
    std::unordered_map<std::type_index, std::unique_ptr<IComponentPool>> _pools;
    std::vector<std::unique_ptr<ISystem>> _systems;
};
 
}  // namespace core