Partager via

Introduction au comportement des entités

  • Article

Dans ce tutoriel, vous apprendrez les éléments suivants:

  • Comment créer et utiliser des fichiers de comportement pour modifier le comportement d’une entité.
  • Comment utiliser des composants pour développer le comportement d’une entité.
  • Comment utiliser les événements pour modifier les composants actifs en fonction de certaines conditions.

Conditions requises

Nous vous recommandons d’effectuer les étapes suivantes avant de commencer ce tutoriel.

Introduction

Les fichiers de comportement dans Minecraft: Bedrock Edition nous permettent de personnaliser la façon dont une entité se comporte et interagit avec le monde. Ils font partie des packs de comportement, mais les packs de comportement peuvent également contenir d’autres types de fichiers comme des fonctions et des tables de butin.

Les fichiers de comportement ont été introduits pour la première fois avec des extensions afin de personnaliser le comportement des entités Vanilla. Les composants ont été créés pour diviser les mécanismes des créatures individuelles, auparavant codés en dur, en petits morceaux pouvant être utilisés par les créateurs pour personnaliser les entités. Par exemple, le mécanisme d’apprivoisement que les chats et chiens utilisent a été transféré au composant tameable afin que les créateurs puissent également apprivoiser d’autres entités.

L’objectif était de rendre chaque mécanisme d’entités personnalisable au fil des ans.

Lorsque l’ajout d’une entité a été introduit, les fichiers de comportement sont devenus un moyen de créer de nouvelles entités à partir de rien en utilisant tous les composants des entités classiques.

Les fichiers de comportement peuvent être utilisés de deux manières:

  • Modification des entités Vanilla. Depuis l’introduction de l’option Ajouter une entité, celle-ci ne doit être utilisée que pour de petits ajustements au jeu Vanilla, et non pour du contenu supplémentaire.
  • Création d’entités personnalisées. Les fichiers de comportement servent de base aux entités personnalisées.

Présentation du format

Les fichiers de comportement des entités sont enregistrés dans le dossier entities de votre pack de comportement. Le jeu charge tous les fichiers dans ce dossier. Vous pouvez donc utiliser des sous-dossiers pour gérer vos entités. Les fichiers utilisent l’extension .json. Cette extension est utilisée par un grand nombre de fichiers des extensions. Donc, si vous voulez éviter toute confusion, vous pouvez utiliser l’extension .behavior.json pour les fichiers de comportement spécifiquement. Pour d’autres extensions étendues, voir ce tableau.

Les fichiers sont écrits en JSON et la structure de base ressemble à ceci:

{
    "format_version": "1.13.0",
    "minecraft:entity": {
        "description": {
            "identifier":"compass:example",
            "is_spawnable":true,
            "is_summonable":true
        },
        "components": {},
        "component_groups": {},
        "events": {}
    }
}

À l’intérieur de la balise description, quelques propriétés de base définissent comment le jeu enregistre l’entité:

Nom du paramètre Type Description
identifier Chaîne Identifiant de l’entité. S’il s’agit d’une entité personnalisée dans une extension, vous devez utiliser un espace de noms unique personnalisé comme dans l’exemple.
runtime_identifier Chaîne Identifiant utilisé en interne par le jeu. Il peut être utilisé pour hériter des mécanismes personnalisés des entités Vanilla qui ne sont pas encore disponibles en tant que composant. Un seul identifiant d’exécution peut être spécifié par entité. Ne l’utilisez que si c’est vraiment nécessaire. Si les mécanismes d’une entité Vanilla sont transformés en composants, vous risquez de perdre des fonctionnalités si vous comptez sur ces mécanismes via un identifiant d’exécution.
is_spawnable Booléen Si true, un œuf d’apparition pour l’entité est ajouté à l’inventaire créatif.
is_summonable Booléen Si true, l’entité peut être invoquée à l’aide de la commande /summon.
is_experimental Booléen Si true, l’entité peut utiliser des fonctionnalités expérimentales. L’entité ne fonctionnera que dans des mondes expérimentaux. Le contenu du magasin ne peut pas être soumis avec cette option activée.
animations Objet Une liste d’animations de comportement ou de contrôleurs d’animation. Celles-ci peuvent être utilisées pour exécuter des commandes ou des événements sur l’entité.
scripts Objet Les scripts fonctionnent de la même manière que dans les fichiers d’entité client, et ils peuvent être utilisés pour lire des animations de comportement.

Composants et groupes de composants

