Événements d'animation

Une animation ne sert pas qu'à bouger des os. À n'importe quel moment d'une animation, tu peux faire apparaître des particules, jouer un son, changer une variable, ou même lancer une commande. Dans ce guide, notre golem de rubis laisse des étincelles rouges et un gros bruit sourd à chaque pas, et se met en colère quand il est gravement blessé.

Ce guide s'appuie sur Animations d'entité et Contrôleurs d'animation.

Les fichiers

RP/
  animations/
    ruby_golem.animation.json
  entity/
    ruby_golem.entity.json
  models/
    entity/
      ruby_golem.geo.json
BP/
  animations/
    ruby_golem.animation.json
  animation_controllers/
    ruby_golem.animation_controllers.json
  entities/
    ruby_golem.json

Eh oui, un pack de comportements peut aussi avoir des animations. La partie 3 explique pourquoi.

Quel pack peut faire quoi

La règle à retenir : le pack de ressources s'occupe de ce qu'on voit et entend sur l'écran de chaque joueur. Le pack de comportements s'occupe des vrais changements dans la partie, partagés par tout le monde.

Partie 1 : les particules

Donner un nom court à la particule

L'entité client liste les particules que la créature peut utiliser, chacune avec un nom court :

"particle_effects": {
  "sparkle": "wiki:ruby_sparkle",
  "dust": "minecraft:villager_happy"
}

À droite, on trouve l'identifiant d'un effet de particules. Ce peut être un effet vanilla ou un effet que tu as créé toi-même (voir Particules).

La faire apparaître depuis une animation

Ajoute particle_effects à l'animation. Les clés sont des temps en secondes, comme des images clés :

"animation.ruby_golem.walk": {
  "loop": true,
  "animation_length": 1.0,
  "bones": { },
  "particle_effects": {
    "0.0": { "effect": "sparkle", "locator": "left_foot" },
    "0.5": { "effect": "sparkle", "locator": "right_foot" }
  }
}

À chaque boucle de la marche, une étincelle apparaît sous le pied gauche, puis sous le pied droit.

Pour faire apparaître plusieurs particules en même temps, utilise une liste : "0.0": [ { ... }, { ... } ].

Les locators

Un locator est un point nommé à l'intérieur d'un os de ton modèle. Ajoute-les dans le fichier de géométrie :

{
  "name": "left_leg",
  "parent": "body",
  "pivot": [3, 12, 0],
  "locators": {
    "left_foot": [3, 0, 0]
  },
  "cubes": [ ]
}

Comme le locator se trouve dans un os, il bouge quand l'os bouge. Une particule placée sur left_foot suit la jambe qui se balance.

Partie 2 : les sons

Les sons marchent de la même façon. D'abord, des noms courts dans l'entité client :

"sound_effects": {
  "thud": "mob.wiki.ruby_golem.step"
}

À droite, on trouve le nom d'un événement sonore de RP/sounds/sound_definitions.json. Ensuite, ajoute sound_effects à l'animation :

"sound_effects": {
  "0.0": { "effect": "thud" },
  "0.5": { "effect": "thud" }
}

Chaque entrée de son a un effect et un locator facultatif, exactement comme les particules.

Depuis un état de contrôleur

Les états d'un contrôleur peuvent aussi avoir des particle_effects et des sound_effects. Ils n'ont pas de temps, car un état n'a pas de chronologie. À la place, ils démarrent quand la créature entre dans l'état :

"alert": {
  "animations": ["fists_up"],
  "particle_effects": [{ "effect": "sparkle", "locator": "head" }],
  "sound_effects": [{ "effect": "roar" }],
  "transitions": [{ "idle": "!query.has_target" }]
}

La timeline

En plus des particules et des sons, une animation peut avoir une timeline : une liste de choses à lancer à des moments précis. Dans un pack de ressources, la timeline exécute du Molang :

