Saltar al contenido principal

Animaciones de FreeMinecraftModels

FreeMinecraftModels importa datos de animación de archivos .bbmodel y .fmmodel. Esta página explica los nombres reservados, cómo se mezclan las animaciones, los tiempos de los fotogramas, la interpolación, los modos de bucle, la cinemática inversa (IK) y cómo giran los modelos.

Para las reglas de nomenclatura de huesos y el resto del contrato de importación, consulta las Notas de Creación de Modelos.

Animaciones de estado​

FreeMinecraftModels vincula estos seis nombres de animación en minúsculas, y los cuatro de nado y de montura de más abajo, a estados automáticos durante la ejecución. Todo lo demás en el modelo es una animación personalizada.

Nombre de la animaciónEn bucleCuándo se reproduce
spawnnoUna vez, al crear el modelo. Cuando termina, el modelo pasa a walk si su entidad se está moviendo y, si no, a idle
idlesíMientras la entidad no tiene velocidad horizontal. Pasa a walk con una fusión progresiva cuando la velocidad en X o Z deja de ser cero
idle.longnoUna vez, después de que el modelo haya mostrado idle sin que se reproduzca nada más durante un número aleatorio de segundos entre longIdleMinSeconds y longIdleMaxSeconds (de 15 a 30 segundos por defecto). Después el modelo vuelve a idle con una fusión progresiva y la espera empieza de nuevo
walksíMientras la velocidad de la entidad en X o Z es distinta de cero. Pasa a idle con una fusión progresiva cuando ambas son cero
attacknoCuando se activa. Se reproduce una vez sobre idle o walk y termina
deathnoCon removeWithDeathAnimation(). Aparece en fundido desde la pose actual. Cuando termina, el modelo se encoge durante 20 ticks y se elimina

FMM activa attack por sí mismo solo para los Evokers, cuando aparecen a menos de dos bloques de él unos colmillos que el Evoker ha invocado. Otros plugins activan ataques mediante la API. EliteMobs reproduce attack.melee y attack.ranged. Todo nombre que empieza por attack. es un ataque y se reproduce como attack.

idle.long se reproduce una sola vez, diga lo que diga su ajuste de bucle de Blockbench. Moverse, un ataque u otra acción, una animación personalizada en la capa base y un jugador que dirige a la criatura como montura reinician la espera, y esas mismas cosas cortan un idle.long en curso. Un modelo sin idle.long nunca espera. idle.long necesita FreeMinecraftModels 2.15.0 o posterior; las versiones anteriores lo tratan como una animación personalizada.

Otras cuatro animaciones base se reproducen en lugar de walk e idle mientras la criatura nada o un jugador la monta, siempre que el modelo las tenga:

  • Montura. Un modelo sobre un caballo ensillado que dirige un jugador, como una mascota montada o una montura de /fmm mount, reproduce ride en lugar de walk mientras se mueve, e idle.ride en lugar de idle mientras está quieto. Un archivo de mascota puede nombrar otras animaciones con riding.animation y riding.idleAnimation; consulta Monta. Los plugins llaman a getAnimationComponent().setRiddenAnimation(name) y setRiddenIdleAnimation(name), donde null desactiva una de ellas. Un modelo sin ride camina bajo su jinete, y uno sin idle.ride reproduce idle.
  • Nado. Un modelo cuya criatura nada, es decir, está en el agua y sin tocar el suelo, reproduce swim en lugar de walk mientras se mueve, e idle.swim en lugar de idle mientras se mantiene quieto. Un archivo de mascota puede nombrar otras animaciones con swimming.animation y swimming.idleAnimation; consulta Nado. Los plugins llaman a getAnimationComponent().setSwimAnimation(name) y setIdleSwimAnimation(name), donde null desactiva una de ellas. Un modelo sin swim camina en el agua, y uno sin idle.swim reproduce idle mientras se mantiene quieto. Una montura que dirige un jugador también reproduce sus animaciones de montura en el agua.

Las cuatro necesitan FreeMinecraftModels 2.15.0 o posterior.

Nombres​

Los nombres de animación van en minúsculas. Un punto separa un nombre general de uno más específico, y un guion bajo une palabras dentro de una misma parte: idle.long es un tipo de idle, y attack.melee un tipo de attack. Cada pose quieta es idle. seguido del nombre del movimiento que detiene:

En movimientoQuieto
En tierrawalkidle, e idle.long de vez en cuando
En el aguaswimidle.swim
Montadorideidle.ride

Cuando a un modelo le falta un nombre con punto, FMM reproduce en su lugar el nombre hasta su último punto: attack para attack.melee, idle para idle.swim. Lo mismo vale para los nombres que reproducen los scripts y los plugins: tanto playAnimation como hasAnimation lo siguen.

Los modelos hechos antes de esto usaban long_idle, attack_melee y attack_ranged. FMM los encuentra con los nombres nuevos, y los nombres nuevos con los antiguos, así que los modelos y los plugins antiguos siguen funcionando sin cambios.

