Minecraft Wiki

A Minecraft Wiki não é mais considerado oficial da Microsoft e, portanto, várias alterações são obrigadas a serem feitas, inclusive para o logotipo da Wiki. Por favor leia este anúncio para maiores informações.

Acompanhe o Minecraft Live 2021 ao vivo em 16 de outubro às 13:00 no Twitter da Minecraft Wiki.

LEIA MAIS

Minecraft Wiki
Advertisement
Minecraft Wiki
4 313
páginas
Information icon.svg
Esta é uma página oficial documentada pela equipe da Mojang e mantida pela comunidade. 
Embora esta página seja uma documentação oficial, ela pode ser editada por qualquer pessoa.
Information icon.svg
Esse recurso é exclusivo para Edição Bedrock. 

Documentação

Ultima atualização feita: Edição Bedrock 1.16.210


Controles de animação

{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.sheep.move": {
      "states": {
        "default": {
          "animations": [
            { "walk": "query.modified_move_speed" }
          ],
          "transitions": [
            { "grazing": "query.is_grazing" }
          ]
        },
        "grazing": {
          "animations": [ "grazing" ],
          "transitions": [
            { "default": "query.all_animations_finished" }
          ]
        }
      }
    }
  }
}


Estados

Cada estado tem uma seção de variáveis opcionais, listando qualquer número de variáveis que as animações referenciadas podem usar. Cada estado também possui uma ou mais animações, usando o nome dado na definição da entidade json.

Variáveis de Estado

As variáveis têm seu valor definido por uma Expressão de MoLang. Eles também podem ter seus valores remapeados por meio de uma curva-interpolada linearmente.

Por exemplo

O controlador de animação para esse quadro. Ele pegará o valor de query.ground_speed e, em seguida, remapeá-lo-á entre 0.2 e 0.7 com base no valor de query.ground_speed indo de 0.0 para 1.0. Ele reproduzirá uma caminhada de animação que se misturará de 0.0 à 1.0 conforme a velocidade do solo aumenta de parado para 2,3 m/s. A curva de remapeamento pode ter qualquer número de entradas. O controlador de animação irá então reproduzir as animações wiggle_nose referenciadas pela entidade, seguidas pela animação caminhada, escalando a última pelo valor de variable.ground_speed_curve.

{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.sheep.move": {
      "states": {
        "default": {
          "variables": {
            "ground_speed_curve": {
              "input": "query.ground_speed",
              "remap_curve": {
                "0.0": 0.2,
                "1.0": 0.7
              }
            }
          },
          "animations": [
            "wiggle_nose",
            { "walk": "variable.ground_speed_curve" }
          ]
        }
      }
    }
  }
}


Exemplo de script definido pelo usuário

NOTA: pre_animation diz ao script para descobrir os valores dessas variáveis uma vez por quadro, antes que a animação ocorra, para que a animação possa usar esses valores em suas próprias fórmulas. Se uma variável não existia, ele irá criar uma nova variável e seu valor padrão será 0.0.
Em definitions\entity\tiger.json
{
  "custom:tiger":{
    "scripts":{
      "pre_animation": {
        "variable.foo = math.sin(query.life_time)"
      }
    }
  }
}

De 0 para -1 para 0 onde apenas Base_pose será reproduzido e, em seguida, uma quantidade igual de tempo em que Walk jogará em cima de base_pose conforme foo vai de 0 para 1 de volta para 0. Base_pose terá um valor de misturado de 1.0.

"controller.animation.tiger.move": {
  "states": {
    "default": {
      "animations": [
        // animações são ADITIVAS, a menos que seja especificado de outra forma
         // neste caso, base_pose sempre estará jogando no estado padrão
         // walk também será reproduzido se Entity.foo for maior que '0,0'
        "base_pose",
        { "walk": "variable.foo > 0.0" }
      ]
    }
  }
}

Transições de estado

Cada transição tem um estado de destino para o qual alternar e um script para alternar ou não. Para cada transição em ordem, avalie o script e, se ele retornar diferente de zero, mude para o estado especificado imediatamente.

