Ignite est une implementation simpliste d'Entity-Component-System (ECS) en C#.

Une node est un object réprésenté par une ID (ulong) en ECS. Dans Ignite, les nodes sont aussi des conteneurs de composents et peuvent etre organisées dans une hierarchie de nodes.

  
    class Node
    {
        ulong ID;
        Node Parent;
        List<Node> Children;
        List<IComponent> Components;
    }
            

On peut alors chercher les composents présents sur la node avec la fonction suivante :

  
    bool HasComponent<T>() where T : IComponent
    {
        for(var component in Components)
        {
            if (component.GetType() == typeof(T))
                return true; // found a component of type T !
        }
        return false;
    }
            

Bien que fonctionnel, cette fonction en O(n) va devenit fortement inefficiente lors d'un grand nombre d'itérations. Pour résoudre ce problème, il est plus simple de chercher un composent par son UID, pour cela, il suffit de rajouter une liste des UID des composents présents sur la node.

  
    Hashset<int> ComponentIndex;
            

Grace à çà, on va pouvoir simplifier notre fonction, la faisant passer de O(n) a O(1) :

  
    bool HasComponent(int index)
    {
        return ComponentIndex.Contains(index);
    }
            

Pour récuperer l'UID d'un composent, on utilise une ComponentLookupTable qui nous permet de coupler un type avec une UID.

  
    class ComponentLookupTable
    {
        ImmutableDictionary<Type, int> ComponentIndex;

        //Get ID from Type
        int this[Type type] => ComponentIndex[type];
    }
            

Dans Ignite, les ID des nodes fonctionne d'une façon un peu étrange, elles sont codées sur un ulong de 64 octets divisé en 3 parties.

• The first 32 bytes represent the node id.
• Then the next 16 bytes represent the node generation.
• And the last 16 bytes are used as flags to help us manage the state of the node.

This allow us to have 2⁴⁸ different IDs in addition to let us query for nodes with certain flags.
This method come from this post from Sander Mertens the creator of Flecs.

A component is a datatype that can be added to or removed from nodes. Components in ECS are generally plain data types and not encapsulated and Ignite components are no exception.

A system is an executable object that is matched with all nodes that have a certain set of components using a filter. At runtime, every nodes with matching components will be registerd in the system. The system will then execute some code we've made for each nodes registered.

A context is a tracker object that register valid nodes for a system. It allow us to process nodes more efficiently when a system execute itself.

A world is where all ECS data is stored. In Ignite we can have multiple worlds which can communicate with each. This allow us to dissociate data and logic through multiple environnements.