Los nombres con punto, el fallback y las grafías antiguas necesitan FreeMinecraftModels 2.15.0 o posterior.

Reglas que se derivan de cómo está construida la máquina de estados:

  • El estado inicial es spawn si el modelo lo tiene y, si no, idle. Un modelo que no tenga ninguno de los dos muestra su pose de reposo hasta que empieza a caminar o algo reproduce una animación.
  • Solo se usan las animaciones que existen en el modelo. Un modelo con walk pero sin idle sigue caminando después de dejar de moverse.
  • El cambio idle/walk lee la velocidad horizontal de la entidad subyacente; el movimiento vertical por sí solo no activa la animación de caminar. Las entidades estáticas y los disfraces de jugador no tienen una entidad subyacente para este propósito, y los elementos decorativos inmóviles no tienen movimiento horizontal. Sus animaciones adicionales se controlan mediante scripts, la API o el controlador de disfraces de FMM.
No hay estado jump

Las entidades modeladas normales no tienen estado de salto. Una animación llamada jump se comporta como cualquier otra animación personalizada y hay que reproducirla por nombre. Los disfraces de jugador son la excepción: su controlador aparte reproduce jump cuando el jugador salta.

Fusión de animaciones​

FMM reproduce las animaciones de un modelo en dos capas y las mezcla en una sola pose en cada tick, tanto en Java como en Bedrock.

CapaQué se reproduce en ella
Basespawn, idle, idle.long, walk, las animaciones de montura y de nado, y death, o una animación personalizada reproducida con blend en false, que se apodera de toda la pose
Acciónattack y todo nombre attack., como attack.melee y attack.ranged, damaged y las animaciones personalizadas reproducidas con blend en true. Una acción se reproduce sobre la capa base, así que un modelo puede atacar mientras camina

Un hueso que la animación base no anima vuelve a su pose de reposo. Un hueso que la acción no anima conserva su pose base.

Fundidos​

CambioFundido
Entre idle, idle.long, walk y las animaciones de montura y de nadoFusión progresiva durante idleWalkBlendTicks, 5 ticks por defecto. Ambas animaciones siguen reproduciéndose durante el fundido
Cualquiera a deathFundido desde la pose que mostraba el modelo en el tick anterior, acción incluida, durante deathBlendTicks, 4 ticks por defecto
Cualquier otro cambioInstantáneo

Los fundidos aceleran y frenan suavemente en lugar de avanzar a un ritmo constante. Cuando un nuevo cambio entre idle y walk interrumpe un fundido, el siguiente fundido parte de la pose que el modelo estaba mostrando. Las acciones empiezan y terminan sin fundido.

Override y peso de mezcla​

FMM lee dos ajustes de las propiedades de cada animación en Blockbench.

Ajuste de BlockbenchEfecto en FMM
Override activadoEn la capa de acción, los huesos que la animación anima toman su pose y descartan la pose base
Override desactivado (por defecto)En la capa de acción, la rotación y la posición de la animación se suman a la pose base de los huesos que anima, y su escala multiplica la escala base
Blend WeightEscala la intensidad con la que se aplica la animación, en cualquiera de las dos capas. 1 (el valor por defecto) aplica los fotogramas clave tal como se crearon. 0.5 aplica la mitad de cada rotación y posición y mueve la escala la mitad del camino desde 1 hacia el valor animado

Activa Override cuando los huesos que anima un ataque deban alcanzar exactamente la pose creada, sea lo que sea que esté haciendo el ciclo de caminar. Déjalo desactivado para sumar el movimiento del ataque al de caminar, por ejemplo un golpe de brazos mientras las piernas siguen caminando. En Java, Override no tiene efecto en las animaciones de la capa base, que siempre sustituyen la pose.

FMM lee Blend Weight solo como un número simple. Una expresión Molang registra Model <model>, animation <animation> has the blend weight '<value>'. FreeMinecraftModels only reads plain numbers and uses 1. FMM no admite Start Delay, Loop Delay ni Anim Time Update de Blockbench. Una animación que defina alguno de ellos registra un aviso y se reproduce sin ellos.

Qué animación gana​

  • Las animaciones personalizadas, damaged incluida, tienen prioridad sobre las integradas. Mientras una se reproduce en cualquiera de las dos capas, las solicitudes de ataque se descartan. death interrumpe todo.
  • Una acción nueva sustituye a la acción en curso, así que un segundo ataque reinicia el ataque, y una animación personalizada reproducida con blend en true sustituye a un ataque en curso.
  • Una animación personalizada reproducida con blend en false termina la acción actual.
  • Mientras una animación personalizada ocupa la capa base, FMM sigue llevando la cuenta de idle y walk por debajo. Ocupar la capa base termina un spawn o un idle.long en curso. Cuando termina una animación personalizada de una sola ejecución, el modelo pasa de golpe a idle o walk, según corresponda a su movimiento. Una solicitud explícita de idle o walk termina de inmediato una animación personalizada en bucle, y se muestra cuando termina una de una sola ejecución.
  • Una acción de una sola ejecución termina tras su último fotograma. Si la capa base no tiene nada que mostrar, por ejemplo en un prop sin animación spawn ni idle, la acción mantiene su último fotograma, así que una puerta abierta de este modo permanece abierta. Una animación personalizada de una sola ejecución en la capa base también mantiene su último fotograma cuando el modelo no tiene idle ni walk al que volver.

