Ragdoll na Unity: Ragdoll Wizard e Ativar por Código

Unity ragdoll é a técnica de trocar a animação de um personagem por física no momento certo, normalmente a morte: cada parte do corpo vira um Rigidbody ligado à vizinha por uma junta, e o boneco cai de forma diferente a cada vez, reagindo ao chão, a escadas e à força do golpe. A Unity monta essa estrutura sozinha com o Ragdoll Wizard; o seu trabalho é deixar o ragdoll desligado durante o jogo e ligá-lo por código na hora da morte.

Este post faz o caminho completo num modelo do Mixamo no Unity 6.3 LTS: preparar o modelo, gerar o ragdoll com o Wizard, desligar durante o jogo, ativar por código na morte com a força do tiro aplicada no ponto do impacto, e corrigir os erros de junta que fazem o boneco tremer ou explodir.

Unity ragdoll: o que é

Um personagem animado tem um esqueleto: uma hierarquia de ossos (Transforms) que o Animator move a cada frame conforme a animação. O ragdoll acrescenta a cada osso principal três componentes:

• Rigidbody: o osso passa a ter massa e a sofrer gravidade.
• Collider (cápsula, caixa ou esfera): o osso passa a bater no chão e em outros objetos.
• Character Joint: o osso fica preso ao osso pai com limites de rotação, como uma articulação.

Com o Animator ligado, a animação controla os ossos. Com o Animator desligado e os Rigidbodies livres, a física controla. Ragdoll é a passagem de um para o outro.

O mesmo conceito existe em outras engines. Se você usa Godot, o post de ragdoll no Godot com PhysicalBone3D mostra a versão de lá, com a mesma ideia de ossos físicos ligados por juntas.

Preparar o modelo humanoide

Qualquer modelo com esqueleto humanoide serve. O Mixamo é a fonte mais usada para protótipo porque entrega personagem e animações já com rig.

1. No Mixamo, baixe o personagem em FBX for Unity (.fbx), com T-pose (ou com uma animação de idle, se preferir). O processo de importação de personagem e animações está no post de importar animação do Mixamo na Unity.
2. Arraste o FBX para o Project. Selecione e, no Inspector, aba Rig, use Animation Type: Humanoid e aplique.
3. Aba Model: confira que Generate Colliders está desmarcado (o manual do Ragdoll Wizard recomenda desligar se estiver ativo, para não duplicar colliders).
4. Arraste o modelo para a cena e confira a escala: um humano deve ter cerca de 1,8 unidade de altura. Coloque um cubo de 1 x 1 x 1 ao lado para comparar. Se o boneco estiver gigante ou minúsculo, corrija o Scale Factor na aba Model, não no Transform da cena. Escala errada é uma das causas mais comuns de ragdoll instável.
5. Adicione um Animator com um Controller com uma animação de idle ou corrida, para testar a transição depois.

Ragdoll Wizard passo a passo

Com o personagem na Hierarchy, abra GameObject > 3D Object > Ragdoll.... A janela tem um campo para cada osso. Expanda a hierarquia do personagem até ver os ossos mixamorig: e arraste cada um para o campo correspondente:

Os nomes enganam: no Mixamo, LeftLeg é a canela (vai no Knee) e LeftUpLeg é a coxa (vai no Hips). LeftArm é o braço e LeftForeArm é o antebraço (vai no Elbow).

Abaixo dos ossos:

• Total Mass: massa total do boneco, distribuída entre as partes. Algo entre 60 e 80 para um humano funciona bem e deixa as massas das partes em faixas próximas.
• Strength: deixe 0.
• Flip Forward: marque só se o ragdoll for gerado com os limites de junta virados para trás (joelho dobrando para a frente ao cair).

Clique em Create. O Wizard adiciona Rigidbody, Collider e Character Joint em cada osso. Dê Play: o personagem desaba. Isso confirma que o ragdoll funciona. Agora é preciso desligá-lo.

Salve como prefab depois de ajustar tudo, arrastando o personagem da Hierarchy para o Project.

Desligar o ragdoll durante o jogo

