Introducción a Agregar entidad

Puedes usar un pack de comportamiento y un pack de recursos para agregar una entidad a Minecraft: Bedrock Edition. Tal como aprendiste en los tutoriales recomendados, el comportamiento de las entidades se puede cambiar con un pack de comportamiento y el aspecto, con un pack de recursos. Ambos son necesarios para agregar una entidad funcional al juego. Esta guía cuenta con dos partes: la primera cubre la estructura de archivos y carpetas necesaria para agregar una entidad personalizada a Minecraft. En la segunda parte, se muestra cómo darle vida a la entidad mediante componentes de comportamiento y animaciones.

Con este tutorial, aprenderás lo siguiente:

• Cómo crear una nueva entidad personalizada utilizando packs de recursos y comportamiento.
• Cómo aplicar varias funciones a la entidad, incluidos componentes y animaciones
• Cómo usar traducciones para los nombres de entidades

Requisitos

Se recomienda que completes lo siguiente antes de comenzar este tutorial.

• Introducción a los packs de comportamiento
• Introducción a los packs de recursos
• Descarga los packs de comportamiento y de recursos del robot mínimo y el robot completo

También se recomienda saber lo siguiente para entender mejor este artículo.

• El funcionamiento del formato JSON.
• Un editor de código como VSCode.

Estructura de los archivos

En el pack de comportamiento, hay un archivo de entidad que define la entidad del lado del servidor. En el pack de recursos, hay un archivo de la entidad cliente que se encarga de decirle al juego cómo se verá la entidad. En el siguiente gráfico, se muestra cómo pueden interactuar diferentes archivos para crear una entidad personalizada:

Ejemplo de una entidad de robot: el robot mínimo

Como punto de referencia para este tutorial, te proporcionamos dos versiones de la misma entidad: un robot que se puede generar al azar en el mundo y tiene tres texturas aleatorias, una animación de rueda, varios componentes y una mecánica de agua personalizada. El enlace de descarga está en la sección Requisitos anterior.

Para ver el robot en acción, elige uno de los conjuntos de packs de recursos y de comportamiento que acabas de descargar. Te recomendamos probar con el mínimo por ahora. Coloca los packs de recursos y de comportamiento en las subcarpetas com.mojang respectivas, inicia un mundo con trucos habilitados y usa /summon compass:robot.

Esta es la estructura del pack de comportamiento y del de recursos del "robot mínimo" terminado:

Parece complicado, pero solo debes preocuparte por los archivos que tienen "robot" en el nombre y dónde están almacenados.

Una vez que tengas una idea de cómo actúa el robot en el juego, puedes eliminar los packs de recursos y de comportamiento del robot terminado y recrearlos de cero con los pasos de este tutorial para tener una idea de cómo funcionan los archivos en conjunto.

Un buen punto de partida sería usar los packs de recursos y de comportamiento que creaste en los tutoriales anteriores. Puedes eliminar la entidad de vaca de ataque, pero es una preferencia personal.

Cómo asignar nombres

Cuando creas una entidad, lo primero que debes tener en cuenta es qué ID le darás. Los archivos de tus packs de recursos y de comportamiento se deberán sincronizar mediante el ID de entidad que le des a tu entidad. Este ID consta de un espacio de nombres y un nombre separados por dos puntos. Nos referimos al ID compass:robot que usamos antes para invocar al robot.

Tu espacio de nombres puede ser una versión corta del nombre de tu equipo o del nombre del producto. El ID solo debe incluir letras minúsculas, números y guiones bajos. No uses "minecraft" como espacio de nombres para contenido personalizado. El espacio de nombres "minecraft" está reservado para recursos de la versión original, por lo que solo debes usar "minecraft" si estás sobrescribiendo contenido original.

La mayoría de los archivos que definen la entidad serán archivos JSON. Para evitar confusiones, se recomienda usar un formato extendido de la extensión de archivo mientras creas cada archivo. El juego omite los nombres de archivo en la mayoría de los casos, pero, cuando se trabaja en un complemento, los nombres de archivo poco claros pueden resultar confusos. Las extensiones son las siguientes:

Tipo de archivo	Nombre del archivo
Archivos de la entidad cliente	nombre_de_entidad.entity.json
Archivos del modelo	nombre_de_entidad.geo.json
Archivos de animación	nombre_de_entidad.animation.json
Controles de animación	nombre_de_entidad.animation_controllers.json
Controles de renderizado	nombre_de_entidad.render_controllers.json

entity_name debe reemplazarse por el nombre de tu entidad, sin incluir el espacio de nombres.

Versiones del formato

Cada archivo JSON debe tener una etiqueta format_version. Esta etiqueta es importante para que el juego lea correctamente el archivo. Es importante saber que los archivos creados en formatos más antiguos seguirán funcionando en las versiones más recientes del juego, pero solo si la versión del formato está configurada correctamente. Las versiones de formato incorrecto son un motivo frecuente de errores.

Definición del pack de comportamiento

El primer paso práctico para agregar un robot al juego empieza en el pack de comportamiento. Crea un archivo nuevo en la carpeta entities del pack de comportamiento y llámalo robot.json. Copia y pega el siguiente código.

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

Dentro de la etiqueta de descripción, definimos los atributos básicos de la entidad. identifier establece el ID de la entidad. is_spawnable más adelante, agregará un huevo de generación en el juego para que el jugador pueda generar esta criatura. is_summonable hará que la entidad funcione con el comando /summon.

Dentro de components, agregaremos componentes para cambiar el comportamiento de la entidad. Por ahora, solo agregaremos el componente minecraft:physics. Esto hará que la entidad tenga gravedad y un comportamiento de colisión regular.

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

Guarda el archivo robot.json y continúa con el paso siguiente.

Definición de la entidad cliente

Ahora debemos agregar la entidad al pack de recursos para darle una apariencia visual. En la carpeta entity del pack de recursos, crea un archivo JSON nuevo llamado robot.entity.json.

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

Esta es la estructura básica del archivo. Hasta ahora, es similar al archivo del lado del comportamiento que creamos en la sección anterior. Ten en cuenta que ahora usamos client_entity, en lugar de solo "entity". Al momento de escribir este artículo, la última versión de formato para este archivo es1.10.0.

La etiqueta spawn_egg define cómo se verá el huevo de generación en el inventario. Con este método, se verá como un huevo de generación original pero con colores personalizados.

Efectos visuales

Antes de que podamos agregar la entidad al juego, necesita un modelo. En el artículo Modelado y animación de las entidades, se explica cómo crear un modelo y una textura personalizados, pero, para esto, se necesitan muchos conocimientos y todavía no terminamos con este tutorial. Así que, por el momento, copia y pega los archivos del pack de recursos del robot para fingir que ya creaste un modelo. Usa estos mismos pasos más adelante para agregar el modelo que crees.

• Guarda el modelo en la carpeta models/entity como robot.geo.json.
• Guarda la textura en textures/entity como robot.png.

Ahora que los archivos del modelo están en su lugar, necesitamos un control de renderizado para vincular el modelo, la textura y el material que se usan para la entidad.

Abre el archivo robot.entity.json en la carpeta entity de tu pack de recursos.

Para la mayoría de las entidades (como nuestro robot), podemos usar el control de renderizado predeterminado que viene con el juego. Hablaremos más sobre los controles de renderizado más adelante, en la parte más avanzada de este tutorial. Por ahora, debes saber que aquí es donde se encuentra y este debería ser el contenido:

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

Se hace referencia al modelo por el nombre de la geometría. Si creas un modelo en Blockbench, asegúrate de que el nombre de la geometría en la configuración del proyecto sea el nombre de tu entidad. En este caso, "robot".

A diferencia de las geometrías, las texturas se vinculan por su ruta en el pack de recursos, sin incluir la extensión del archivo, como se muestra en el ejemplo.

En la mayoría de los casos, no se requiere un material personalizado. En cambio, puedes utilizar un material predeterminado. En este ejemplo, usamos entity. Si la textura tiene partes transparentes, puedes usar entity_alphatest; si la textura es translúcida (como cristal teñido), puedes usar entity_alphablend.

Cadenas de traducción

