Héritage

L’héritage relie une entité instance à une base avec IsA. Les composants sont copiés dans l’instance et deviennent owned par défaut ; ceux qui doivent rester partagés peuvent choisir explicitement le mode shared.

Créer une base et une instance

C

ecs_entity_t enemy_base = ecs_new();
ecs_set(enemy_base, Health, { .value = 100 });

ecs_entity_t enemy = ecs_new();
ecs_is_a(enemy, enemy_base);

C++

auto enemy_base = ecs::entity::create();
enemy_base.set(Health{ .value = 100 });

auto enemy = ecs::entity::create().is_a(enemy_base);

Lire et remplacer

Une instance reçoit une copie owned des composants hérités par défaut. Pour remplacer la valeur sur l’instance, écrivez simplement le composant local. Les composants configurés shared restent stockés sur la base et doivent être traités comme des données en lecture seule.

C

ecs_add(enemy, Health);
ecs_set(enemy, Health, { .value = 50 });

C++

enemy.add<Health>();
enemy.set(Health{ .value = 50 });

Utilisez ecs_is(entity, base) ou entity.is_a(base) pour vérifier la chaîne d’héritage. Le terme ecs_up(Component, Relation) permet une recherche du champ hérité le plus proche.

Marquer une base abstraite

Une base destinée à être héritée doit porter Abstract. Les composants normaux sont copiés dans chaque instance selon leur politique :

C

ecs_entity_t base = ecs_new();
ecs_set(base, Health, { 100 });
ecs_add(base, Abstract);

ecs_entity_t instance = ecs_new();
ecs_is_a(instance, base);

C++

auto base = ecs::entity::create();
base.set(Health{ 100 });
base.abstract();
auto instance = ecs::entity::create().is_a(base);

Les instances possèdent donc leur propre valeur par défaut. Pour conserver une valeur partagée, déclarez le composant avec .inheritance = EcsInheritShared.

Remplacer un composant hérité

Ajoutez ou écrivez le composant sur l’instance pour le rendre local :

C

ecs_set(instance, Health, { 75 });

C++

instance.set(Health{ 75 });

Les écritures suivantes ne modifient alors plus la base. Les composants locaux et hérités sont indépendants.

Correspondance des requêtes

Une requête en lecture peut voir un composant hérité, qu’il soit owned ou shared :

C

ecs_query_id_t q = ecs_query({
    .components = { ecs_in(Health) },
});

C++

ecs::query().require<Health>().each([](const Health &health) {
    printf("%d\n", health.value);
});

Un composant hérité configuré shared retourne EcsFieldShared et son pointeur ne représente pas un tableau indépendant par entité. Un composant inherited owned retourne EcsFieldOwned et peut être indexé avec l’indice du lot.

Les termes d’écriture (ecs_out, ecs_inout) correspondent aux valeurs owned, y compris celles copiées lors de IsA. Ils ignorent les valeurs inherited shared. Les termes optionnels en écriture suivent la même règle.

Requêtes limitées à une base

Utilisez is_a dans le descripteur de requête pour limiter les résultats aux entités qui héritent d’une base donnée :

C

ecs_query_id_t enemies = ecs_query({
    .components = { ecs_in(Health) },
    .is_a = enemy_base,
});

C++

auto enemies = ecs::query()
    .is_a(enemy_base)
    .require<Health>()
    .build_handle();

La recherche d’héritage est transitive. ecs_is(instance, base) vérifie donc aussi les bases intermédiaires.