Durante o jogo, o personagem precisa de três coisas: Animator controlando os ossos, um collider principal (cápsula ou Character Controller) para andar, e ragdoll inerte. "Inerte" significa todos os Rigidbodies dos ossos com isKinematic marcado: eles seguem a animação sem sofrer gravidade, e os colliders deles continuam lá.

Deixar os colliders dos ossos ligados tem um bônus: eles viram hitboxes por parte do corpo. Um raycast de tiro acerta o collider da cabeça ou da perna, e você sabe onde foi o tiro.

Para que esses colliders não briguem com o collider principal, crie uma layer Ragdoll para os ossos e desmarque Ragdoll x Jogador e Ragdoll x Inimigo (a layer da cápsula principal) na Layer Collision Matrix, em Edit > Project Settings > Physics.

Um detalhe que pega muita gente: a cápsula principal envolve os ossos, então um raycast que enxerga a layer dela para na cápsula e nunca chega na cabeça. Na LayerMask do tiro, marque Ragdoll e desmarque a layer da cápsula do inimigo.

Um ragdoll que funciona numa cena de teste é a parte fácil. No jogo, a morte tem que conversar com o sistema de dano, com o Animator, com a câmera, com o respawn e com os inimigos ao redor, e é aí que um projeto solo costuma descobrir que cada sistema foi feito sem pensar no outro. O curso de Unity monta personagem, dano, animação e física juntos num jogo completo, e a morte com ragdoll entra como consequência natural dessa estrutura.

Ativar o ragdoll por código na morte

Arquivo ControleRagdoll.cs, no objeto raiz do personagem:

using System.Collections.Generic;
using UnityEngine;

public class ControleRagdoll : MonoBehaviour
{
    [SerializeField] private Animator animator;
    [SerializeField] private Collider colliderPrincipal;

    private Rigidbody[] ossos;
    private Rigidbody corpoPrincipal;

    public bool Ativo { get; private set; }

    private void Awake()
    {
        corpoPrincipal = GetComponent<Rigidbody>();

        // Todos os Rigidbodies filhos, menos o do próprio objeto raiz.
        Rigidbody[] todos = GetComponentsInChildren<Rigidbody>();
        List<Rigidbody> lista = new List<Rigidbody>();
        foreach (Rigidbody rb in todos)
        {
            if (rb != corpoPrincipal)
            {
                lista.Add(rb);
            }
        }
        ossos = lista.ToArray();

        DefinirRagdoll(false);
    }

    public void DefinirRagdoll(bool ligado)
    {
        Ativo = ligado;

        foreach (Rigidbody rb in ossos)
        {
            rb.isKinematic = !ligado;
            rb.interpolation = ligado ? RigidbodyInterpolation.Interpolate : RigidbodyInterpolation.None;
        }

        animator.enabled = !ligado;

        if (colliderPrincipal != null)
        {
            colliderPrincipal.enabled = !ligado;
        }

        if (corpoPrincipal != null)
        {
            corpoPrincipal.isKinematic = ligado;
        }
    }
}

Os pontos importantes:

• A lista exclui o Rigidbody da raiz. Se o personagem usa Rigidbody para andar, ele não faz parte do ragdoll e vira Kinematic na morte, para não arrastar o corpo.
• O Animator é desligado, não pausado. Desligado, ele para de escrever nos ossos e a física assume a partir da pose atual. Por isso o boneco cai a partir do meio da animação, sem "pulo" para a T-pose.
• O collider principal é desligado. Se ficar ligado, a cápsula de andar fica em pé no lugar e os ossos caem em cima dela.
• Interpolate só ligado durante o ragdoll, para a queda ficar suave na câmera sem gastar enquanto os ossos seguem a animação.

Se o personagem usa Character Controller em vez de cápsula com Rigidbody, arraste o Character Controller para o campo colliderPrincipal: ele é um Collider e pode ser desligado do mesmo jeito. Desligue também o script de movimento na morte, porque chamar Move num controller desligado gera erro no Console.

Força no impacto do tiro

Um ragdoll que só desaba é estranho num jogo de tiro. O boneco precisa ser empurrado na direção do tiro, a partir do ponto atingido. Como os colliders dos ossos estão ligados durante o jogo, o raycast da arma já devolve o osso certo.

Arquivo MorteComImpacto.cs, no mesmo objeto do ControleRagdoll:

using UnityEngine;

[RequireComponent(typeof(ControleRagdoll))]
public class MorteComImpacto : MonoBehaviour
{
    [SerializeField] private float forcaImpacto = 40f;

    private ControleRagdoll ragdoll;

    private void Awake()
    {
        ragdoll = GetComponent<ControleRagdoll>();
    }

    public void Morrer(Rigidbody ossoAtingido, Vector3 ponto, Vector3 direcao)
    {
        if (ragdoll.Ativo)
        {
            return;
        }

        ragdoll.DefinirRagdoll(true);

        if (ossoAtingido != null)
        {
            ossoAtingido.AddForceAtPosition(direcao.normalized * forcaImpacto, ponto, ForceMode.Impulse);
        }
    }
}

Na arma, depois do raycast:

MorteComImpacto alvo = hit.collider.GetComponentInParent<MorteComImpacto>();
if (alvo != null)
{
    alvo.Morrer(hit.rigidbody, hit.point, direcaoDoTiro);
}

O hit.rigidbody é o Rigidbody do osso atingido, e GetComponentInParent sobe do osso até a raiz do personagem.

Por que ativar antes de aplicar a força: com isKinematic marcado, AddForce não tem efeito. A ordem importa.

ForceMode.Impulse considera a massa. Um tiro na cabeça (osso leve) joga a cabeça para trás com mais violência que um tiro no quadril (osso pesado), o que dá a variação que faz cada morte parecer diferente. Ajuste forcaImpacto para o seu jogo: exagero vira cômico, o que pode ser exatamente o que você quer. O post de game feel e juice fala de como esse tipo de exagero controlado muda a sensação do jogo.

Erros comuns: boneco tremendo ou explodindo

Boneco explode no momento da morte. Os colliders dos ossos estavam sobrepostos a outro collider (o principal, uma arma presa à mão, o chão) e a física separou tudo de uma vez. Desligue o collider principal antes de soltar os ossos (o DefinirRagdoll faz isso), coloque armas em layers que não colidem com Ragdoll e confira que o personagem não está afundado no chão.

Boneco treme no chão sem parar. Massas muito diferentes entre partes vizinhas, ou ossos pequenos demais por escala errada. Confira a escala do import, gere o ragdoll de novo com Total Mass entre 60 e 80, e aumente as iterações do solver: Default Solver Iterations em Project Settings > Physics, ou rb.solverIterations só nos ossos do ragdoll.

Joelho e cotovelo dobrando para o lado errado. O eixo da Character Joint ficou invertido. Gere de novo marcando Flip Forward, ou ajuste à mão no componente Character Joint do osso: os limites Low Twist Limit e High Twist Limit e os Swing 1 Limit e Swing 2 Limit.

Membros esticando como borracha. Em quedas violentas, o solver deixa juntas se separarem. Marque Enable Projection nas Character Joints dos membros: a física "puxa de volta" o osso quando a distância passa do limite.

Ragdoll caindo em câmera lenta. Escala do modelo gigante. Um boneco de 18 unidades de altura cai como se estivesse na Lua. Corrija o Scale Factor no import.

O boneco atravessa o chão. Colliders dos ossos finos e velocidade alta na queda. Ligue Continuous Speculative no Collision Detection dos ossos maiores (pelve e tronco) e confira que o chão tem collider com espessura.

A animação não volta depois do respawn. Desligar o ragdoll (DefinirRagdoll(false)) não leva os ossos de volta à pose. Ou você instancia um personagem novo no respawn (mais simples), ou religa o Animator e deixa ele sobrescrever os ossos no próximo frame.

Próximo passo

Monte a cena com um personagem do Mixamo, o ControleRagdoll e o MorteComImpacto, e uma câmera com um script de tiro por raycast. Atire na cabeça, no tronco e na perna, e compare as quedas. Depois solte o boneco do alto de uma escada para ver se ele treme no fim: se tremer, siga a lista de erros na ordem.

Com o básico funcionando, o passo seguinte é misturar animação e física em vez de trocar uma pela outra (o personagem tropeça, quase cai e se recupera). Isso exige outra técnica, mas parte desta mesma estrutura de ossos com Rigidbody e juntas.