Los disfraces de jugador usan otro conjunto​

Un disfraz de jugador añade un controlador por tick que solicita animaciones mediante el mismo motor de reproducción. Sus cinco nombres reservados son attack, jump, sneak, walk e idle, evaluados en ese orden de prioridad cuando no está activa la cuenta atrás de una animación de una sola ejecución. attack se reproduce en la capa de acción, jump y sneak ocupan la capa base, y idle y walk seleccionan los estados integrados. Avisa en la consola si el modelo no tiene idle. Consulta Disfraces de Jugador para ver la tabla completa y la limitación temporal de esas animaciones.

Animaciones personalizadas​

Cualquier animación cuyo nombre no sea uno de los nombres de estado anteriores puede reproducirse igualmente por nombre:

modeledEntity.playAnimation("open", /* blend */ true, /* loop */ false);
modeledEntity.stopCurrentAnimations();
boolean exists = modeledEntity.hasAnimation("open");
context.prop:play_animation("open", true, false)
context.prop:stop_animation()
  • blend elige la capa de una animación personalizada. true la reproduce en la capa de acción, sobre idle o walk, con su Override y su blend weight de Blockbench. false le da la capa base, así que sustituye toda la pose y termina la acción en curso. Consulta Fusión de animaciones.
  • Las solicitudes se ponen en cola y se aplican en orden al comienzo del siguiente tick del modelo. Todas las solicitudes se ejecutan; una posterior no cancela a una anterior que esté en la cola.
  • loop se aplica a las animaciones personalizadas y a damaged. Los nombres integrados ignoran tanto blend como loop: idle y walk siempre están en bucle, mientras que spawn, death y los ataques se reproducen una vez. idle.long reproducido por nombre es una animación personalizada como cualquier otra.
  • Los nombres integrados y de ataque coinciden sin distinguir mayúsculas de minúsculas. Para los demás nombres, FMM busca primero el nombre exacto, después su forma en minúsculas, después la grafía antigua de un nombre renombrado y después la parte general de un nombre con punto (consulta Nombres). hasAnimation encuentra los mismos nombres que reproduce playAnimation. El modelo debe contener el nombre en minúsculas para que un estado integrado funcione.
  • damaged siempre se reproduce en la capa de acción, diga lo que diga blend.
  • playAnimation devuelve false para un nombre que el modelo no tiene y para cualquier solicitud posterior a que se haya solicitado death. true significa que la solicitud se puso en cola, no que se haya reproducido un fotograma: un ataque aún puede ser descartado por una animación personalizada en curso.
  • stopCurrentAnimations() termina todas las animaciones personalizadas y acciones y lleva el modelo de golpe a idle, o a su pose de reposo cuando no tiene idle.
  • La muerte es terminal: una vez solicitada death, las nuevas solicitudes de reproducción devuelven false, las solicitudes en cola se ignoran y stopCurrentAnimations() no hace nada.

Tiempos y duración​

  • Blockbench guarda la duración de la animación en segundos. FMM la convierte con ceil(seconds x 20), así que la duración es siempre un número entero de ticks y las animaciones cortas se redondean hacia arriba en lugar de hacia abajo.
  • Un canal con keyframes solo numéricos se hornea en un array plano de frames por tick durante la importación, y la reproducción lee un frame por tick. En cambio, un canal con un keyframe de MoLang se muestrea en cada tick para cada entidad; consulta Keyframes de MoLang.
  • Cada animación en reproducción lleva su propio contador de ticks, así que la capa base, la capa de acción y una animación que se está desvaneciendo avanzan de forma independiente. Las animaciones en bucle se indexan con counter % duration; las que no están en bucle se fijan en su último frame.
  • Los tiempos de los fotogramas clave conservan su posición de tick fraccionaria (20 x time, sin redondear), por lo que uno situado en 0,37 s contribuye a la interpolación entre ticks. Los fotogramas se muestrean en ticks enteros de 0 a duration - 1; un fotograma clave situado exactamente en el final declarado influye en la interpolación, pero no se muestrea directamente. Sitúa la pose final antes de ese límite si un fotograma visible debe alcanzarla.
  • Si dos keyframes del mismo canal caen exactamente en el mismo tiempo, gana el que aparece después en el orden del archivo.
  • Un keyframe con un tiempo no finito aborta esa pista y produce un único aviso Malformed animation timeline for model ... por animación, mientras que las demás animaciones del modelo se siguen convirtiendo.

Las animaciones de longitud cero son válidas​

Una animación cuya longitud sea 0 (o negativa) se trata como una pose estática intencionada: una decisión de creación habitual en muebles y otros props que necesitan una entrada llamada "sin animación". Se omite en silencio, sin aviso, y no aporta ningún frame.