En este momento, ni la entidad en sí ni el huevo de generación tienen un nombre que los represente en el juego. Para definir un nombre, necesitamos un archivo de idioma. Crea una nueva carpeta llamada texts dentro de tu pack de recursos y crea un nuevo archivo llamado en_US.lang. Para las entidades personalizadas, solo necesitamos cambiar este archivo de idioma, ya que todos los demás idiomas tendrán el inglés estadounidense como opción predeterminada. Dentro de este archivo, agrega las dos líneas siguientes:

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

La primera línea define el nombre de la entidad. Será visible en los mensajes de muerte y en la salida de algunos comandos. La clave y el valor siempre están separados por un signo igual. La primera línea se puede dividir de la siguiente forma:

entity.<identifier>.name=<Name>

La segunda línea define el nombre de elemento correspondiente al huevo de generación:

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

Pruebas

Asegúrate de realizar pruebas en las primeras etapas del proceso y de hacerlo con frecuencia. Detectar un problema desde el principio permite hacerle un mejor seguimiento, lo que puede facilitar su solución. Muchas veces las pruebas revelan problemas poco después de realizar cambios, lo que acota la búsqueda de la causa a los cambios recientes.

Deberías poder generar tu entidad en el juego usando el huevo de generación o el comando de invocación. Si solo deseas una entidad estática, estás listo para comenzar. Sigue leyendo si quieres personalizar aún más la entidad.

Ejemplo de una entidad de robot: el robot completo

Este sería un buen momento para probar los packs de comportamiento y de recursos del robot completo. Compara la colección de carpetas y archivos. Después devuelve tus packs del robot mínimo para poder seguir agregando funcionalidades.

Componentes

Los componentes le dicen a la entidad cómo actuar en el juego. Agreguemos algunos componentes y expliquemos en detalle lo que hacen.

En la carpeta behavior pack/entities/, abre robot.json y reemplaza la entrada única de "minecraft:physics": {} con todo esto…

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

Nombre del componente	Descripción
minecraft:nameable	Permite que el jugador nombre la entidad con una etiqueta de nombre.
minecraft:movement	Le dice a la entidad con qué velocidad debe moverse. 0.25 es la velocidad normal de la mayoría de los animales en Minecraft.
minecraft:movement.basic	Le da a la entidad la capacidad de moverse por el suelo.
minecraft:jump.static	Permite que la entidad salte para subir bloques.
minecraft:navigation.walk	Permite que la entidad navegue por el mundo. Evitar el agua es una de las opciones que trae este componente.
minecraft:behavior.tempt	Hace que la entidad siga a los jugadores que tienen diamantes en la mano. Le estamos dando a este comportamiento una prioridad más alta para que priorice esta acción (número más bajo = prioridad más alta).
minecraft:behavior.random_stroll	Hace que la entidad camine aleatoriamente por el lugar. Establecemos la prioridad en un número más alto para que la entidad solo haga esto cuando no tenga otra cosa que hacer. El multiplicador de velocidad disminuye la velocidad cuando se usa esta forma de caminar.
minecraft:experience_reward	Hace que la entidad pierda experiencia cuando es asesinada por un jugador.

Animaciones

En esta sección, solo agregaremos una animación de rueda simple al robot. Si deseas obtener más información sobre animaciones, cómo usar los controles de animación y cómo crear animaciones en Blockbench, lee esta guía.

Las animaciones se almacenan en archivos de animación. Entonces, lo primero que debemos hacer es crear una carpeta llamada animations en el pack de recursos y crear un archivo llamado robot.animation.json en esa carpeta. En ese archivo, crearemos una nueva animación llamada animation.robot.drive. También queremos establecer que loop sea true para que la animación se reproduzca de forma continua. El archivo debería verse así:

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

Las animaciones nos permiten animar la posición, la rotación y la escala de cada hueso. (Si todavía no sabes qué significa "hueso" en ese contexto, no te preocupes. Aprenderás sobre los huesos cuando aprendas a usar Blockbench. Por ahora, solo debes saber que se refiere a una pieza del modelo, como una pierna o una rueda). Las animaciones se pueden hacer con fotogramas clave, expresiones de Molang o una combinación de ambos. En este ejemplo, solo usaremos expresiones de Molang.

