Introduction à l'ajout d'entité

Article
04/26/2022

Vous pouvez ajouter une entité à Minecraft: Bedrock Edition à l'aide d'un pack de comportement et d'un pack de ressources. Comme vous l'avez appris dans les tutoriels recommandés, le comportement des entités peut être modifié grâce à un pack de comportement tandis que le pack de ressources peut être utilisé pour modifier leur apparence. Les deux packs sont indispensables pour ajouter une entité qui fonctionnera dans votre jeu. Ce guide comporte deux parties: la première partie aborde la structure des fichiers et des dossiers nécessaires pour ajouter une entité personnalisée à Minecraft. La seconde partie vous permettra de donner vie à votre entité grâce à des composants de comportement et des animations.

Image d’une baleine bleue créée dans un pack de modélisation.

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

Comment créer une nouvelle entité personnalisée à l’aide de packs de comportement et de ressources.
Comment appliquer diverses fonctionnalités à l'entité, y compris des composants et des animations.
Utilisation de traductions relatives aux noms d'entité.

Conditions

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

Introduction aux packs de comportement
Introduction aux packs de ressources
Télécharger les ressources minrobot et robot complet et les packs de comportements

Il est également recommandé de connaître des éléments suivants pour une meilleure compréhension de cet article.

Avoir connaissance du fonctionnement du format JSON.
Connaître le fonctionnement d'un éditeur de code tel que VSCode

Structure de fichier

Dans le pack de comportement, un fichier d'entité est chargé de définir cette dernière du côté serveur. Dans le pack de ressources, un fichier d'entité client est chargé de décrire au jeu à quoi ressemblera l'entité. Le graphique suivant montre comment différents fichiers peuvent interagir afin de créer une entité personnalisée:

Relations entre les packs de ressources et les packs de comportement

Exemple d'entité robot: minrobot

Pour vous donner un point de référence pour ce tutoriel, nous vous proposons deux versions de la même entité: un robot qui peut apparaître de façon aléatoire dans le monde et qui possède trois textures également aléatoires, une animation de roue, divers composants et un mécanisme aquatique personnalisé. Le lien de téléchargement se trouve dans la section Conditions section ci-dessus.

Pour voir le robot en action, choisissez l'un des packs de ressources et de comportements que vous venez de télécharger. (Nous vous recommandons d'essayer le plus simple pour l'instant.) Placez les packs de ressources et de comportement dans leurs sous-dossiers com.mojang respectifs, lancez un monde avec les commandes de triche activées et utilisez /summon compass:robot.

Voici la structure une fois terminée des packs de comportement et de ressources «robot minimum»:

Structure de fichier d'une entité minimum robot terminée

Cela peut vous paraître un peu trop, mais vous n'avez qu'à penser aux fichiers avec «robot» dans le nom et où ils sont stockés.

Une fois que vous avez une idée de la façon dont le robot se comporte dans le jeu, vous pouvez supprimer les packs de ressources et de comportement du robot une fois finalisé et les recréer à partir de zéro grâce aux étapes de ce tutoriel pour avoir une idée de la façon dont tous les fichiers fonctionnent ensemble.

Un bon point de départ serait d'utiliser les packs de ressources et de comportements que vous avez créés dans les tutoriels précédents. Vous voudrez peut-être supprimer l'entité vache d'attaque, mais c'est une préférence personnelle.

Identification

Lorsque vous créez une entité, l'une des premières choses à prendre en compte est l'identifiant que vous allez lui donner. Les fichiers de vos packs de ressources et de comportements devront être synchronisés à l'aide de l'identifiant que vous allez donner à votre entité. Cet identifiant se compose d'un espace de noms et d'un nom séparés par un deux-points. Il s'agissait de l'identifiant compass:robot que nous avions utilisé précédemment pour invoquer le robot.

Vous pouvez utiliser une version abrégée du nom de votre équipe ou de votre produit pour votre propre espace de noms. L'identifiant ne doit comprendre que des lettres minuscules, des chiffres et des tirets bas. N'utilisez pas «minecraft» comme espace de noms pour le contenu personnalisé. L'espace de noms «minecraft» est réservé aux ressources vanilla, vous ne devez donc l'utiliser que si vous écrasez du contenu vanilla.

