#include <tuple>
#include <iostream>
#include <utility>

template <typename... Ts>
class ModuleBase // Baza dla każdego modułu
{
public:

    template <typename... Us>
    ModuleBase(std::tuple<Us...>& _Tuple) :
        m_Modules(std::get<Ts>(_Tuple)...) {} // Magia, pobranie odpowiednich modułów z listy

    ModuleBase(const ModuleBase&) = delete;

    ModuleBase& operator = (const ModuleBase&) = delete;

protected:

    template <typename T>
    T& GetModule() { return std::get<T&>(m_Modules); }

    template <typename T>
    const T& GetModule() const { return std::get<T&>(m_Modules); }

private:

    const std::tuple<std::add_lvalue_reference_t<Ts>...> m_Modules; // Kontener na moduły, trzyma do nich referencje

};

class ModuleX : public ModuleBase<>
{
public:

    using ModuleBase::ModuleBase;

    int GetX() const { return m_X; }

private:

    int m_X = 10;

};

class ModuleY : public ModuleBase<>
{
public:

    using ModuleBase::ModuleBase;

    float GetY() const { return m_Y; }

private:

    float m_Y = 2.5f;

};

class ModuleA : public ModuleBase<ModuleX, ModuleY> // Zależności modułu w dziedziczeniu, tj. lista wszystkich modułów z jakich nasz moduł korzysta
{
public:

    using ModuleBase::ModuleBase; // Używamy konstruktora klasy bazowej, tu będzie trzeba pomyśleć

    void Init() // Init modułu, ta metoda tego wymaga do poprawnego działania jeśli pobieramy coś z innego modułu
    {
        m_ID = GetModule<ModuleX>().GetX();
        m_Number = GetModule<ModuleY>().GetY();
    }

    void Print() // Testowa metoda
    {
        std::cout << m_ID << ' ' << m_Number << '\n';
    }

private:

    int m_ID;
    float m_Number;

};

template <typename... Ts>
class ModulesCollection // Kontener na wszystkie moduły
{
public:

    ModulesCollection() :
        m_Modules(((void)std::conditional_t<true, int, Ts>{}, m_Modules)...) {} // Kolejna magia, zapewne jeszcze do poprawy

    template <typename T>
    T& GetModule() { return std::get<T>(m_Modules); }

    template <typename T>
    const T& GetModule() const { return std::get<T>(m_Modules); }

private:

    std::tuple<Ts...> m_Modules;

};

int main()
{
    // Tak wygląda część silnika odpowiedzialna za moduły
    ModulesCollection<
        ModuleX,
        ModuleY,
        ModuleA
    > Modules;
    // Jedyne co trzeba zrobić to wpisać moduł na listę (kolejność dowolna), I TYLE ^^

    Modules.GetModule<ModuleA>().Init();
    Modules.GetModule<ModuleA>().Print(); // 10 2.5
}