Molang es un lenguaje que se usa solo para packs de recursos y comportamiento. Nos permite obtener varios números de la entidad usando una consulta y calcular un resultado de estos números usando expresiones matemáticas. Por ejemplo, la consulta query.modified_distance_moved devolverá la distancia que la entidad recorrió al moverse. Podemos usarla para calcular la rotación de la rueda del robot en el ejeX, lo que permitirá obtener una animación en la que el robot parece estar conduciendo. Te sugerimos probar distintos valores, pero, para este modelo, 60funcionó bastante bien.

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

Ahora que se creó la animación, debemos vincularla en el archivo de la entidad cliente. (Recuerda que el pack de recursos es el cliente, así que abre <resource pack>/entity/robot.entity.json para esta próxima parte). La etiqueta animations vincula todas las animaciones y los controles de animación que usa la entidad. Cada animación recibe un nombre corto que se puede usar para reproducir la animación en un control de animación o directamente en el archivo, en este caso drive.

Las secciones scripts y animate se pueden utilizar para reproducir animaciones directamente:

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

Si se agregan estas dos etiquetas en la etiqueta de descripción del archivo de la entidad cliente, la animación de la unidad siempre estará activa y hará que avance la rotación de la rueda mientras la entidad se está moviendo.

Controles de renderizado

Los controles de renderizado nos permiten cambiar la geometría, las texturas y los materiales de la entidad usando Molang. El siguiente ejemplo muestra cómo utilizar la geometría, el material y la textura que se vincularon en el archivo de la entidad cliente como default:

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

Si solo queremos usar una geometría, un material y una textura predeterminados, podemos dejar que apunte al control de renderizado predeterminado como lo hicimos antes. Pero este es un buen momento para aprender a agregar texturas aleatorias, así que analicemos cómo funcionan los controles de renderizado.

Explicación del control de renderizado

Notarás que la etiqueta base se llama render_controllers. Esto significa que podemos especificar varios controles de renderizado en un archivo.

El nombre de nuestro control de renderizado se asigna utilizando el siguiente esquema: controller.render.<entity_name>. Para un control de renderizado multipropósito, también podemos usar otra palabra clave en lugar del nombre de la entidad.

Dentro de la etiqueta del control de renderizado, se especifican los diferentes recursos, pero notarás que cada uno usa un formato JSON diferente.

Geometría

Un control de renderizado solo puede mostrar una geometría a la vez. Por eso se vincula directamente como una sola cadena. Esta cadena puede ser una expresión de Molang y siempre debe mostrar una geometría. En este caso, está llamando a Geometry.default, lo que significa que mostrará la geometría vinculada como default de cualquier entidad que use el control de renderizado.

Puedes renderizar varias geometrías en una entidad utilizando varios controles de renderizado. Sin embargo, esto puede ser complicado y provocar un comportamiento inesperado. Por lo tanto, solo se recomienda para creadores experimentados.

Materiales

A diferencia de la geometría, los materiales se definen como una matriz de objetos. El propósito es que podamos asignar a cada hueso un material separado. Cada objeto de la matriz puede tener un par clave-valor. La clave selecciona un conjunto de huesos. El asterisco funciona como comodín. Esto significa que todos los huesos, sin importar su nombre, tendrán asignado el material predeterminado. Ten en cuenta que los materiales se asignan en orden, lo que significa que los materiales que se encuentran más abajo en la lista pueden sobrescribir los materiales anteriores.

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

En este ejemplo, primero aplicamos el material predeterminado a todos los huesos. Luego, sobrescribimos el material con el material transparente en todos los huesos que terminan en _arm. De esa forma, todos los huesos del brazo tendrán transparencia.

Texturas

Las texturas se especifican en una matriz. En la mayoría de los casos, aquí solo se vinculará una textura, ya que las entidades no admiten texturas separadas. Sin embargo, hay una excepción: los materiales pueden admitir múltiples texturas superpuestas, como el material entity_multitexture. Por ejemplo, las llamas lo utilizan para superponerse a la decoración.

Matrices

Cuando se trabaja con varios recursos de un mismo tipo, puede resultar útil utilizar una matriz. Una matriz es una lista de enlaces de recursos que se definen en el control de renderizado, de la cual puedes elegir un recurso usando Molang.