NOTA: Apenas uma transição será processada por quadro.
"<nome_do_controle>": {
  "states": {
    "<nome_do_estado>": {
      "transitions": [
        // Avalie as expressões abaixo em ordem.
        // O primeiro a retornar diferente de zero é o estado para o qual fazer a transição.
        // Se todos forem zero, não faça a transição.
        { "<trageto_de_estado_A>", "<expressão>" },
        { "<trageto_de_estado_B>", "<expressão>" },
      ]
    }
  }
}

Por exemplo:

"controller.animation.tiger.move": {
  "states": {
    "default": {
      "animations": [ "base_pose", "walk" ],
      "transitions": [
        { "angry": "query.is_angry" }, // transição para o estado de raiva (angry) se query.is_angry retorna verdadeiro
        { "tired": "variable.is_tired" } // transição para o estado cansado (tired) se variable.is_tired retorna verdadeiro
      ]
    },
    "angry": {
      "animations": [ "roar", "extend_claws" ],
      "transitions": [
        { "default": "query.any_animation_finished" } // transição de volta ao estado padrão quando a animação de rugido (roar) ou a animação extend_claws terminar
      ]
    },
    "tired": {
      "animations": [ "yawn", "stretch" ],
      "transitions": [
        { "default": "query.all_animation_finished" } // transição de volta ao estado padrão quando as animações de bocejo e alongamento terminarem
      ]
    }
  }
}

Mistura de estado

para o tempo que você gostaria que o sistema levasse para se misturar entre os dois estados. Isso é feito como uma interpolação linear simples entre os dois estados ao longo do tempo especificado.

Por exemplo:

"controller.animation.tiger.move": {
  "states": {
    "default": {
      "animations": [ "base_pose", "walk" ],
      "transitions": [
        { "angry": "query.is_angry" } // transição para o estado de raiva se query.is_angry retornar verdadeiro
      ],
      "blend_transition": 0.2          // ao fazer a transição para longe deste estado, o cross-fade em 0,2 segundos
    },
    "angry": {
      "animations": [ "roar", "extend_claws" ],
      "transitions": [
        { "default": "query.any_animation_finished" } // transição de volta ao estado padrão quando a animação de rugido ou a animação extend_claws terminar
      ]
    }
  }
}

Canais (rotação, posição, escala)

A engine rastreia a animação de rotação, posição e escala separadamente. Dentro de um canal, um ou mais chave-de-quadro são especificados em tempos arbitrários, em segundos, desde o início da animação. Se nenhuma chave-de-quadro for especificada, um único quadro-chave será criado em t = 0.0 e todos os dados do canal serão armazenados nessa chave-de-quadro.

Exemplos de Formato de Animação de Entidade

O formato json para uma animação é o seguinte:

NOTA: Combinando o formato da geometria, as unidades estão em 1/16 metros.
"<nome_da_animação>": {
  // optional
  "loop": <bool>                                       // padrão = false. A animação deve retornar a t=0.0 quando terminar?
  "blend_weight": <expressão>                         // padrão = "1.0". O quanto essa animação se mescla com as outras. 0,0 = desligado. 1.0 = aplica totalmente todas as transformações. Pode ser uma expressão - consulte a seção Controlador de aAnimação abaixo
  "animation_length": <float>                          // pafrão = hora da última chave-de-quadros. A que horas o sistema considera esta animação concluída?
  "override_previous_animation": <bool>                // padrão = false. A pose de animação do osso deve ser definida para a pose de vinculação antes de aplicar esta animação, substituindo assim quaisquer animações anteriores até este ponto?

  // required
  "bones": [
    {
    "<nome_do_osso>": {                                   // deve corresponder ao nome do osso especificado no esqueleto da geometria
      // vários sabores de dados de configuração
      // omitir um canal pula aquele canal para esta animação deste osso
      // qualquer número float abaixo pode ser substituído por uma expressão de string conforme descrito acima; você não tem que substituir todos os float em uma linha por expressões, apenas aqueles que você deseja que sejam baseados em expressões
      "position": 1.0,                                 // defina x, y e z como 1
      "position": [1.0],                               // defina x, y e z como 1
      "position": [1.0, 2.0, 3.0],                     // defina x=1 , y=2 , como z=3
      "rotation": 45.0,                                // defina x, y, e z como 45 graus
      "rotation": [45.0],                              // defina x, y, e z como 45 graus
      "rotation": [30.0, 0.0, 45.0],                   // defina x, y, e z para os respectivos valores (em graus)
      // NOTA: apenas escala uniforme é suportada neste momento
      "scale": 2.0,                                    // escala o osso em 2,0
      "scale": [2.0],                                  // escala o osso em 2,0
      // Os dados da chave-de-quadros são descritos abaixo
      // Observe que qualquer um dos estilos de valores acima funcionará para "pre" e "post", e "pre" não precisa ter o mesmo formato de "post"
      "rotation": {
        "0.0": [80.0, 0.0, 0.0],
        "0.1667": [-80.0, 0.0, 0.0],
        "0.333": [80.0, 0.0, 0.0]
      }
      // Para uma descontínua curva de canal, você pode especificar um valor diferente ao interpolar de/para esta chave-de-quadro
      "rotation": {
        "0.3": {                                       // o campo da chave é o carimbo de data/hora para esta chave-de-quadro: o valor pode ser qualquer um dos exemplos acima
        "pre": [30.0, 0.0, 45.0],                      // ao interpolar em direção a esta chave-de-quadro do anterior, use este valor
        "post": "180.0 * Math.Sin(global.key_frame_lerp_time)"  // ao interpolar longe desta chave-de-quadro para o próximo, use este valor
        }
      }
      // outro exemplo
      "rotation": {
        "0.0": [80.0, 0.0, 0.0],                       // começar em uma rotação x de 80 graus
        "0.4": {
        "pre": [80.0, 0.0, 0.0],                       // fique em 80 até que 0,4 segundos tenham decorrido
        "post": [0.0, 0.0, 0.0],                       // pop descontinuamente a rotação x para 0.0 graus
        },
        "0.8": [-80.0, 0.0, 0.0]                       // usando o modo interpolação linear do quadro anterior, interpolação linear para uma rotação x de -80 graus por 0,8 segundos
      }
    }
  ]
}

Começando

Atualização da v1.7 Beta para v1.8

Para atualizar os scripts anteriores, você deseja realizar as seguintes etapas para todos os seus scripts MoLang na ordem listada:

  1. entity.flags.foo --> query.foo
  2. entity.member.foo --> query.foo
  3. entity.foo --> variable.foo
  4. params.foo --> global.foo
  5. A regra geral é que query representa valores somente leitura da entidade em que o script está sendo executado, e variable representa dados de leitura e gravação criados pelo usuário.
  6. Adotamos snake_case para todos os nomes de coisas. Você pode usar letras maiúsculas se desejar, pois não diferenciamos maiúsculas de minúsculas, no entanto, recomendamos snake_case em geral.
  7. Várias variáveis previamente definidas em mobs foram alteradas para usar o formato query.foo. Examine a lista atualizada abaixo para ver o que foi adicionado e alterado.

Atualização da v1.8 Beta para v1.10

  • A capacidade de fazer referências a outras animações em uma hierarquia arbitrariamente profunda.
  • A seção de parâmetros dos controladores de animação foi substituída pela seção variables.
  • No arquivo de definição de entidade, os controladores de animação agora estão listados na seção animations, e uma seção scripts/animate foi adicionada para definir quais animações raiz reproduzir.

O formato de arquivo v1.8 é compatível com versões anteriores de v1.10, então você não precisa mudar nada (embora recomendamos refatorar seus arquivos no espírito da v1.10), pois há uma ligeira vitória de desempenho com o novo formato, como além de ser mais simples de entender.

Adicionando Animações

Definição de Enditades

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "minecraft:pig",
      "min_engine_version": "1.8.0",
      "materials": { "default": "pig" },
      "textures": {
        "default": "textures/entity/pig/pig",
        "saddled": "textures/entity/pig/pig_saddle"
      },
      "geometry": {
        "default": "geometry.pig.v1.8"
      },
      "animations": {
        "setup": "animation.pig.setup",
        "walk": "animation.quadruped.walk",
        "look_at_target": "animation.common.look_at_target",
        "baby_transform": "animation.pig.baby_transform"
      },
      "scripts": {
        "animate": [
          "setup",
          { "walk": "query.modified_move_speed" },
          "look_at_target",
          { "baby_transform": "query.is_baby" }
        ]
      },
      "render_controllers": [ "controller.render.pig" ],
      "spawn_egg": {
        "texture": "spawn_egg",
        "texture_index": 2
      }
    }
  }
}