Modos de bucle​

La configuración de bucle de Blockbench controla la animación exportada a Bedrock:

Modo de bucle de BlockbenchExportación a Bedrock
loop"loop": true
once"loop": false
hold"loop": "hold_on_last_frame"

La reproducción en Java usa la política de bucle del estado integrado o el argumento loop de una animación personalizada. No elige esa política a partir de este campo de Blockbench, por lo que la reproducción en Java y Bedrock puede diferir si sus ajustes no coinciden.

Tipos de interpolación​

Cada keyframe lleva uno de cuatro tipos de interpolación: linear, catmullrom (Smooth en Blockbench), bezier y step. Cualquier cosa fuera de ese conjunto no se puede analizar y se reporta como una timeline malformada.

FMM reproduce el segmento entre dos keyframes como lo previsualiza Blockbench, a partir de los tipos de ambos keyframes, comprobados en este orden:

  1. Un keyframe step mantiene su valor hasta el siguiente keyframe.
  2. Un keyframe linear seguido de uno linear o step se interpola en línea recta.
  3. Cuando cualquiera de los dos keyframes es catmullrom, el segmento sigue una curva de Catmull-Rom que pasa por el keyframe anterior al segmento, los dos keyframes del segmento y el keyframe posterior, de modo que el movimiento fluye por cada keyframe en lugar de detenerse en él. Un vecino que falta repite el extremo del propio segmento. En una animación cuyo modo de bucle de Blockbench es loop, con al menos tres keyframes en el canal, la curva continúa a través del bucle, tratando el último keyframe como si fuera de nuevo el primero.
  4. En caso contrario, uno de ellos es bezier, y el segmento sigue el manejador derecho del keyframe de salida y el manejador izquierdo del keyframe de llegada, en tiempo y valor. Un keyframe guardado sin manejadores los tiene a 0,1 segundos a cada lado sin desplazamiento de valor. El tiempo de un manejador se mantiene dentro del segmento.

Antes de su primer keyframe, un canal mantiene el valor de ese keyframe, y después de su último keyframe mantiene el del último.

Un keyframe con valores pre y post separados se alcanza con su valor pre y se abandona desde su valor post. En un segmento suave, un keyframe así también termina la curva por su lado. Un valor post que FMM no puede leer se ignora.

Estas reglas se aplican a los canales precalculados, a los canales de MoLang en Java y a las pistas precalculadas de la exportación a Bedrock. Necesitan FreeMinecraftModels 2.15.0 o posterior. De la 2.3.0 a la 2.14.2, FreeMinecraftModels interpolaba cada segmento solo según el tipo del keyframe de llegada: catmullrom se frenaba suavemente hasta detenerse en cada keyframe, bezier usaba puntos de control fijos de 0.42 y 0.58 dijeran lo que dijeran sus manejadores, lo que se reproducía casi recto, y un keyframe step saltaba a su valor a mitad del segmento que llevaba a él. Los valores pre y post separados se colapsaban en el valor pre. Por eso los modelos con keyframes suaves, step o Bezier se mueven de forma distinta tras la actualización, más cerca de lo que vio su autor en Blockbench.

Canales animados​

Se hornean tres canales por hueso: rotación, posición y escala. Notas que importan al crear modelos:

  • Los valores de posición se dividen entre 16 (píxeles de Blockbench a bloques).
  • Los valores de rotación se convierten a radianes.
  • La format_version 5 de Blockbench y posteriores invierten el signo de la rotación X e Y y de la posición X. FMM lo compensa automáticamente según la versión de formato declarada, así que no lo corrijas a mano, pero tampoco mezcles una declaración v5 con datos con forma de v4.
  • Un hueso sin keyframes en un canal conserva su valor de reposo para ese canal. Un hueso que la animación de la capa base no anima en absoluto se restablece a rotación 0,0,0, traslación 0,0,0, escala 1,1,1; un hueso que la acción no anima conserva la pose base.
  • Los puntos de datos de los keyframes pueden estar escritos como cadenas de texto en el .bbmodel. Una cadena que es un número se lee como ese número, y una cadena vacía se convierte en 1 para la escala y en 0 en los demás casos. Cualquier otra cadena es una expresión de MoLang; consulta Keyframes de MoLang.
  • Un keyframe con dos puntos de datos, los valores pre y post separados de Blockbench, se alcanza con el primero y se abandona desde el segundo. Consulta Tipos de interpolación.

Keyframes de MoLang​

Un valor de keyframe escrito como expresión de MoLang, como math.sin(query.anim_time * 360) * 10, se evalúa para cada entidad mientras se reproduce la animación.

  • Un canal, es decir, la rotación, la posición o la escala de un hueso o la posición de un controlador de IK, que tenga al menos un keyframe de MoLang no se hornea. Cada entidad lo muestrea en cada tick, con la misma interpolación y la misma conversión de unidades que los canales horneados. Los keyframes numéricos de ese canal conservan sus valores.
  • Estas consultas están disponibles, también con el prefijo corto q.:
ConsultaValor
query.anim_timeSegundos transcurridos de esta animación. Una animación en bucle vuelve a empezar desde 0 en cada vuelta
query.life_timeSegundos desde que se creó el modelo
query.modified_distance_movedBloques que la entidad ha recorrido horizontalmente
query.is_moving1 mientras la entidad se mueve horizontalmente, 0 en caso contrario
  • Las demás consultas y las variables desconocidas se leen como 0. Una variable v. conserva su valor en esa entidad entre evaluaciones, y un valor temp. (t.) dura una sola expresión.
  • Las expresiones usan los mismos operadores y funciones matemáticas que el MoLang de partículas.
  • Un programa de varias sentencias sin return toma el valor de su última línea, como lo previsualiza Blockbench. v.a = 10; v.b = v.a * 3; v.b + 5 se reproduce como 35. Una última línea que sea una asignación vale 0. El MoLang de partículas mantiene la regla de Bedrock, donde un programa sin return vale 0.
  • Una expresión que FMM no puede analizar registra Failed to parse the keyframe expression '<expression>' in animation <animation> for model <model>: <reason>. That value plays as 0. una vez al cargar.
  • Un resultado que no sea un número finito se reproduce como 0.
  • Un segmento suave también evalúa los keyframes a ambos lados para dar forma a su curva. Esas evaluaciones no conservan ninguna de las variables que asignan, así que las asignaciones de un keyframe solo surten efecto en los ticks de los segmentos que ese keyframe inicia o termina.

Los jugadores de Bedrock evalúan estos canales en su propio cliente: la exportación a Bedrock escribe los keyframes del canal tal como se crearon, consulta Exportación a Bedrock.

Qué no se anima​

  • El hueso hitbox. Las pistas de animación que lo tengan como objetivo se omiten directamente.
  • Los fotogramas clave de sonido y de instrucciones de timeline de las pistas de efectos de Blockbench. FMM solo importa los fotogramas clave de partículas de una pista de efectos; consulta Partículas. Reproduce los sonidos desde un script de Lua o desde tu propio plugin.
  • Los huesos que no se pudieron resolver por nombre. Una pista que apunte a un hueso inexistente registra Failed to get bone <name> from model <model>! y se omite.

Cinemática inversa (IK)​

Los null objects de Blockbench actúan como controladores de IK. FMM resuelve las cadenas en runtime con FABRIK (Forward And Backward Reaching Inverse Kinematics), limitado a 10 iteraciones con una tolerancia de 0.001.

Cómo encaja todo:

  1. Un null object con ik_source (hueso raíz) e ik_target (hueso final o locator) define una cadena. La detección comprueba la jerarquía y también admite búsquedas entre hermanos y hacia abajo; los objetivos hermanos en el nivel raíz producen una cadena formada solo por el hueso de origen.
  2. Solo los fotogramas clave de posición del null object controlan la IK. Se convierten en un desplazamiento por fotograma que se suma a la posición de reposo del hueso o locator objetivo. El solucionador no usa la posición de reposo almacenada del controlador como base del objetivo. La rotación y la escala no controlan la IK.
  3. En cada tick, cada cadena sigue a la animación en reproducción de mayor prioridad que la controla: primero la acción, después la animación base y luego una animación que se está desvaneciendo. Se aplica el desplazamiento del objetivo de esa animación y se resuelve la cadena. Una cadena que ninguna animación en reproducción controla se limpia, así que una pose de IK no pasa a una animación que no la usa.
  4. lock_ik_target_rotation se lee y almacena, pero el solucionador actual no lo aplica.

Las cadenas que no se pueden resolver se omiten con un aviso de consola que las nombra; consulta las Notas de Creación de Modelos para ver los mensajes exactos y las restricciones de creación.

Exportación a Bedrock​