Les composants sont des propriétés ou des mécanismes que vous pouvez ajouter à votre entité. Il existe deux manières d’ajouter des composants: directement à la balise du composant ou avec un groupe de composants .

  • Les composants ajoutés à la balise de composant de base sont toujours actifs, sauf s’ils sont supprimés par un groupe de composants dans un événement.
  • Les groupes de composants sont des ensembles d’un ou plusieurs composants qui ne sont pas actifs par défaut, mais peuvent être activés ou désactivés par des événements. Par exemple, cela peut être utilisé pour créer une variante de l’entité, comme un bébé.

Dans cet exemple, un groupe de composants est utilisé pour créer une variante bébé de l’entité. Les composants définis dans la section des composants principaux sont toujours actifs, tandis que les composants du groupe de composants baby ne sont actifs que lorsque ce groupe est ajouté.

{
    "format_version": "1.13.0",
    "minecraft:entity": {
        "description": {
            "identifier":"compass:example",
            "is_spawnable":true,
            "is_summonable":true
        },
        "components": {
            "minecraft:physics":{}
        },
        "component_groups": {
            "baby": {
               "minecraft:behavior.follow_parent": {},
               "minecraft:is_baby": {}
            }
        },
        "events": {}
    }
}

Tous les composants Minecraft utilisent l’espace de noms minecraft:.

Presque tous les composants sont définis en tant qu’objet JSON. La plupart des composants ont des options qui peuvent être spécifiées dans cet objet, mais certains composants fonctionnent sans options, comme illustré dans l’exemple précédent.

Comment apprendre les composants

Vous trouverez ici une liste complète des composants disponibles.

Un bon moyen d’en savoir plus sur un composant et de voir comment il est utilisé dans la pratique est de regarder les fichiers de comportement des entités Minecraft par défaut. Vous pouvez toujours trouver le dernier pack de comportement par défaut à cette URL: https://aka.ms/behaviorpacktemplate.

Notes

Le fonctionnement d’un composant peut parfois changer d’une version à l’autre. Ainsi, si un composant d’une entité Vanilla ne fonctionne pas sur votre entité, vérifiez si les deux fichiers utilisent la même version de format. Nous vous encourageons à toujours utiliser la dernière version du composant, car elle a été améliorée et peut inclure des corrections.

Composants essentiels

Nom du composant Options Description
minecraft:physics has_collision
has_gravity		 Vous aurez besoin de ce composant sur 99% des entités personnalisées. Il permet à l’entité de rester au sol et de réagir aux interactions et aux coups de poing de la manière attendue.
minecraft:scale value Définit l’échelle de l’entité.
minecraft:collision_box width height Définit la zone de collision de l’entité. Seules les valeurs de la largeur (width) et de la hauteur (height) peuvent être modifiées. La zone de collision a toujours une base carrée alignée sur les axes du monde.
minecraft:type_family family Définit une liste de familles de types dans laquelle se trouve l’entité. Les familles de types peuvent être testées par d’autres entités. Par exemple, pour tester les créatures envers lesquelles ils sont hostiles.
minecraft:movement value Définit la vitesse de déplacement de l’entité. 0.25 est la vitesse normale de la plupart des animaux dans Minecraft.
minecraft:movement.basic Voir la documentation Permet à l’entité de se déplacer sur le sol.
minecraft:navigation.walk Voir la documentation Permet à l’entité de naviguer dans le monde en marchant. Il existe également d’autres types de navigation, comme le survol.
minecraft:is_baby
minecraft:is_ignited
minecraft:is_saddled
minecraft:is_sheared
minecraft:is_tamed
minecraft:is_illager_captain
 :--- Ces composants ne font rien par eux-mêmes, mais ils peuvent être interrogés dans les animations, les contrôleurs d’animation ou les contrôleurs de rendu, ce qui vous permet de contrôler les animations et autres éléments visuels à partir du comportement de l’entité.
minecraft:variant
minecraft:mark_variant
minecraft:skin_id		 value Ces composants fonctionnent comme les précédents, mais au lieu de stocker uniquement un état de marche/arrêt, ils peuvent stocker une valeur entière.

Priorités

L’option priority peut être utilisée sur tous les composants de comportement (objectifs d’IA). 0 est la priorité la plus élevée et la priorité par défaut de tous les composants de comportement. Plus le nombre est élevé, plus la priorité est faible. Si l’entité est occupée à effectuer un comportement de faible priorité et qu’un comportement de haute priorité se présente, l’entité passera immédiatement au comportement de plus haute priorité.

Dans l’exemple suivant, le composant hurt_by_target a une priorité plus élevée. Si l’entité est attaquée pendant qu’elle se promène, elle ciblera immédiatement l’attaquant.