Isso significa que você também não verá a animação de movimento no arquivo de animação pig.json. Se você gostaria de fazer uma caminhada de porco personalizada, você pode alterar esta linha para apontar para sua animação personalizada.
As animações são especificadas como um nome curto, seguido pelo nome completo do recurso. O nome curto é usado em controladores de animação e na lista scripts/animate, enquanto o nome longo é usado no arquivo de animações.
Na seção scripts/animate, você lista as animações a serem reproduzidas e em que ordem. Você pode especificar uma animação diretamente ou especificar uma expressão de mesclagem.

Controlador de Animação

Embora muito disso possa ser gerenciado na seção scripts/animate de definição de entidade, os controladores de animação fornecem a funcionalidade de uma máquina de estado em estados e os controlam como um bloco. As animações em um estado de controlador de animação podem ser elas próprias controladores de animação, permitindo hierarquias de animação arbitrariamente complexas.

Este é um exemplo de controlador de animação:

{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.my_mob.move": {
      "initial_state": "moving",
      "states": {
        "moving": {
          "animations": [
            "wag_tail",
            "wiggle_ears",
            { "walk": "query.modified_move_speed" }
          ],
          "transitions": [
            { "grazing": "query.is_grazing" }
          ]
        },
        "grazing": {
          "animations": [ "grazing" ],
          "transitions": [
            { "moving": "query.all_animations_finished" }
          ]
        }
      }
    }
  }
}

Animações

Observe que os canais (x, y e z) são adicionados separadamente nas animações primeiro e, em seguida, convertidos em uma transformação depois que todas as animações foram aplicadas cumulativamente.

Os dados de animação podem ser dados brutos (raw data)

Por padrão, as rotações são em graus, no formato euler X-then-Y-then-Z.

Ou um script interpretado em tempo de execução
"rotation": ["cos(query.anim_pos * 38.17) * 80.0 * query.anim_speed", 0.0, 0.0]


Aqui está um exemplo de quadruped.animation.json na pasta de animação do vanilla resource pack:

{
  "format_version": "1.8.0",
  "animations": {
    "animation.quadruped.walk": {
      "anim_time_update": "query.modified_distance_moved",
      "loop": true,
      "bones": {
        "leg0": { "rotation": [ "Math.cos(query.anim_time * 38.17) *  80.0", 0.0, 0.0 ] },
        "leg1": { "rotation": [ "Math.cos(query.anim_time * 38.17) * -80.0", 0.0, 0.0 ] },
        "leg2": { "rotation": [ "Math.cos(query.anim_time * 38.17) * -80.0", 0.0, 0.0 ] },
        "leg3": { "rotation": [ "Math.cos(query.anim_time * 38.17) *  80.0", 0.0, 0.0 ] }
      }
    }
  }
}

Hierarquia da Animação

Chave-de-Quadros

Um quadro-chave define dois valores para uma transformação específica de canal em um osso específico em um momento especificado, um quando o tempo se aproxima do tempo do chave-de-quadro e o segundo a partir desse tempo de chave-de-quadro.
Assim, ao interpolar entre dois chaves-de-quadros, pode-se definir a inclinação da curva da animação de maneira contínua ou descontínua.

Interpolação

Exemplo Contínuo
"head": {
  "rotation": {
    "0.0":[0, 0, 0],
    "0.5": [ 0, 180, 0],
    "1.0": [0, 360, 0]
  }
}


Exemplo Descontínuo

Este exemplo dimensiona a "cabeça" do osso:

  1. De 0 à 0,5 segundos, o osso da cabeça é ajustado para sua escala normal de 1 em todas as dimensões [X, Y, Z];
  2. Em 0.5 segundos, o osso irá instantaneamente aumentar até 2 vezes seu tamanho normal;
  3. De 0.5 à 1 segundo ("post"), o osso será redimensionado de volta ao seu tamanho normal de escala de 1 em todas as dimensões.