La plupart des fichiers qui définissent l'entité seront de type JSON. Afin d'éviter toute confusion, il est recommandé d'utiliser une extension de fichier étendue lors de la création de chacun de ces fichiers. Dans la plupart des cas, le jeu ignore les noms de fichiers, mais lorsque vous travaillez sur une extension, des noms de fichiers peu clairs peuvent prêter à confusion. Les extensions sont les suivantes:

Le type de fichier	Le nom du fichier
Les fichiers d'entité client	entity_name.entity.json
Les fichiers de modèles	entity_name.geo.json
Les fichiers d'animation	entity_name.animation.json
Contrôleurs d’animation	entity_name.animation_controllers.json
Les contrôleurs de rendu	entity_name.render_controllers.json

entity_name doit être remplacé par le nom de votre entité, sans inclure l'espace de noms.

Versions de format

Chaque fichier JSON doit avoir une étiquette format_version. Cette étiquette est importante pour que le jeu puisse lire correctement le fichier. Il est important de savoir que les fichiers créés dans des formats plus anciens fonctionneront toujours dans les nouvelles versions du jeu, mais uniquement si la version du format est correctement configurée. Les versions de format incorrectes sont une source d'erreurs fréquente.

Définition du pack de comportement

La première étape pratique pour ajouter un robot dans le jeu débute par le pack de comportement. Créez un nouveau fichier dans le dossier entities du pack de comportement et donnez lui le nom de robot.json. Copiez et collez ce code.

{
    "format_version": "1.12.0",
    "minecraft:entity": {
        "description": {
            "identifier": "compass:robot",
            "is_spawnable": true,
            "is_summonable": true
        },
        "components": {}
    }
}

À l'intérieur de l'étiquette de description, les attributs de base de l'entité devront être définis. identifier définit l'ID de l'entité. is_spawnable ajoutera plus tard un œuf d'apparition dans le jeu qui permettra au joueur de faire apparaître cette créature. is_summonable fera fonctionner l'entité avec la commande /summon.

A l'intérieur des components, nous allons en ajouter pour modifier le comportement de l'entité. Pour l'instant, nous n'allons ajouter que le composant minecraft:physics. Cela ajoutera de la gravité et un comportement standard de collision à l'entité.

"components": {
    "minecraft:physics": {}
}

Enregistrez votre fichier robot.json et passez à l'étape suivante.

Définition de l'entité client

À cet instant, nous devons ajouter l'entité au pack de ressources pour lui conférer un aspect visuel. Dans le fichier entity du pack de ressources, créez un nouveau fichier JSON nommé robot.entity.json.

{
    "format_version": "1.10.0",
    "minecraft:client_entity": {
        "description": {
            "identifier": "compass:robot",
            "spawn_egg": {
                "base_color": "#505152",
                "overlay_color": "#3b9dff"
            }
        }
    }
}

Il s'agit de la structure de base du fichier. Jusqu'à présent, il est similaire au fichier côté comportement que nous avons créé dans la section précédente. Notez que nous utilisons désormais l'appellation client_entity plutôt qu'entité. Au moment de la rédaction de cet article, 1.10.0 est la dernière version de format pour ce fichier.

L'étiquette spawn_egg définit à quoi l'œuf d'apparition ressemblera dans l'inventaire. A l'aide de cette méthode, il ressemblera à un œuf d'apparition standard, mais avec des couleurs personnalisées.

Visuels

Avant de pouvoir ajouter l'entité au jeu, il est nécessaire de créer un modèle. L'article Modélisation et animation d'entités explique comment créer un modèle et une texture personnalisés. La création d'un modèle est cependant très exigeante en terme d'apprentissage et nous n'en avons pas encore fini avec ce tutoriel. Donc, pour le moment, vous pouvez prétendre que vous avez déjà créé un modèle en copiant et collant les fichiers du pack de ressources du robot. Utilisez ces mêmes étapes plus tard pour ajouter le modèle que vous créez.

Enregistrez le modèle dans le dossier models/entity en tant que robot.geo.json.
Enregistrez la texture dans textures/entity en tant que robot.png.