Cada modelo convertido escribe además un archivo de animación de Bedrock en animations/<model_id>.animation.json dentro del bundle generado:

  • Los identificadores de animación son animation.fmm.<model_id>.a_<hex>, donde <hex> son los bytes UTF-8 del nombre de la animación escritos en hexadecimal. Por eso, dos nombres que solo difieren en caracteres que Bedrock no admite reciben identificadores distintos.
  • animation_length es la duración en segundos, con un mínimo de 0.05 para que una animación de un solo tick siga siendo válida.
  • El modo de bucle se mapea como se muestra en la tabla de Modos de Bucle.
  • Un modelo sin animaciones sigue recibiendo una única entrada idle sin efecto para que la definición de entidad de Bedrock siga siendo válida.
  • La geometría excluye hitbox, los huesos de etiqueta generados fmm_nametag_bone_* y los puntos de montaje m_; conserva los anclajes tag_ creados por el autor. El exportador de animaciones escribe las pistas precalculadas sin aplicar ese mismo filtro de huesos visuales, así que no animes huesos de montaje excluidos esperando ver su geometría.
  • La exportación de animaciones Bedrock usa fotogramas precalculados de rotación, posición y escala de huesos. No incorpora a esas pistas las rotaciones del solucionador IK durante la ejecución; verifica por separado en Bedrock los modelos que dependan de IK.
  • Un canal de hueso con un keyframe de MoLang se escribe, en cambio, tal como se creó, expresiones y números por igual, y los clientes de Bedrock lo evalúan. Un programa de varias sentencias se escribe con return antes de su última línea, de modo que Bedrock reproduce el mismo valor que Java. Desde la 2.14.2, también recibe el ; final que exige Bedrock. Sus keyframes se mezclan linealmente en Bedrock, sea cual sea la interpolación con la que se crearon, y solo se escriben sus valores pre. En un modelo con format_version 5 o posterior, la rotación X e Y y la posición X salen con el signo invertido, un número como su negativo y un programa con lo que devuelve invertido, así que Bedrock reproduce la misma pose que Java.
  • Un modelo exportado cuelga de un hueso freeminecraftmodels_lean con el pivote en el centro de sus cubos. Muestra a los jugadores de Bedrock la inclinación de la orientación de desplazamiento y el centrado mediante cuatro propiedades enteras de entidad, freeminecraftmodels:lean_x, lean_y, lean_z y body_offset. Un modelo con más de 672 animaciones, contando las generadas que ocultan un hueso saddle o fish, no tiene espacio para esas propiedades, no recibe hueso de inclinación y se queda derecho sobre sus pies en Bedrock.
  • Se genera un controlador de animación por animación, conmutado por una propiedad de entidad, que es la forma en que FMM reproduce una animación concreta en un cliente de Bedrock. FMM conmuta según la animación base y la acción a la vez, igual que las capas de Java.
  • Un modelo con un hueso llamado saddle, en cualquier combinación de mayúsculas y minúsculas, recibe una animación más, freeminecraftmodels_hide_saddle, después de las suyas, y uno con un hueso llamado fish recibe freeminecraftmodels_hide_fish a continuación. Cada una encoge su hueso y los huesos que cuelgan de él hasta hacerlos desaparecer, y solo se reproduce mientras el servidor oculta el hueso: la silla de una mascota montable hasta que se la ensilla, y el pez de una mascota pescadora hasta que lleva una captura a casa. Esto necesita FreeMinecraftModels 2.15.0 o posterior.
  • Una animación con Override activado se escribe con "override_previous_animation": true, y un blend weight distinto de 1 como "blend_weight". Las animaciones base idle, walk, spawn y death van primero en la lista animate de la entidad, de modo que las acciones se superponen a ellas.
  • El blend_transition de los controladores lleva los tiempos de fundido de Java: idle y walk se funden de entrada y de salida durante idleWalkBlendTicks, death se funde de entrada durante deathBlendTicks, y todas las demás animaciones cambian al instante, idle.long y las animaciones de montura y de nado incluidas. Los tiempos se escriben al generar el paquete, así que un cambio de configuración llega a los jugadores de Bedrock cuando el paquete se regenera.
  • Los fotogramas clave de partículas se convierten en la timeline particle_effects de la animación, así que los clientes de Bedrock los reproducen de forma nativa. Consulta Partículas.
Disponibilidad según la versión

Esto necesita FreeMinecraftModels 2.16.0:

  • Un modelo no tiene hueso de inclinación por encima de 532 animaciones en lugar de 672, contando igualmente las animaciones de ocultación generadas.
  • La rotación X e Y y la posición X con keyframes se reproducen en Bedrock igual que en Java. De la 2.8.0 a la 2.15.0, las pistas precalculadas de todos los modelos, y los canales de MoLang de un modelo con format_version 5 o posterior, salían con esos ejes en espejo. El movimiento que oscila por igual alrededor de cero se veía igual, pero una pose mantenida hacia un lado se doblaba hacia el otro en Bedrock, como un codo doblado hacia atrás. Los jugadores de Bedrock ven la corrección cuando el paquete se regenera y su cliente adopta el paquete nuevo.

Consulta Salida del Resource Pack para saber dónde acaba el bundle en el disco.

Inercia de giro​

Con weightedTurning activado (el valor por defecto), un modelo sobre un mob gira hacia la orientación del mob con inercia en lugar de saltar a ella. En cada tick su velocidad de giro cambia como máximo en la aceleración, hasta el límite de velocidad, y frena con la antelación suficiente para detenerse exactamente en la nueva orientación. El propio mob gira y camina igual que antes. Los huesos, la caja de colisión, los locators y la presentación en Bedrock del modelo usan la orientación del modelo.

Ambos límites dependen del tamaño del modelo:

  • El tamaño es la raíz cúbica del volumen del hueso hitbox (ancho x fondo x alto, en bloques), multiplicada por el atributo scale del mob. Un modelo sin hueso hitbox usa en su lugar la raíz cúbica de la caja delimitadora del propio mob. Los tamaños inferiores a 0.25 cuentan como 0.25
  • La velocidad máxima es turnSpeedCap dividido entre la raíz cuadrada del tamaño, y nunca más de 90 grados por tick
  • La aceleración es turnAcceleration dividida entre el tamaño