"minecraft:behavior.random_stroll": {
    "priority": 4
},
"minecraft:behavior.hurt_by_target": {
    "priority": 1
}

Suppression de composants

Lorsqu’un groupe de composants est supprimé d’une entité, l’effet des composants est également supprimé. Cela ne posera aucun problème dans la plupart des cas. Mais dans certains cas, il est important de considérer que les composants s’écrasent les uns les autres. Par conséquent, la suppression d’un composant ne le fera pas revenir à son état précédent, et il n’utilisera pas le même composant d’un autre groupe de composants ou des composants de base. Au lieu de cela, le composant sera supprimé complètement et réinitialisé sur ses valeurs par défaut.

Voici un exemple: disons que vous avez une entité avec une échelle de 2 définie dans la balise components de base. Vous ajoutez un groupe de composants bébé avec un composant d’échelle qui définit l’échelle sur 1.5. Cela mettra correctement à jour l’échelle sur 1.5. Maintenant, vous supprimez à nouveau ce groupe de composants. Au lieu de revenir sur 2, l’échelle sera maintenant réinitialisée sur 1. Cela se produit parce que la suppression du groupe de composants entraîne la suppression totale du composant d’échelle. L’échelle sera réinitialisée sur la valeur par défaut 1.

Il est important de prendre en compte quelques éléments:

  • Les composants qui modifient une valeur de l’entité comme minecraft:scale, minecraft:collision_box ou minecraft:variant.
  • Les composants de la liste comme minecraft:interact, minecraft:environment_sensor ou minecraft:damage_sensor
  • Tout autre composant pour lequel vous pourriez souhaiter avoir des états différents comme minecraft:rideable (nombre de sièges ou positions différents).

Afin d’éviter ce comportement, vous devez ajouter un nouveau groupe de composants avec l’état mis à jour du composant. Dans le cas de l’exemple d’échelle, cela peut être aussi simple que d’avoir deux groupes de composants différents pour les différents états entre lesquels vous pouvez basculer:

        "components": {
            "minecraft:scale":{
               "value": 2
            }
        },
        "component_groups": {
            "baby": {
               "minecraft:scale": {
                   "value": 1.5
               }
            },
            "adult": {
               "minecraft:scale": {
                   "value": 2
               }
            }
        },
        "events": {
            "set_baby":{
               "remove": {"component_groups": ["adult"]},
               "add": {"component_groups": ["baby"]}
            },
            "set_adult":{
               "remove": {"component_groups": ["baby"]},
               "add": {"component_groups": ["adult"]}
            }
        }

Événements

Les événements sont utilisés pour ajouter et supprimer des groupes de composants dans l’entité. Dans cet exemple, un ancien groupe de composants est supprimé tandis que deux nouveaux sont ajoutés:

"events": {
    "compass:example_event": {
        "remove": {
            "component_groups": ["compass:group_a"]
        },
        "add": {
            "component_groups": ["compass:group_b","compass:group_c"]
        }
    }
}

Les événements peuvent être déclenchés par de nombreux composants comme minecraft:interact ou minecraft:environment_sensor, par des animations de comportement, ou par la commande d’invocation. La commande suivante génère l’entité lors de l’exécution de l’événement ci-dessus.

/summon compass:example_entity ~ ~ ~ compass:example_event

Événements intégrés

Quelques événements sont intégrés à Minecraft et s’exécutent si l’entité est générée dans certaines conditions.

Nom de l’événement Description
minecraft:entity_born L’événement se déroule lorsque l’entité est engendrée par reproduction.
minecraft:entity_spawned L’événement s’exécute chaque fois que l’entité s’affiche. Notez qu’il ne fonctionnera pas si vous l’appelez (/summon) manuellement.
minecraft:entity_transformed L’événement s’exécute lorsqu’une autre entité se transforme en cette entité.
minecraft:on_prime L’événement s’exécute lorsque l’entité est amorcée et prête à exploser.

Randomiseurs

Si vous voulez randomiser le groupe de composants qui sera ajouté à l’entité, vous pouvez utiliser la fonction «randomize». Vous spécifiez un tableau d’objets, chacun pouvant ajouter et supprimer des groupes de composants. Le jeu choisit et exécute alors au hasard l’un de ces objets.

Vous pouvez également ajouter une option de pondération aux options pour modifier la probabilité de chaque option. Toutes les pondérations combinées comptent pour 100%. Dans l’exemple suivant, l’entité est générée en tant qu’œuf avec 20% (1 sur 4) de chances, tandis que dans les autres cas, aucun groupe de composants n’est ajouté:

"events": {
    "minecraft:entity_spawned": {
        "randomize": [
            {
               "weight": 40
            },
            {
               "weight": 10,
               "add": {
                   "component_groups": ["baby"]
               }
            }
        ]
    }
}

Séquences

Parfois, vous devez exécuter plusieurs instances d’événement l’une après l’autre dans le même événement. Par exemple, vous pouvez vouloir randomiser deux aspects de l’entité, comme la couleur et le motif de la marque. Dans ce cas, vous pouvez utiliser une séquence. Les séquences sont structurées de la même manière que les randomiseurs, mais chaque élément de la liste est exécuté dans l’ordre. Ceci est également très utile en combinaison avec des filtres, ce qui sera expliqué dans la section suivante.

Les séquences et les randomiseurs peuvent être imbriqués indéfiniment.

Dans cet exemple, le groupe initial sera ajouté lorsque l’entité sera générée. Après cela, le composant bébé sera randomisé comme dans la section précédente.

        "events": {
            "minecraft:entity_spawned":{
               "sequence": [
                   {
                       "add": {
                           "component_groups": ["initial"]
                       }
                    },
                   {
                       "randomize": [
                           {
                               "weight": 40
                           },
                           {
                               "weight": 10,
                               "add": {
                                   "component_groups": ["baby"]
                               }
                           }
                       ]
                    }
               ]
            }
        }

Filtres

Les filtres conditionnent un événement ou une partie d’un événement en testant une propriété spécifique sur l’entité actuelle, à savoir l’entité en interaction ou le monde. Les filtres peuvent être utilisés dans n’importe quel événement, mais vous pouvez également les utiliser directement dans certains composants.

Un événement comprend jusqu’à cinq paramètres. Les paramètres test et value sont obligatoires. Les autres sont facultatifs:

Type de test Propriété à tester
value Valeur à tester. Il peut s’agir d’une chaîne lorsque le test porte sur des chaînes, d’un nombre lorsque le test porte sur des valeurs numériques ou d’une valeur booléenne.
subject Entité sur laquelle le test est exécuté. Par défaut, il s’agit de self, mais il peut également cibler l’autre entité impliquée dans une interaction.
operator Manière dont la valeur est comparée. La valeur par défaut est equals, mais il est également possible de tester les valeurs inférieures ou supérieures (pour les valeurs numériques) ou les inégalités.
domain Ceci n’est utilisé que par quelques tests pour fournir un contexte supplémentaire, comme l’emplacement d’inventaire à tester pour le test has_equipment.

Notes

Une liste complète des filtres, et la façon dont ces paramètres interagissent avec eux se trouvent dans le document technique Entités.

Un exemple minimal de filtre à l’intérieur d’un événement peut ressembler à ceci: le groupe de composants ne peut être ajouté que si l’entité possède la balise event_allowed.

"events": {
    "compass:example_event": {
        "filters": {
            "test": "has_tag",
            "value":"event_allowed"
        },
        "add": {
            "component_groups": ["baby"]
        }
    }
}

Si vous souhaitez utiliser plusieurs filtres, vous pouvez les regrouper à l’aide des listes all_of, any_of ou none_of. Cela ne réussira que si tous les filtres, l’un des filtres ou aucun des filtres qu’ils contiennent ont abouti. Ces listes peuvent être imbriquées indéfiniment.

Dans l’exemple suivant, nous ajoutons une deuxième condition au filtre. L’événement ne s’exécutera que si l’entité a la balise de l’exemple précédent et se trouve à moins de 10pâtés de maisons du joueur le plus proche.

"events": {
    "compass:example_event": {
        "filters": {
            "all_of":[
               {"test": "has_tag", "value": "event_allowed"},
               {"test": "distance_to_nearest_player", "operator": "<", "value": 10}
            ]
        },
        "add": {
            "component_groups": ["baby"]
        }
    }
}

Quelle est la prochaine étape?

Si vous vous retrouvez bloqué ou si vous souhaitez mieux comprendre le fonctionnement d’un composant, vous pouvez consulter les fichiers de comportement Vanilla pour voir des exemples fonctionnels. Déconstruire une entité Vanilla et l’appliquer à une autre entité est un excellent moyen de commencer. Prenez le composant minecraft:teleport d’un Endermen et appliquez-le sur un creeper. Rendez un zombie chevauchable par le joueur. Faites des bébés creepers.

Le système de composants vous permet de personnaliser ce que fait votre entité et comment elle interagit avec le monde. Si vous souhaitez en savoir plus sur la conception de l’apparence et des déplacements de votre entité, consultez le tutoriel sur la modélisation et l’animation d’entités.

Modélisation et animation d’entités