Maintenant que les fichiers de modèle sont en place, nous avons besoin d'un contrôleur de rendu pour associer le modèle, la texture et les matières premières utilisés pour l'entité.

Ouvrez le fichier robot.entity.json dans le dossier entity de votre pack de ressources.

Pour la plupart des entités (telles qu'un robot), nous pouvons utiliser le contrôleur de rendu par défaut fourni dans le jeu. Nous parlerons plus en détail des contrôleurs de rendu plus tard dans la partie la plus avancée de ce tutoriel. Pour l'instant, sachez simplement que c'est l'endroit qui doit être utilisé et que le contenu devrait être:

{
    "format_version": "1.10.0",
    "minecraft:client_entity": {
        "description": {
            "identifier": "compass:robot",
            "materials": {
                "default": "entity"
            },
            "textures": {
                "default": "textures/entity/robot"
            },
            "geometry": {
                "default": "geometry.robot"
            },
            "render_controllers": [
                "controller.render.default"
            ],
            "spawn_egg": {
                "base_color": "#505152",
                "overlay_color": "#3b9dff"
            }
        }
    }
}

Le modèle est référencé par le nom de géométrie. Si vous créez un modèle dans Blockbench, veillez à ce que le nom de géométrie dans les paramètres de votre projet soit défini sur le nom de votre entité. Dans le cas présent, il s'agit de «robot».

Contrairement aux géométries, les textures sont liées par leur chemin dans le pack de ressources, sans l'extension de fichier, comme illustré dans l'exemple.

Dans la plupart des cas, une matière première personnalisée n'est pas obligatoire. Au lieu de cela, vous pouvez utiliser une matière première par défaut. Dans cet exemple, nous utilisons entity. Si la texture comporte des parties transparentes, vous pouvez utiliser entity_alphatest ou si votre texture est translucide (comme un verre coloré), vous pouvez utiliser entity_alphablend.

Chaînes de traduction

À ce moment précis, ni l'entité en elle-même, ni l'œuf d'apparition ne disposent d'un nom propre dans le jeu. Pour définir un nom, nous avons besoin d'un fichier linguistique. Créez un nouveau dossier appelé texts au sein de votre pack de ressources et également nouveau fichier appelé en_US.lang. Pour les entités personnalisées, il suffit de modifier ce fichier de langue, car toutes les autres langues seront par défaut l'anglais américain. Dans ce fichier, ajoutez ces deux lignes:

entity.compass:robot.name=Robot
item.spawn_egg.entity.compass:robot.name=Spawn Robot

La première ligne définit le nom de l'entité. Il sera visible dans les messages de mort et dans la sortie de certaines commandes. La clé et la valeur sont toujours séparées par un signe égal. La première ligne peut être décomposée ainsi:

entity.<identifier>.name=<Name>

La deuxième ligne définit le nom d'objet de l'œuf d'apparition:

item.spawn_egg.entity.<identifier>.name=<Name>

Tests

Veillez à effectuer vos tests rapidement et de façon régulière. Le fait de rencontrer un problème à un stade précoce permet de simplifier son suivi, ce qui peut faciliter sa résolution. Les tests révèlent souvent des problèmes peu de temps après avoir apporté des modifications, ce qui permet de déterminer rapidement la cause de ces changements récents.

Vous devriez maintenant être capable de faire apparaître votre entité dans le jeu à l'aide de l'œuf d'apparition ou de la commande d'invocation. Si vous voulez juste une entité statique, c'est tout bon. Mais si vous souhaitez personnaliser davantage l'entité, continuez votre lecture.

Exemple d'entité robot: robot complet

Ce serait le bon moment d'essayer les packs de ressources et de comportement du robot complet. Comparez l'ensemble des dossiers et fichiers. Ensuite, remettez vos packs de robot minimal afin que nous puissions continuer à ajouter des fonctionnalités.

Composants

Les composants indiquent à l'entité comment agir dans le jeu. Ajoutons quelques composants et décrivons en détail leur action.

Dans le dossier pack comportement/entités/, ouvrez robot.json et remplacez l'entrée unique de "minecraft:physics": {} avec tout cela...

   "components": {
        "minecraft:physics": {},
        "minecraft:nameable": {},
        "minecraft:movement": {
            "value": 0.25
        },
        "minecraft:movement.basic": {},
        "minecraft:jump.static": {},
        "minecraft:navigation.walk": {
            "avoid_water": true
        },
        "minecraft:behavior.tempt": {
            "priority": 1,
            "speed_multiplier": 1.4,
            "items": ["diamond"],
            "within_radius": 7.0
        },
        "minecraft:behavior.random_stroll":
        {
            "priority": 3,
            "speed_multiplier": 0.8
        },
        "minecraft:experience_reward": {
            "on_death": 8
        }
   }

Nom du composant	Description
`minecraft:nameable`	Permet au joueur de nommer l'entité avec une étiquette de nom.
`minecraft:movement`	Indique à l'entité à quelle vitesse se déplacer. 0,25 est la vitesse normale de la plupart des animaux dans Minecraft.
`minecraft:movement.basic`	Donne à l'entité la possibilité de se déplacer sur le sol.
`minecraft:jump.static`	Permet à l'entité de sauter pour gravir des blocs.
`minecraft:navigation.walk`	Permet à l'entité de naviguer dans le monde où ils se trouve. Ce composant dispose d'une option pour éviter l'eau.
`minecraft:behavior.tempt`	Ce composant pousse l'entité à suivre les joueurs qui tiennent des diamants dans leur main. Nous avons donné à ce comportement une priorité plus haute pour cette action ait la priorité (numéro inférieur=priorité plus haute).
`minecraft:behavior.random_stroll`	Permet à l'entité de se déplacer de façon aléatoire là où il elle se trouve. Nous attribuons à cette priorité un numéro supérieur pour que l'entité ne suive ce comportement que lorsqu'elle n'a rien d'autre à faire. Le multiplicateur de vitesse diminuera la vitesse lors de l'utilisation de ce comportement de marche.
`minecraft:experience_reward`	Permet à l'entité d'abandonner l'expérience lorsqu'elle est tuée par un joueur.

Animations

Dans cette section, nous allons juste ajouter une simple animation du robot qui tourne un volant. Si vous souhaitez en savoir plus sur les animations, sur l'utilisation des contrôleurs et sur la création d'animations dans Blockbench, veuillez consultez ce guide.

Les animations sont stockées dans des fichiers d'animation. La première chose que nous devons donc faire est de créer un dossier dénommé animations dans le pack de ressources et également un fichier appelé robot.animation.json à l'intérieur. Dans ce fichier, nous allons créer une nouvelle animation appelée animation.robot.drive. Nous voulons également définir loop sur true pour que l'animation soit continue. Le fichier doit ressembler à ceci:

{
    "format_version": "1.8.0",
    "animations": {
        "animation.robot.drive": {
            "loop": true
        }
    }
}

Les animations nous permettent de faire varier la position, la rotation et la taille de chaque os. Si vous ne savez pas encore ce que signifie «os» dans ce contexte, ce n'est pas grave, vous pourrez en apprendre plus sur ce sujet lorsque vous étudierez Blockbench. Pour l'instant, sachez simplement que cela représente un tronçon du modèle, comme une jambe ou une roue. Les animations peuvent être réalisées avec des images clés, des expressions Molang ou une combinaison des deux. Dans cet exemple, nous n’utiliserons que des expressions Molang.

Le Molang est un langage réservé aux packs de ressources et de comportement. Il nous permet d’obtenir plusieurs données chiffrées à partir de l’entité à l’aide d’une requête et de calculer un résultat grâce à des expressions mathématiques. Par exemple, la requête query.modified_distance_moved indique la distance parcourue par l'entité. Nous pouvons l'utiliser pour calculer la rotation du volant du robot sur l'axe X, ce qui se traduira par une animation donnant l'impression que le robot est en train de conduire. Il faut jongler avec les chiffres, mais pour ce modèle, le nombre 60 a plutôt bien fonctionné.

{
    "format_version": "1.8.0",
    "animations": {
        "animation.robot.drive": {
            "loop": true,
            "bones": {
                "wheel": {
                    "rotation":["query.modified_distance_moved*60", 0, 0]
                }
            }
        }
    }
}

Maintenant que l'animation est créée, nous devons l'associer au fichier d'entité client. (N'oubliez pas que le pack de ressources est le client, alors ouvrez <resource pack>/entity/robot.entity.json pour la prochaine partie.) La balise animations relie toutes les animations et les contrôleurs d'animation utilisés par l'entité. Chaque animation reçoit un nom court qui peut être utilisé pour lancer l'animation dans un contrôleur ou directement dans le fichier, par exemple dans ce cas: drive.