"animation.ruby_golem.blink": {
  "animation_length": 4.0,
  "loop": true,
  "timeline": {
    "0.0": "variable.eyes_closed = 0;",
    "3.8": "variable.eyes_closed = 1;"
  }
}

Toutes les quatre secondes, le golem ferme les yeux un instant. Un contrôleur de rendu peut lire variable.eyes_closed pour afficher une autre texture ou cacher les os des yeux (voir Contrôleurs de rendu).

Une clé peut contenir une seule chaîne ou une liste de chaînes : "1.0": ["variable.a = 1;", "variable.b = 2;"].

Partie 3 : les animations du pack de comportements

Voici l'astuce. Le serveur peut lui aussi lancer des animations et des contrôleurs. Il ne peut pas bouger d'os (le serveur n'a pas de modèle à bouger), mais il peut exécuter des timelines et des états de contrôleur. Ça en fait un mini outil de script dans ta créature, sans JavaScript.

Dans un pack de comportements, un événement peut être trois choses :

Les événements d'entité ne peuvent viser que la créature elle-même, donc c'est toujours @s suivi du nom de l'événement.

Étape 1 : un contrôleur qui surveille la vie

Faisons enrager le golem quand sa vie passe sous 20, et le calmer à nouveau quand il guérit :

{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.ruby_golem.rage": {
      "initial_state": "calm",
      "states": {
        "calm": {
          "transitions": [
            { "enraged": "query.health < 20" }
          ]
        },
        "enraged": {
          "on_entry": [
            "/say The ruby golem is cracking!",
            "/particle minecraft:lava_particle ~ ~1 ~",
            "@s wiki:enrage"
          ],
          "on_exit": [
            "@s wiki:calm_down"
          ],
          "transitions": [
            { "calm": "query.health >= 20" }
          ]
        }
      }
    }
  }
}

La liste on_entry s'exécute une fois quand le golem entre dans enraged. Les commandes partent du golem, donc ~ ~1 ~ veut dire un bloc au-dessus de lui.

Étape 2 : une animation minuteur qui se répète

Une animation en boucle dans le pack de comportements fait un minuteur bien pratique. Celle-ci soigne un peu le golem au début de chaque boucle de 10 secondes :

{
  "format_version": "1.10.0",
  "animations": {
    "animation.ruby_golem.regen": {
      "loop": true,
      "animation_length": 10.0,
      "timeline": {
        "0.0": "/effect @s regeneration 3 0 true"
      }
    }
  }
}

Étape 3 : les activer dans l'entité

Dans le fichier d'entité du pack de comportements, liste-les sous description et lance-les avec scripts.animate, comme le fait l'entité client :

{
  "format_version": "1.21.0",
  "minecraft:entity": {
    "description": {
      "identifier": "wiki:ruby_golem",
      "is_spawnable": true,
      "is_summonable": true,
      "animations": {
        "rage": "controller.animation.ruby_golem.rage",
        "regen": "animation.ruby_golem.regen"
      },
      "scripts": {
        "animate": ["rage", "regen"]
      }
    },
    "component_groups": {
      "wiki:enraged": {
        "minecraft:movement": { "value": 0.35 },
        "minecraft:attack": { "damage": 12 }
      }
    },
    "components": { },
    "events": {
      "wiki:enrage": {
        "add": { "component_groups": ["wiki:enraged"] }
      },
      "wiki:calm_down": {
        "remove": { "component_groups": ["wiki:enraged"] }
      }
    }
  }
}

Maintenant, un golem blessé se déplace plus vite et frappe plus fort, puis redevient normal dès que sa régénération le fait repasser au-dessus de 20 points de vie.

Quand quelque chose ne marche pas

Tu trouveras plus d'aide dans Dépannage.

Et ensuite

• Découvre les commandes que tu peux lancer depuis une timeline dans Commandes.
• Crée tes propres effets dans Particules.
• Lis la vie, les cibles et bien plus avec les requêtes Molang.