NOTA: No exemplo maior acima do formato de arquivo, "pre" e "post" também podem ser definidos por uma expressão MoLang que calcula esse valor em tempo de execução, permitindo que você tenha uma curva definida matematicamente em vez de ser puramente linear.
"head": {
  "scale": {
    "0.5": {
      "pre": [1, 1, 1],
      "post": 2.0
    }
    "1.0": [ 1.0 ]
  }
}

Nomes

Todos os nomes: animations, bones, states e etc, devem todos começar com uma letra e conter apenas alfanuméricos, sublinhado ou ponto. Recomenda-se usar nomes em letras minúsculas.

Visão Global

A seguir estão os paradigmas JSON atuais do Minecraft:

  • Os campos devem ser minúsculos e usar sublinhados (sem espaços).
  • Todos os arquivos JSON no diretório de definições e subárvore serão lidos e interpretados pelo sistema de animação.

Controles de Renderização

O Render Controller precisa de um identificador e precisa seguir o formato de controller.render.<name>. Esse nome precisa corresponder ao nome definido no JSON de Definições do Cliente de Entidade.

Os Render Controllers são uma forma de o jogador determinar o que é renderizado na entidade. Os jogadores podem definir a geometria, materiais, texturas e visibilidade da parte da entidade. Além de definir as chaves diretamente, os jogadores podem usar matrizes para que a entidade escolha entre diferentes opções.

Começando

Para começar a criar uma nova pasta chamada render_controllers na raiz do Resource Pack, você deseja adicionar o novo Render Controller JSON dentro.

Exemplo de controles de renderização JSON para a jaguatirica:

"format_version": "1.8.0",
"render_controllers": {
  "controller.render.ocelot": {
    "arrays": {
      "textures": {
        "Array.skins": ["Texture.wild", "Texture.black", "Texture.red", "Texture.siamese"]
      }
    },
    "geometry": "Geometry.default",
    "materials": [{ "*": "Material.default" }],
    "textures": ["Array.skins[query.variant]"]
  }
}

Exemplos

Exemplo de Array para geometria JSON da Ovelha:

"arrays": {
  "geometries": {
    "Array.geos": ["Geometry.default", "Geometry.sheared"]
  }
},
"geometry": "Array.geos[query.is_sheared]",

Exemplo de Array para os materiais JSON da Aranha:

"arrays": {
  "materials": {
    "Array.materials": ["Material.default", "Material.invisible"]
  }
},
"materials": [{ "*": "Array.materials[query.is_invisible]" }],

Exemplo de Array para a textura JSON do Aldeão:

"arrays": {
  "textures": {
    "Array.skins": ["Texture.farmer", "Texture.librarian", "Texture.priest", "Texture.smith", "Texture.butcher"]
  }
},
"textures": ["Array.skins[query.variant]"]

Exemplo com cor para tingimento de peças do controlador de renderização Armor 1.0 JSON:

"format_version": "1.8.0",
"render_controllers": {
    "controller.render.armor.chest.v1.0": {
        "arrays": {
          "materials": {
            "array.armor_material": [
              "material.armor",
              "material.armor_enchanted",
              "material.armor_leather",
              "material.armor_leather_enchanted"
            ]
          },
          "textures": {
            "array.armor_texture": [
              "texture.leather",
              "texture.chain",
              "texture.iron",
              "texture.diamond",
              "texture.gold"
            ]
          }
        },
        "geometry": "geometry.armor",
        "materials" : [
          { "body": "array.armor_material[query.armor_material_slot(1)]" },
          { "leftarm": "array.armor_material[query.armor_material_slot(1)]" },
          { "rightarm": "array.armor_material[query.armor_material_slot(1)]" }
        ],
        "part_visibility" : [
          { "*": 0 },
          { "body": "query.has_armor_slot(1)" },
          { "leftarm": "query.has_armor_slot(1)" },
          { "rightarm": "query.has_armor_slot(1)" }
        ],
        "color": {
          "r": "query.armor_color_slot(1, 0)",
          "g": "query.armor_color_slot(1, 1)",
          "b": "query.armor_color_slot(1, 2)",
          "a": "query.armor_color_slot(1, 3)"
        },
        "textures": ["array.armor_texture[query.armor_texture_slot(1)]", "texture.enchanted"]
    }
}