Les sections scripts et animate peuvent être utilisées pour lancer directement des animations:

        "animations": {
            "drive": "animation.robot.drive"
        },
        "scripts": {
            "animate": ["drive"]
        }

Avec ces deux étiquettes ajoutées dans l'étiquette de description du fichier entité client, l'animation «conduite» sera toujours active et actionnera la rotation du volant pendant que l'entité se déplace.

Les contrôleurs de rendu

Les contrôleurs de rendu permettent de modifier la géométrie, les textures et les matières premières de l’entité à l’aide du Molang. L’exemple suivant montre comment utiliser la géométrie, les matières premières et la texture qui ont été associées au fichier d’entité client en tant que default:

{
    "format_version": "1.8.0",
    "render_controllers": {
        "controller.render.robot": {
            "geometry": "Geometry.default",
            "materials": [ { "*": "Material.default" }],
            "textures": [ "Texture.default" ]
        }
    }
}

Si vous souhaitez juste utiliser une géométrie, un matière première et une texture par défaut, vous pouvez simplement laisser la sélection du contrôleur de rendu par défaut comme auparavant. Mais ce peut être également le bon moment pour apprendre comment ajouter des textures aléatoires. Découvrons donc en détail comment les contrôleurs de rendu fonctionnent.

Explications sur le contrôleur de rendu

