Eventos de animación

Las animaciones pueden hacer mucho más que mover huesos. En cualquier momento de una animación puedes generar partículas, reproducir un sonido, cambiar una variable o incluso ejecutar un comando. En esta guía, nuestro gólem de rubí suelta chispas rojas y un golpe sordo en cada paso, y se enfada cuando está muy herido.

Esta guía parte de Animaciones de entidades y Controladores de animación.

Los archivos

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

Sí, un paquete de comportamiento también puede tener animaciones. La parte 3 explica por qué.

Qué puede hacer cada paquete

La regla general: el paquete de recursos se encarga de lo que se ve y se oye en la pantalla de cada jugador. El paquete de comportamiento se encarga de los cambios reales en el juego que todos comparten.

Parte 1: partículas

Dale a la partícula un nombre corto

La entidad de cliente enumera las partículas que puede usar la criatura, cada una con un nombre corto:

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

A la derecha va el identificador de un efecto de partículas. Puede ser uno del juego base o uno que hayas hecho tú (consulta Partículas).

Lánzala desde una animación

Añade particle_effects a la animación. Las claves son tiempos en segundos, igual que los fotogramas clave:

"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" }
  }
}

Cada vez que la animación de caminar se repite, aparece una chispa bajo el pie izquierdo y luego bajo el derecho.

Para generar varias partículas a la vez, usa una lista: "0.0": [ { ... }, { ... } ].

Localizadores

Un localizador (locator) es un punto con nombre dentro de un hueso de tu modelo. Se añaden en el archivo de geometría:

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

Como el localizador está dentro de un hueso, se mueve cuando el hueso se mueve. Una partícula en left_foot sigue a la pierna mientras se balancea.

Parte 2: sonidos

Los sonidos funcionan igual. Primero, los nombres cortos en la entidad de cliente:

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

A la derecha va el nombre de un evento de sonido de RP/sounds/sound_definitions.json. Después, añade sound_effects a la animación:

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

Cada entrada de sonido tiene effect y un locator opcional, igual que las partículas.

Desde un estado del controlador

Los estados de un controlador también pueden tener particle_effects y sound_effects. No llevan tiempos, porque un estado no tiene línea de tiempo. En su lugar, se lanzan cuando la criatura entra en el estado:

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

La línea de tiempo

Además de partículas y sonidos, una animación puede tener un timeline: una lista de cosas que se ejecutan en momentos concretos. En un paquete de recursos, la línea de tiempo ejecuta Molang:

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

Cada cuatro segundos el gólem cierra los ojos un momento. Un controlador de renderizado puede leer variable.eyes_closed para mostrar otra textura u ocultar los huesos de los ojos (consulta Controladores de renderizado).

Una clave puede contener una cadena o una lista de cadenas: "1.0": ["variable.a = 1;", "variable.b = 2;"].

Parte 3: animaciones del paquete de comportamiento

Aquí viene lo ingenioso. El servidor también puede ejecutar animaciones y controladores. No puede mover huesos (el servidor no tiene ningún modelo que mover), pero sí puede ejecutar líneas de tiempo y estados de controlador. Eso los convierte en una pequeña herramienta de programación dentro de tu criatura, sin necesidad de JavaScript.

En un paquete de comportamiento, los eventos pueden ser tres cosas:

Los eventos de entidad solo pueden apuntar a la propia criatura, así que siempre es @s seguido del nombre del evento.

Paso 1: un controlador que vigila la salud

Vamos a hacer que el gólem se enfurezca cuando su salud baje de 20 y se calme de nuevo cuando se cure:

{
  "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 lista on_entry se ejecuta una vez cuando el gólem entra en enraged. Los comandos se ejecutan desde el gólem, así que ~ ~1 ~ significa un bloque por encima de él.

Paso 2: una animación temporizadora que se repite

Una animación en bucle del paquete de comportamiento es un temporizador muy práctico. Esta le da al gólem una pequeña curación al principio de cada bucle de 10 segundos:

{
  "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"
      }
    }
  }
}

Paso 3: actívalos en la entidad

En el archivo de entidad del paquete de comportamiento, enuméralos en description y reprodúcelos con scripts.animate, igual que hace la entidad de cliente:

{
  "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"] }
      }
    }
  }
}

Ahora un gólem herido se mueve más rápido y golpea más fuerte, y vuelve a la normalidad cuando la regeneración lo lleva por encima de 20 de salud.

Cuando algo sale mal

Tienes más ayuda en Solución de problemas.

Qué sigue

• Aprende qué comandos puedes ejecutar desde una línea de tiempo en Comandos.
• Crea tus propios efectos en Partículas.
• Lee la salud, los objetivos y más con las consultas de Molang.