Podemos definir una matriz para el robot de esta manera:

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

En la sección de matrices, podemos definir matrices para cada una de las tres categorías: textures, materials y geometries. Dentro de la categoría, puedes definir matrices usando Array.<array name> como el nombre. Cada línea dentro de la matriz vincula una textura que se define en el archivo de la entidad cliente.

Puedes acceder a la matriz utilizando Molang. Las matrices comienzan con la posición0, por lo que se puede acceder a la primera textura de esta matriz a través de Array.variant[0].

En este ejemplo, usamos la consulta de variante para elegir una textura de la matriz. La variante de una criatura se puede cambiar a través del componente minecraft:variant en el archivo de comportamiento.

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

Ahora necesitamos vincular las texturas adicionales en el archivo de la entidad cliente. La textura de robot azul normal ya está vinculada como default. Ahora crearemos dos copias del archivo de textura del robot, editaremos el color y los vincularemos como variant_b y variant_c.

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

Ahora, las texturas están vinculadas. El último paso es aleatorizar la variante en el archivo de comportamiento. Usaremos grupos de componentes para esto. Esos pasos constituyen una forma de agregar y eliminar un conjunto de componentes de la entidad en cualquier momento. También usaremos un evento que aleatoriza qué grupo de componentes agregar.

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

Ahora, cuando generamos la entidad por primera vez, elige aleatoriamente un grupo de componentes y, por lo tanto, una variante. Esta es una técnica muy común para aleatorizar la apariencia de una entidad.

Generación

Las reglas de generación definen cómo las entidades se generan aleatoriamente en el mundo. Crearemos un archivo de reglas de generación para nuestro robot. Primero, crea una carpeta llamada spawn_rules en tu pack de comportamiento. Dentro de la carpeta, crea un nuevo archivo de texto llamado robot.json. El contenido del archivo debería verse así:

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

Dentro de minecraft:spawn_rules, hay dos cosas que debemos tener en cuenta: el control de la población y las condiciones.

description define las propiedades básicas del archivo. identifier debe coincidir con el identificador de nuestra entidad. population_control define en qué se basará el juego para saber cuántas criaturas generar y es un poco más complicado.

Control de la población

Hay diferentes grupos de entidades. Cuando se considere que el grupo definido aquí está lleno, el juego ya no generará criaturas de este grupo. Hay tres opciones diferentes:

• "animal": Criaturas pasivas, como las vacas y los cerdos.
• "water_animal": Criaturas que viven en el agua, como los peces tropicales y delfines.
• "monster": Criaturas hostiles, como los esqueletos y los zombis.

Para el robot, usamos el grupo de animales.

Condiciones

conditions es una matriz de posibles condiciones que permitirían que una criatura se genere en el mundo. Cada una de las condiciones intenta por separado generar criaturas en el mundo. Cada una consta de un grupo de componentes que definen cuándo se debe generar la criatura y cuándo no.

Para una regla básica de generación, una condición es suficiente. Para el robot, usaremos la siguiente configuración:

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

Nombre del componente	Descripción
minecraft:spawns_on_surface	La criatura se genera en la superficie.
minecraft:brightness_filter	Solo genera la entidad con un brillo determinado. Acepta tres opciones, min, max y adjust_for_weather. Los niveles de luz van de 0 a 15. Si adjust_for_weather se establece en true, se tendrá en cuenta la disminución del nivel de luz debido a la lluvia y las tormentas eléctricas.
minecraft:weight	El peso de la entidad en el proceso de generación. Cuanto más alto sea el número, mayor será la frecuencia con que se generará esta criatura.
minecraft:biome_filter	Filtra el bioma en el que se puede generar la criatura. Los filtros de bioma funcionan de manera similar a los filtros del comportamiento, lo que significa que están permitidos los operadores all_of y any_of. Los biomas tienen diferentes etiquetas que indican el tipo de bioma, la variante, la dimensión y características tales como monstruo y animal.

Los robots ahora se generarán en cualquier lugar de la superficie donde puedan generarse animales y donde haya luz suficiente. Con un peso de 40, también se generarán con bastante frecuencia.