Vous remarquerez que l'étiquette de base est nommée render_controllers. Cela signifie que nous pouvons définir plusieurs contrôleurs de rendu dans un seul fichier.

Notre contrôleur de rendu est nommé selon le schéma suivant: controller.render.<entity_name>. Pour un contrôleur de rendu polyvalent, nous pouvons également utiliser un autre mot-clé au lieu du nom de l'entité.

À l'intérieur de l'étiquette du contrôleur de rendu, les différentes ressources sont indiquées, mais vous remarquerez que chacune utilise un format JSON différent.

Géométrie

Un contrôleur de rendu ne peut afficher qu'une seule géométrie à la fois. C’est pour cette raison qu'il est associé directement en tant que chaîne unique. Cette chaîne peut être une expression Molang et doit toujours renvoyer à une géométrie. Dans ce cas, elle déclenche Geometry.default, ce qui signifie qu'elle renverra à la géométrie associée en tant que default par n’importe quelle entité utilisant le contrôleur de rendu.

Vous pouvez appliquer plusieurs géométries à une entité à l'aide de plusieurs contrôleurs de rendu. Cette action peut être délicate car elle peut provoquer un comportement inattendu. Par conséquent, il est recommandé que seuls les créateurs expérimentés ne l'applique.

Matières premières

À la différence de la géométrie, les matières premières sont décrites sous la forme d'un tableau d'objets. Le but étant de pouvoir attribuer à chaque os une matière distincte. Chaque objet du tableau peut avoir une paire clé-valeur. La clé va sélectionner un ensemble d'os. Un astérisque est utilisé comme caractère de remplacement. Cela signifie que tous les os, quel que soit leur nom, se verront attribuer la matière première par défaut. Notez que les matières sont attribuées dans l'ordre, ce qui signifie que celles étant situées plus bas dans la liste peuvent remplacer les matières précédentes.

        "materials": [
            { "*": "Material.default" },
            { "*_arm": "Material.transparent" }
        ],

Dans cet exemple, nous allons d'abord appliquer la matière par défaut à tous les os. Ensuite, nous remplacerons celle-ci par la matière transparente sur tous les os qui se terminent par _arm. De cette façon, tous les os des bras seront transparents.

Textures

Les textures sont présentées dans un tableau. Dans la plupart des cas, une seule texture sera associée ici car les entités ne sont pas compatibles avec des textures distinctes. Il y a cependant une seule exception: les matières premières sont compatibles avec plusieurs textures placées les unes sur les autres, en tant que matière première entity_multitexture. Par exemple, c'est ce qui est utilisé pour les lamas posés sur un décor.