Con los valores por defecto turnSpeedCap: 30 y turnAcceleration: 6:

HitboxTamañoVelocidad máxima (grados por tick)Aceleración (grados por tick, en cada tick)
0.5 x 0.5 x 0.50.542.412
1 x 1 x 11306
2 x 2 x 2221.23
4 x 4 x 44151.5

Otras reglas:

  • Un modelo gira al instante mientras un jugador monta directamente su mob o se sienta en uno de sus asientos m_, para que la vista del jinete y el modelo se mantengan juntos.
  • Un modelo sobre un caballo con silla que un jugador dirige, como uno de /fmm mount, mira hacia donde mira el jinete, y su cabeza se mantiene nivelada en lugar de seguir la mirada del jinete hacia arriba y hacia abajo.
  • Los huesos de cabeza h_ siguen la cabeza del mob y pueden adelantarse al cuerpo, que es más lento, hasta 75 grados.
  • Un modelo que está muriendo conserva la orientación que tenía. Un modelo con la sincronización de movimiento desactivada conserva su propia orientación.
  • Las entidades estáticas, los props y los disfraces de jugador no usan inercia de giro.

Orientación de desplazamiento​

Un modelo dinámico puede inclinarse con su desplazamiento además de mirar hacia su rumbo. Los caminantes se mantienen nivelados, pero las criaturas voladoras y nadadoras normalmente no deberían. Las mascotas lo definen desde la sección orientation de su archivo de mascota. Los plugins llaman a DynamicEntity#setTravelOrientation(TravelOrientation). Los modelos son UPRIGHT por defecto.

EstiloInclinación
UPRIGHTNinguna. El modelo solo mira hacia donde va
TOP_FIRSTSu parte superior va delante, como una medusa: se inclina hacia su desplazamiento, se tumba de lado al avanzar y se pone boca abajo para descender
FRONT_FIRSTSu parte delantera va delante, como un ave o un pez: cabecea al subir y bajar y se ladea en los giros, hasta 45 grados de alabeo
AjustePor defectoSignificado
startSpeed0.6Bloques por segundo por debajo de los cuales el modelo se mantiene derecho, para que la deriva y el balanceo en reposo no lo inclinen
fullSpeed4.0Bloques por segundo a los que se alinea por completo con su desplazamiento. Entre ambos valores se inclina parcialmente
maxTilt180Inclinación máxima, en grados, de 0 a 180
turnSpeed180Grados por segundo a los que puede cambiar su inclinación
  • La inclinación gira todo el modelo alrededor del centro de sus cubos, después de su orientación y de sus animaciones, así que todos los huesos, locators y puntos de montaje la siguen.
  • La velocidad procede del movimiento de la entidad, suavizado durante unos pocos ticks. Un movimiento de más de 2,5 bloques en un tick cuenta como un teletransporte y no inclina el modelo.
  • Un modelo puede inclinarse de otra manera mientras su criatura nada, es decir, está en el agua y sin tocar el suelo. Las mascotas lo establecen con swimming.orientation (consulta Nado), y los plugins con DynamicEntity#setSwimOrientation(TravelOrientation), donde null inclina como en tierra. Mientras nada, la inclinación sigue de inmediato la propia velocidad de la criatura, frenada solo por turnSpeed, en lugar de la velocidad suavizada, así que el morro de un nadador apunta hacia arriba mientras asciende y hacia abajo mientras desciende. Esto necesita FreeMinecraftModels 2.15.0 o posterior.
  • El modelo vuelve suavemente a la vertical cuando se detiene, mientras muere, mientras un jugador lo monta y mientras su sincronización de movimiento está desactivada.
  • Los jugadores de Bedrock ven la inclinación mediante el hueso de inclinación exportado (consulta Exportación a Bedrock). Se actualiza a saltos, al ritmo de ticks del servidor, sin suavizado en el cliente. Después de que el paquete se regenere por primera vez con el hueso de inclinación, reinicia el servidor una vez para que el puente de Bedrock registre las nuevas propiedades de entidad.

Centrado en el cuerpo​

ModeledEntity#setCenteredOnBody(true) dibuja un modelo con el centro de sus cubos sobre el centro de su entidad, en lugar de apoyarlo en los pies de la entidad. Una criatura voladora o nadadora cuyo modelo es mucho mayor que su cuerpo oculto se mueve, gira y se inclina entonces alrededor de ese cuerpo. La placa de nombre de reserva, la caja de clic y la caja de impacto se mueven con el modelo. Los huesos hitbox y de etiqueta de nombre no cuentan para el centro.

Está desactivado por defecto. Las mascotas lo activan para las especies FLYING y AQUATIC, y su clave centerOnBody lo sobrescribe. Los jugadores de Bedrock también ven el modelo centrado, mediante el mismo hueso de inclinación. La propia caja de colisión de la entidad de Bedrock sigue empezando en sus pies.

Reproducir animaciones desde otros sistemas​