Exemplo com is_hurt_color do controlador de renderização Creeper JSON:

"format_version": "1.8.0",
"render_controllers": {
    "controller.render.creeper": {
        "geometry" : "Geometry.default",
        "materials" : [{ "*": "Material.default" }],
        "textures" : "Texture.default",
        "is_hurt_color" : {
          "r": 0.0,
          "g": 0.0,
          "b": 1.0,
          "a": 0.5,
        }
    }
}

Exemplo com on_fire_color do controlador de renderização da Fireball JSON:

"format_version": "1.8.0",
"render_controllers": {
    "controller.render.fireball": {
        "geometry" : "Geometry.default",
        "materials" : [{ "*": "Material.default" }],
        "textures" : "Texture.default",
        "on_fire_color" : {
          "r": 0.0,
          "g": 0.0,
          "b": 0.0,
          "a": 0.0,
        }
    }
}

Exemplo com overlay_color do controlador de renderização Wither Boss JSON:

"format_version": "1.8.0",
"render_controllers": {
    "controller.render.wither_boss": {
        "arrays": {
          "textures": {
            "Array.wither_state": ["Texture.invulnerable", "Texture.default"]
          }
        },
        "geometry" : "Geometry.default",
        "materials" : [{ "*": "Material.default" }],
        "textures" : ["Array.wither_state[variable.display_normal_skin]"],
        "overlay_color" : {
          "r": "variable.is_invulnerable ? 1.0 : this",
          "g": "variable.is_invulnerable ? 1.0 : this",
          "b": "variable.is_invulnerable ? 1.0 : this",
          "a": "variable.is_invulnerable ? query.overlay_alpha : this"
        }
    }
}

Exemplo com part_visibility para ativar e desativar a visibilidade de peças da Llama JSON:

"format_version": "1.8.0",
"render_controllers": {
  "controller.render.llama": {
    "arrays": {
      "textures": {
        "Array.base": ["Texture.creamy", "Texture.white", "Texture.brown", "Texture.gray"],
        "Array.decor": ["Texture.decor_none", "Texture.decor_white", "Texture.decor_orange", "Texture.decor_magenta", "Texture.decor_light_blue", "Texture.decor_yellow", "Texture.decor_lime", "Texture.decor_pink", "Texture.decor_gray", "Texture.decor_silver", "Texture.decor_cyan", "Texture.decor_purple", "Texture.decor_blue", "Texture.decor_brown", "Texture.decor_green", "Texture.decor_red", "Texture.decor_black"]
      }
    },
    "geometry": "Geometry.default", 
    "part_visibility": [{ "chest*": "query.is_chested" }],
    "materials": [{ "*": "Material.default" }],
    "textures": [
      "Array.base[query.variant]",
      "Array.decor[variable.decor_texture_index]",
      "Texture.decor_none"
    ]
  }
}


Exemplo de array dos materiais dos controles de renderização do Cavalo. Saddle irá substituir Mane, que irá substituir TailA, etc.:

"materials": [
  { "*": "Material.default" },
  { "TailA": "Material.horse_hair" },
  { "Mane": "Material.horse_hair" },
  { "*Saddle*": "Material.horse_saddle" }
],


Transforms

  • Ordem das operações: os vértices são transladados, rotacionado e escalados.
  • Os dados de animação são considerados hierárquicos e aplicados a um osso por nome, correspondendo ao nome do osso nos dados de animação ao esqueleto da geometria de destino.
  • Nem todo osso precisa ser animado.
  • Você pode animar ossos que não existem na geometria de destino (ossos ausentes são ignorados).
  • Para cada escala, rotação, posição, pode-se definir os campos individualmente ou uniformemente com um único valor. Por exemplo, eles são equivalentes.
"scale": [2.0, 2.0, 2.0]
"scale": 2.0
"scale": [2.0]

Veja Mais

Páginas Oficiais

Advertisement