Tableaux

Lorsque vous travaillez avec plusieurs ressources d'un même type, il peut être utile d'utiliser un tableau. Un tableau est une liste de liens de ressources qui sont définis dans le contrôleur de rendu. Vous pouvez sélectionner une des ressources à l’aide du Molang.

Nous pouvons définir un tableau pour le robot de cette façon:

        "controller.render.robot": {
            "arrays": {
                "textures": {
                    "Array.variant":[
                        "Texture.default",
                        "Texture.variant_b",
                        "Texture.variant_c"
                    ]
                }
            },

Dans la section tableaux, nous pouvons définir des tableaux pour chacune des trois catégories suivantes: textures, materials et geometries. A l'intérieur de la catégorie, vous pouvez définir des tableaux en utilisant Array.<array name> comme nom. Chaque ligne à l’intérieur du tableau associe une texture définie dans le fichier d’entité client.

Vous pouvez accéder au tableau à l’aide du Molang. La base des tableaux est 0, donc la première texture de ce tableau est accessible grâce à Array.variant[0].

Dans cet exemple, nous utilisons la requête de variante pour choisir une texture dans le tableau. La variante d'une créature peut être modifiée à l'aide du composant minecraft:variant dans le fichier de comportement.

"textures": [ "Array.variant[ query.variant ]" ]

Nous devons maintenant associer les textures supplémentaires dans le fichier d'entité client. La texture standard bleue du robot est déjà associée en tant que default, et nous allons maintenant créer deux copies du fichier de texture du robot, modifier la couleur et les associer en tant que variant_b et variant_c.

            "textures": {
                "default": "textures/entity/robot",
                "variant_b": "textures/entity/robot_b",
                "variant_c": "textures/entity/robot_c"
            },

Maintenant, les textures sont associées. La dernière étape consiste à rendre la variante aléatoire dans le fichier de comportement. Nous utiliserons des groupes de composants pour cela. Les groupes sont un moyen d'ajouter un ensemble de composants à l'entité ou d'en supprimer à tout moment. Nous utiliserons également un événement qui rend aléatoire le groupe de composants à ajouter.

        "description": {
            ...
        },
        "components": {
            ...
        },
        "component_groups": {
            "compass:color_0": {
                "minecraft:variant": {"value": 0}
            },
            "compass:color_1": {
                "minecraft:variant": {"value": 1}
            },
            "compass:color_2": {
                "minecraft:variant": {"value": 2}
            }
        },
        "events": {
            "minecraft:entity_spawned": {
                "randomize": [
                    {
                        "add": {
                            "component_groups": ["compass:color_0"]
                        }
                    }, {
                        "add": {
                            "component_groups": ["compass:color_1"]
                        }
                    }, {
                        "add": {
                            "component_groups": ["compass:color_2"]
                        }
                    }
                ]
            }
        }

Maintenant, lorsque nous allons faire apparaître l'entité pour la première fois, elle choisira un groupe de composants au hasard et donc une variante. Il s'agit d'une technique très courante pour rendre l'apparence d'une entité aléatoire.

Apparition

Les règles d'apparition définissent la façon dont les entités apparaissent aléatoirement dans le monde. Nous allons créer un fichier de règles d'apparition pour notre robot. Tout d'abord, créez un dossier appelé spawn_rules dans votre pack comportement. Dans le dossier, créez un nouveau fichier texte appelé robot.json. Le contenu du fichier doit ressembler à ceci:

{
    "format_version": "1.8.0",
    "minecraft:spawn_rules": {
        "description": {
            "identifier": "compass:robot",
            "population_control": "animal"
        },
        "conditions": []
    }
}

À l'intérieur de minecraft:spawn_rules, il y a deux choses que nous devons prendre en compte: le contrôle de la population et les conditions.

description définit les propriétés de base du fichier. identifier doit correspondre à l'identifiant de notre entité. population_control définit la façon dont le jeu doit connaître le nombre de créatures qui vont apparaître et est un peu plus complexe.

Contrôle de la population

Il existe différents groupes d'entités. Au moment où le groupe qui a été défini ici est considéré comme complet, le jeu ne fera plus apparaître de créatures de ce groupe. Il existe trois différentes options:

"animal": créatures passives telles que les vaches ou les cochons
"water_animal": créatures aquatiques telles que les poissons tropicaux et les dauphins
"monster": créatures hostiles telles que les squelettes et les zombies

Pour le robot, nous allons utiliser le groupe «animal».

Conditions requises

conditions est un tableau des conditions de possibilités permettant aux créatures d'apparaître dans le monde. Chacune des conditions essaie séparément de faire apparaître les créatures dans le monde. Chacune se compose d'un groupe de composants qui définissent quand les créatures doivent apparaître et quand elles ne le doivent pas.

Pour une règle d'apparition de base, une seule condition suffit. Pour le robot, nous utiliserons cette configuration:

{
    "format_version": "1.8.0",
    "minecraft:spawn_rules": {
        "description": {
            "identifier": "compass:robot",
            "population_control": "animal"
        },
        "conditions": [
            {
                "minecraft:spawns_on_surface": {},
                "minecraft:brightness_filter": {
                    "min": 12,
                    "max": 15,
                    "adjust_for_weather": false
                },
                "minecraft:weight": {
                    "default": 40
                },
                "minecraft:biome_filter": {
                    "test": "has_biome_tag",
                    "value": "animal"
                }
            }
        ]
    }
}

Nom du composant	Description
`minecraft:spawns_on_surface`	La créature apparaît à la surface
`minecraft:brightness_filter`	Ne fait apparaître l'entité qu'à une certaine luminosité. Accepte trois options: `min`, `max` et `adjust_for_weather`. Les niveaux de luminosité vont de 0 à 15. Si `adjust_for_weather` est défini sur `true`, la diminution du niveau de luminosité due à la pluie et aux orages sera prise en compte.
`minecraft:weight`	L'importance de l'entité au niveau des apparitions. Plus le nombre est élevé, plus la créature apparaîtra souvent.
`minecraft:biome_filter`	Filtre le biome dans lequel la créature est autorisée à apparaître. Les filtres de biome fonctionnent de la même manière que les filtres pour le comportement, ce qui signifie que les opérateurs tels que `all_of` et `any_of` sont autorisés. Les biomes ont différentes étiquettes qui indiquent le type de biome, la variante, la dimension et les caractéristiques telles que «monstre» ou «animal».

Les robots apparaîtront désormais à n'importe quel endroit de la surface où les animaux peuvent apparaître et où il y a suffisamment de lumière. Avec une importance de 40, ils apparaîtront également assez fréquemment.

Animations de comportement

Les animations de comportement fonctionnent de la même manière que les animations classiques, mais s'exécutent dans le pack de comportement. Alors que les animations classiques animent le mouvement du modèle ainsi que des sons et des particules, les animations de comportement peuvent exécuter des commandes standard, déclencher des événements d’entité ou exécuter des expressions Molang. Les animations de comportement sont également souvent mentionnées comme événements d’entité, bien que cette appellation ait tendance à prêter à confusion.

Puisque les robots n'aiment pas l'eau, nous allons ajouter une action mécanique pour que les robots soient endommagés pour l'eau ou la pluie. Tout d’abord, nous allons créer un contrôleur d’animation pour effectuer des tests lorsque l’entité est dans l’eau à l’aide d’une requête Molang. Créez un nouveau dossier dans le pack de comportement appelé animation_controllers et le fichier robot.animation_controllers.json à l’intérieur:

{
    "format_version": "1.10.0",
    "animation_controllers": {
        "controller.animation.robot.in_water": {
            "states": {
                "default": {
                    "transitions": [
                        {"in_water": "query.is_in_water_or_rain"}
                    ]
                },
                "in_water": {
                    "transitions": [
                       {"default": "query.is_in_water_or_rain == 0"}
                    ]
                }
            }
        }
    }
}

Le contrôleur d'animation ressemble beaucoup aux contrôleurs d'animation classiques côté client. Il dispose de deux états qui peuvent être activés selon que le robot est dans l'eau ou non.

Ajoutons maintenant une animation pour donner un effet de poison au robot. Créez un nouveau dossier animations dans le pack de comportement et un fichier robot.animation.json à l'intérieur:

{
    "format_version": "1.8.0",
    "animations": {
        "animation.robot.poison": {
            "loop": true,
            "animation_length": 1,
            "timeline": {
                "0.0": [
                    "/effect @s poison 2 0 true"
                ]
            }
        }
    }
}

Au lieu d’utiliser l’étiquette «bone» ici pour animer les os, nous allons utilisons l’étiquette «timeline». Dans les packs de ressources, seules les chronologies peuvent être utilisées pour exécuter du code Molang. Dans les animations de comportement, vous pouvez l’utiliser pour exécuter du code Molang, des commandes ou déclencher des événements d’entité. Notez que tous ces éléments sont fournis sous forme de chaîne. Le jeu déterminera le type de chaîne à partir de son contenu. Si la chaîne commence par une barre oblique (slash), elle s'exécutera comme une commande. Si cela correspond à ce schéma: @s namespace:event, la chaîne s’exécutera en tant qu’événement d’entité. Si elle est similaire à du Molang, elle s’exécutera en tant que Molang.

Pour cette raison, il est important de démarrer les commandes par une barre oblique pour les animations de comportement. Notez également que nous appliquons un effet poison pendant deux secondes, car une seule ne serait pas suffisante pour réellement infliger des dégâts. Les true à la fin de la commande rendra l'effet de statut ambiant, ce qui signifie qu'il n'y aura aucune particule.

Comme pour les animations des packs de ressources, toutes les animations et les contrôleurs d'animation doivent être associés dans l'étiquette de description de l'entité, qui ressemblera à ceci:

        "description": {
            "identifier": "compass:robot",
            "is_spawnable": true,
            "is_summonable": true,
            "animations": {
                "poison": "animation.robot.poison",
                "in_water": "controller.animation.robot.in_water"
            },
            "scripts": {
                "animate": [
                    "in_water"
                ]
            }
        },

La section animations répertorie toutes les animations et les contrôleurs d'animation que l'entité utilise et leur donne un nom court. La section scripts/animation indique les animations qui doivent toujours s'exécuter. Nous voulons que le contrôleur détecte l'état pour un fonctionnement continu, mais pas pour l'effet poison.

Maintenant, nous devons revenir au contrôleur d'animation et ajouter l'effet poison. Nous ajouterons également un petit mécanisme de régénération avec un effet sonore, afin que le robot ne meure pas aussi facilement.

            "states": {
                "default": {
                    "transitions": [
                        {"in_water": "query.is_in_water_or_rain"}
                    ]
                },
                "in_water": {
                    "animations": [
                        "poison"
                    ],
                    "on_exit": [
                        "/effect @s regeneration 2 4 true",
                        "/playsound random.fizz @a[r=16]"
                    ],
                    "transitions": [
                        {"default": "query.is_in_water_or_rain == 0"}
                    ]
                }
            }

Le tableau animations indique toutes les animations qui doivent s'exécuter dans cet état, qui, dans le cas présent, est simplement poison.

Dans l'étiquette on_exit, deux commandes qui vont s'exécuter lorsque le robot sortira de l'eau sont ajoutées. La première commande donnera au robot un effet de régénération de niveau quatre pendant deux secondes. La deuxième commande déclenchera un effet sonore de pétillement.

Veuillez noter que la commande aurait pu également être exécutée dans le tableau on_entry de l'état par défaut, mais cela aurait également lancé les effets lors de l'apparition du robot ou du rechargement du monde, car le jeu passera toujours par l'état default.

Pour résumer la relation entre les contrôleurs et les animations: un contrôleur d'animation est utilisé pour contrôler la lecture d'une animation, tandis qu'une animation est ce qui se produit à la suite de la transition vers l'animation telle que déterminée par le contrôleur. Les animations et les contrôleurs d'animation sont fournis au fichier de comportement de l'entité.

Quelle est la prochaine étape?

Dans ce guide, nous avons ajouté au jeu une entité personnalisée complète. Si vous avez utilisé les fichiers de modèle existants au lieu de créer les vôtres, le moment est peut-être venu d'en savoir plus sur Blockbench. Ou bien vous pouvez en apprendre davantage sur le comportement des entités pour le serveur.

Modélisation et animation d'entités Introduction au comportement de l'entité

Partager via