Animaciones de comportamiento

Las animaciones de comportamiento funcionan de manera similar a las animaciones normales, pero se ejecutan en el pack de comportamiento. Mientras que las animaciones comunes animan el movimiento del modelo, así como los sonidos y las partículas, las animaciones de comportamiento pueden ejecutar comandos habituales, desencadenar eventos de entidad o ejecutar expresiones de Molang. A las animaciones de comportamiento también se las suele llamar eventos de entidad, aunque ese nombre tiende a ser un poco confuso.

Dado que a los robots no les gusta el agua, agregaremos una mecánica para que los robots se dañen en el agua o la lluvia. Primero, crearemos un control de animación que use una consulta de Molang para comprobar si la entidad está en el agua. Crea una nueva carpeta en el pack de comportamiento llamada animation_controllers y crea el archivo robot.animation_controllers.json en ella:

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

El control de animación se parece mucho a los controles de animación normales que se usan del lado del cliente. Tiene dos estados que se alternan según si el robot está en el agua o no.

Ahora, agreguemos una animación para aplicarle un efecto de veneno al robot. Crea la carpeta animations en el pack de comportamiento y crea un archivo llamado robot.animation.json:

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

En lugar de usar aquí la etiqueta de hueso para animar huesos, usamos la etiqueta de línea de tiempo. En los packs de recursos, las líneas de tiempo solo se pueden usar para ejecutar código de Molang. En las animaciones de comportamiento, puedes usar esto para ejecutar código de Molang, utilizar comandos o desencadenar eventos de entidad. Ten en cuenta que todos estos son de tipo cadena. El juego determinará el tipo de cadena a partir de su contenido. Si la cadena comienza con una barra diagonal, se ejecutará como un comando. Si se ajusta a este esquema: @s namespace:event, se ejecutará como un evento de entidad. Si luce como código de Molang, se ejecutará como Molang.

Por esa razón, es importante iniciar los comandos con una barra diagonal en las animaciones de comportamiento. Además, ten en cuenta que estamos aplicando veneno durante dos segundos porque uno no sería suficiente para causar daño. La palabra true al final del comando hará que el efecto de estado sea ambiental, lo que significa que no habrá partículas.

Al igual que con las animaciones en los packs de recursos, necesitamos vincular todas las animaciones y los controles de animación en la etiqueta de descripción de nuestra entidad, que se verá así:

        "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 sección de animaciones enumera todas las animaciones y los controles de animación que usa la entidad y les da un nombre corto. En la sección scripts/animate, enumeramos las animaciones que siempre deben ejecutarse. Queremos que el control detecte el estado de ejecución permanente, pero no el efecto de veneno.

Ahora, debemos volver al control de animación y agregar el efecto de veneno. También agregaremos una pequeña mecánica de regeneración junto con un efecto de sonido, para que el robot no muera tan fácilmente.

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

En la matriz animations, enumeramos todas las animaciones que deberían ejecutarse en este estado, que, en nuestro caso, es solo poison.

En la etiqueta on_exit, agregaremos dos comandos que se ejecutarán cuando el robot salga del agua. El primer comando le dará al robot un efecto de regeneración de nivel cuatro durante dos segundos. El segundo comando reproducirá un efecto de sonido de efervescencia.

Ten en cuenta que también podríamos haber ejecutado el comando en la matriz on_entry del estado predeterminado, pero eso también habría aplicado los efectos al generar el robot o recargar el mundo porque la primera transición del juego siempre será al estado default.

Para resumir la relación entre los controles y las animaciones: un control de animación se usa para controlar cuándo se reproduce una animación, mientras que una animación en sí es lo que ocurre como resultado de la transición a la animación según lo determinado por el control. Las animaciones y los controles de animación se suministran al archivo de comportamiento de la entidad.

¿Cuál es el siguiente paso?

En esta guía, agregamos una entidad personalizada completa al juego. Si usaste los archivos del modelo existente en lugar de crear uno propio, este sería un buen momento para aprender a usar Blockbench. O puedes leer más sobre el comportamiento de las entidades para el servidor.

Modelado y animación de las entidades Introducción al comportamiento de las entidades