Quien llamaPunto de entrada
Plugin (Java)ModeledEntity#playAnimation(String, boolean blend, boolean loop) / #stopCurrentAnimations() / #hasAnimation(String)
Script de Lua de un propcontext.prop:play_animation(name, blend, loop) / context.prop:stop_animation()
Cualquier tabla de entidad de Luaentity.model:play_animation(name, blend, loop) / entity.model:stop_animations() (disponible cuando entity.is_modeled es true)

Consulta la Guía de API y desarrollo y Lua: API de elementos decorativos para conocer las interfaces relacionadas.

Los valores predeterminados de Lua son distintos: context.prop:play_animation(name) usa blend=true, loop=true, mientras que entity.model:play_animation(name) usa false, false. Pasa ambos booleanos explícitamente cuando esa diferencia sea relevante.

Solución de problemas​

Mi animación nunca se reproduce automáticamente. La máquina de estados compartida reconoce spawn, idle, idle.long, walk, swim, idle.swim, ride, idle.ride, attack y death en minúsculas, y trata todo nombre attack. y damaged como acciones. El movimiento controla las transiciones idle/walk, el nado y un jinete que dirige activan las animaciones de nado y de montura, e idle.long espera a un rato tranquilo de reposo; los ataques y la muerte siguen necesitando su activación durante la ejecución. Consulta Animaciones de estado. Los demás nombres requieren una llamada explícita a playAnimation / play_animation, salvo los nombres adicionales que selecciona el controlador de disfraces.

Mi modelo no hace absolutamente nada. Lo más probable es que no tenga ni una animación spawn ni una idle, así que muestra su pose de reposo hasta que camina o algo reproduce una animación. Añade un idle.

Mi ataque se ve mal mientras el modelo camina. Con Override desactivado, el ataque se suma a la pose de caminar de cada hueso que anima. Activa Override en las propiedades del ataque en Blockbench para que esos huesos tomen la pose del ataque, o anima menos huesos. Consulta Override y peso de mezcla.

Mi modelo cambia entre idle y walk demasiado despacio o demasiado de golpe. Cambia idleWalkBlendTicks. 0 cambia al instante.

Mi idle.long se reproduce demasiado a menudo, demasiado poco o nunca. Cambia longIdleMinSeconds y longIdleMaxSeconds. La espera solo cuenta mientras el modelo muestra idle simple: moverse, los ataques, las animaciones personalizadas y los jinetes la reinician. longIdleMaxSeconds: 0 desactiva idle.long.

Mi animación suave, step o Bezier se mueve de forma distinta tras una actualización. FreeMinecraftModels 2.15.0 y posteriores reproducen estos keyframes como los previsualiza Blockbench; consulta Tipos de interpolación. Comprueba la animación en la previsualización de Blockbench: ese es el movimiento que FMM reproduce ahora.

Mi modelo grande gira demasiado despacio. La velocidad de giro baja con el tamaño; consulta Inercia de giro. Sube turnSpeedCap y turnAcceleration, comprueba que el hueso hitbox no sea mayor de lo previsto, o establece weightedTurning: false.

La consola dice ... FreeMinecraftModels does not support these ... o ... has the blend weight .... FMM reproduce esa animación sin Start Delay, Loop Delay ni Anim Time Update de Blockbench, y lee Blend Weight solo como un número simple. Vacía esos campos o sustituye la expresión Molang por un número.

Mi animación se reproduce pero nada se mueve. Revisa la duración de la animación. Una animación de longitud cero se trata como una pose estática y se omite en silencio por diseño.

En Bedrock, todas las animaciones de un modelo se detienen, incluida la de reposo, mientras que Java las reproduce. Bedrock rechaza un programa de MoLang con un ; o una asignación a menos que termine en ;, y un solo keyframe rechazado detiene todas las animaciones de la entidad. FreeMinecraftModels 2.13.0 a 2.14.1 escriben esos programas sin el ; final, y la 2.14.2 lo añade. Actualiza o, en esas versiones, termina tú mismo el programa del keyframe con ; en Blockbench. Java lo reproduce igual.

Un keyframe de MoLang se queda quieto en 0. Revisa la consola en busca de Failed to parse the keyframe expression. Un programa cuya última línea es una asignación vale 0; termínalo con el valor que quieras, o con return. Las consultas distintas de las cuatro indicadas en Keyframes de MoLang se leen como 0.

Las rotaciones salen invertidas. Revisa meta.format_version en el .bbmodel. FMM invierte el signo de la rotación X/Y para la versión de formato 5 y posteriores; un archivo que declare una versión pero contenga los datos de la otra saldrá invertido.

La consola dice Malformed animation timeline for model .... Una pista de esa animación no se pudo leer o interpolar. El aviso se dispara una vez por animación y nombra el hueso o el controlador de IK implicado; las demás animaciones del modelo se siguen convirtiendo.

Los sonidos de mi timeline de Blockbench no hacen nada. Los fotogramas clave de sonido no se importan. Activa los sonidos desde un script de Lua o desde tu propio plugin. Los fotogramas clave de partículas sí se importan; si no se ven, consulta Partículas.