animações

Unity: Animações em um game 2D

A Unity é uma das ferramentas mais poderosas e acessíveis para criar jogos 2D e 3D. Neste tutorial, vamos te mostrar como desenvolver um jogo de plataforma 2D simples na Unity, com movimentação lateral, pulo e animações integradas, usando o componente Rigidbody2D e o sistema de Animator.

Você vai aprender conceitos fundamentais como entrada do jogador, física 2D, movimentação por script em C#, além de entender como funcionam os sistemas de Animation e Animator na prática, essenciais para dar vida ao seu personagem!

Exemplo Prático: Ninja Frog Game

Aqui está o jogo que usaremos como referência:

Passo 1: Criando o Projeto na Unity

  1. Abra a Unity Hub e clique em “New Project”.

  2. Selecione o template 2D (Core).

  3. Dê um nome como BallGame e clique em Create.

unity

Passo 2: Criando o cenário com plataforma

  • No painel Hierarchy, clique com o botão direito e vá em 2D Object > Sprite.

  • Renomeie o novo objeto para Plataforma.

  • No Inspector, clique em “Sprite” e escolha uma imagem de plataforma (como a da imagem do tutorial).

  • Adicione o componente BoxCollider2D para permitir que o jogador colida com ela.

animações

Passo 3: Adicionando o jogador

  1. Crie um novo GameObject do tipo Sprite (pode ser uma esfera como na imagem).

  2. Adicione os seguintes componentes:

    • Rigidbody2D

    • CapsuleCollider2D

    • Player.cs
animações

Passo 4: Criando as animações no Animation

Nesta etapa, vamos criar as animações do jogador utilizando a ferramenta Animation da Unity. Serão quatro animações principais:

  • Idle (parado)

  • Run (correndo)

  • Jump (pulando)

  • Fall (caindo)

1. Criar a pasta de animações

  1. No painel Project, clique com o botão direito em Assets > Create > Folder.

  2. Nomeie a pasta como Animations.

2. Criar as animações

  1. Vá até o menu superior e clique em Window > Animation > Animation para abrir a aba Animation.

  2. Com o jogador selecionado, clique em Create na aba Animation.

  3. Salve a primeira animação como Idle dentro da pasta Animations.

  4. Em seguida, repita o processo para criar as outras animações:

    • Com o jogador selecionado, clique no menu suspenso da aba Animation e selecione Create New Clip.

    • Salve com o nome Run.

    • Repita para criar Jump e Fall.

3. Adicionar quadros às animações

  1. Com a animação aberta (por exemplo, Idle), clique em Add Property ou arraste diretamente os sprites para a linha do tempo.

  2. Insira os sprites na sequência correta para formar o movimento da animação.

  3. Ajuste o valor de Samples na parte superior da aba Animation para controlar a velocidade da animação.

animações

Passo 5: Configurando o Animator

Agora que já temos as animações criadas, vamos configurar o Animator Controller para que o personagem mude de animação automaticamente conforme o movimento, o pulo ou a queda.

1. Criar os parâmetros no Animator

  1. Com o jogador selecionado, abra a aba Animator.

  2. Clique na aba Parameters.

  3. Clique no botão “+” para criar os seguintes parâmetros:

TipoNome
Intmovimento_h
BooltocouChao
FloatvelocidadeY

Esses parâmetros serão atualizados pelo script e vão controlar qual animação deve ser exibida.

2. Adicionar os estados Idle e Run

  1. Clique com o botão direito na área do Animator e selecione Create State > From New Clip.

  2. Selecione o arquivo Idle e repita para Run.

  3. Clique com o botão direito no estado Idle e selecione Set as Default State.

  4. Crie as transições:

    • De Idle para Run

    • De Run para Idle

  5. Para cada transição, siga os passos abaixo:

    • Selecione a seta de transição.

    • No painel Inspector, defina:

      • Transition Duration = 0

      • Desmarque a opção Has Exit Time

    • Em Conditions, configure:

      • Idle → Run: movimento_h diferente de 0

      • Run → Idle: movimento_h igual a 0

3. Criar Blend Tree para Jump e Fall

  1. Clique com o botão direito e selecione Create State > From New Blend Tree.

  2. Nomeie como Jump nd Fall.

  3. Clique duas vezes no Blend Tree para abrir.

  4. Na aba Inspector, defina:

    • Blend Type: 1D

    • Parameter: velocidadeY

  5. Clique no botão + e selecione Add Motion Field duas vezes.

    • Em Motion, adicione a animação Fall com Threshold -0.1

    • Em Motion, adicione a animação Jump com Threshold 0.1

4. Criar a transição para o Blend Tree

  1. Crie uma transição de Any State para Jump nd Fall.

  2. Crie outra transição de Jump nd Fall para Exit. Para cada transição, ajuste:

    • Transition Duration = 0

    • Desmarque a opção Has Exit Time

  3. Em Conditions, configure:

    • Any State → Jump nd Fall: quando tocouChao = false

    • Jump nd Fall → Exit: quando tocouChao = true

animações
animações
animações

Passo 6: Criando o script - Declarando variáveis

Essas variáveis serão usadas para controlar o movimento horizontal, o pulo, o estado de ataque, o flip do personagem, a detecção de chão e o controle das animações:

				
					private float movimentoH;
public float velocidade;      // Exemplo: 10
public float jumpForce;       // Força do pulo
private Rigidbody2D jogadorRb;
private float velocidadeY;

private bool isLookLeft = true;
private float scaleX;

private Animator animacao_jogador;

private bool tocarChao;
public Transform colisorChao;


				
			

Explicação:

  • movimentoH: armazena o valor do eixo horizontal (teclas A/D ou setas).

  • velocidade: define a velocidade da movimentação lateral.

  • jumpForce: controla a força aplicada no pulo.

  • jogadorRb: acessa o componente Rigidbody2D do jogador.

  • velocidadeY: armazena a velocidade vertical do Rigidbody (para detectar pulo/queda).

  • isLookLeft: controla para qual lado o personagem está olhando.

  • scaleX: usado para inverter a escala do personagem quando muda de direção.

  • animacao_jogador: armazena o componente Animator e permite ativar as animações via script.

  • tocarChao: detecta se o jogador está encostando no chão (para impedir pulo no ar).

  • colisorChao: representa o ponto de verificação do chão.

Passo 7: Criando o script de movimentação – Iniciando o Rigidbody e o Animator no Start

No início do jogo, precisamos conectar o script ao corpo físico (Rigidbody2D) e ao controlador de animações (Animator) do personagem. Isso é feito dentro do método Start().

				
					void Start()
{
    jogadorRb = GetComponent<Rigidbody2D>();
    animacao_jogador = GetComponent<Animator>();
}

				
			

Explicação:

  • jogadorRb = GetComponent<Rigidbody2D>(): acessa o componente Rigidbody2D do jogador para controlar física, movimento e pulo.

  • animacao_jogador = GetComponent<Animator>(): conecta o script ao Animator para controlar as animações via parâmetros.

Passo 8: Criando o script de movimentação – Capturando o movimento no Update

Nesta parte, vamos capturar a entrada do jogador (teclado) para movimentação, pulo e ataque. Tudo isso será feito no método Update(), que é chamado a cada frame.

				
					void Update()
{
    movimentoH = Input.GetAxisRaw("Horizontal");

    if (movimentoH < 0 && isLookLeft == true)
    {
        Flip();
    }

    if (movimentoH > 0 && isLookLeft == false)
    {
        Flip();
    }

    if (Input.GetButtonDown("Jump") && tocarChao == true)
    {
        jogadorRb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
    }

}

				
			

Explicação:

  • Input.GetAxisRaw("Horizontal"): retorna -1 (esquerda), 0 (parado) ou 1 (direita), conforme a tecla pressionada.

  • Os if com isLookLeft fazem o personagem virar para o lado certo.

  • Input.GetButtonDown("Jump") && tocarChao == true: só permite pular se o jogador estiver no chão.

  • AddForce: aplica uma força vertical para o pulo.

Passo 9: Criando o script de movimentação – Aplicando o movimento

Agora aplicamos o movimento horizontal e preservamos a velocidade vertical do jogador:

				
					velocidadeY = jogadorRb.linearVelocity.y; //velocidade padrão, que ja vem no player
jogadorRb.linearVelocity = new Vector2(movimentoH * velocidade, velocidadeY);

				
			

Explicação:

  • velocidadeY = jogadorRb.linearVelocity.y: armazena a velocidade vertical atual.

  • jogadorRb.linearVelocity: define a nova velocidade do jogador.

  • movimentoH * velocidade: define a direção e a intensidade do movimento horizontal.

Passo 10: Criando o script de movimentação – Atualizando o Animator no Update

Agora que os parâmetros já foram criados no Animator, precisamos atualizá-los constantemente no script, para que as animações sejam ativadas corretamente de acordo com o movimento do jogador.

Adicione as seguintes linhas no final do método Update():

				
					animacao_jogador.SetInteger("movimento_h", (int) movimentoH);
animacao_jogador.SetBool("tocouChao", tocarChao);
animacao_jogador.SetFloat("velocidadeY", velocidadeY);

				
			

Explicação:

  • SetInteger("movimento_h", (int) movimentoH): envia para o Animator o valor do movimento horizontal (−1, 0 ou 1).

  • SetBool("tocouChao", tocarChao): informa se o jogador está encostando no chão.

  • SetFloat("velocidadeY", velocidadeY): envia a velocidade vertical atual para controlar as animações de pulo e queda no Blend Tree.

Passo 11: Criando o script de movimentação – Detectando o chão com OverlapCircle

Para saber se o jogador está tocando no chão e permitir o pulo apenas nesse momento, vamos usar o método Physics2D.OverlapCircle. Essa verificação será feita no FixedUpdate().

				
					private void FixedUpdate()
{
    tocarChao = Physics2D.OverlapCircle(colisorChao.position, 0.02f);
}

				
			

Explicação:

  • FixedUpdate(): usado para lidar com física, pois é chamado em intervalos fixos.

  • Physics2D.OverlapCircle: verifica se há alguma colisão no ponto indicado.

  • colisorChao.position: é a posição do ponto de verificação (normalmente um GameObject pequeno sob o jogador).

  • 0.02f: raio do círculo de detecção. Um valor pequeno para detectar apenas o chão sob os pés.

  • O resultado (true ou false) será armazenado na variável tocarChao e usado no Update() para liberar ou bloquear o pulo e para ativar as animações corretas.

Passo 12: Criando o script de movimentação – Virando o personagem com a função Flip

Para o personagem olhar para a direção correta ao se mover, precisamos inverter a escala horizontal dele. Isso é feito com a função Flip().

Adicione o seguinte método ao seu script:

				
					void Flip()
{
    isLookLeft = !isLookLeft;
    scaleX = transform.localScale.x * -1;
    transform.localScale = new Vector3(scaleX, transform.localScale.y, transform.localScale.z);
}

				
			

Explicação:

  • isLookLeft = !isLookLeft: inverte o estado atual (se estiver olhando para a esquerda, muda para direita e vice-versa).

  • scaleX = transform.localScale.x * -1: inverte o sinal da escala no eixo X.

  • transform.localScale = ...: aplica a nova escala, fazendo o personagem virar para o outro lado.

Resultado Final

				
					using UnityEngine;
using UnityEngine.InputSystem.iOS;

public class Player : MonoBehaviour
{
    private float movimentoH;

    public float velocidade; 

    public float jumpForce;

    private Rigidbody2D jogadorRb;

    private float velocidadeY;

    private bool isLookLeft = true;

    private float scaleX;

    private Animator animacao_jogador;

    //VARIAVEL PARA RECONHECER SE O JOGADOR TA TOCANDO NO CHAO
    private bool tocarChao;

    //variavel que vai reconhecer o colisor do jogador
    public Transform colisorChao;


    // Start is called once before the first execution of Update after the MonoBehaviour is created
    void Start()
    {

        jogadorRb = GetComponent<Rigidbody2D>();
        animacao_jogador = GetComponent<Animator>();

    }

    // Update is called once per frame
    void Update()
    {

        movimentoH = Input.GetAxisRaw("Horizontal");

        if (movimentoH < 0 && isLookLeft == true)
        {
            Flip();
        }

        if (movimentoH > 0 && isLookLeft == false)
        {
            Flip();
        }

        velocidadeY = jogadorRb.linearVelocity.y; //velocidade padrão, que ja vem no player
        jogadorRb.linearVelocity = new Vector2(movimentoH * velocidade, velocidadeY);


        //verificando se foi clicada a tecla para que o jogador possa pular
        if (Input.GetButtonDown("Jump") && tocarChao == true)
        {
            jogadorRb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
        }


        //transformar a variável movimentoH em int - para executar a animação
        animacao_jogador.SetInteger("movimento_h", (int)movimentoH);
        animacao_jogador.SetBool("tocouChao", tocarChao);
        animacao_jogador.SetFloat("velocidadeY", velocidadeY);
    
    }

    void Flip()
    {
        //verdadeira- esquerda
        //falsa- direita
        //diferente - !  não 
        isLookLeft = !isLookLeft;

        //se ele ta olhando para a esquerda depois de um tempo fica falsa e ele olha para direita

        scaleX = transform.localScale.x * -1; //inverter o sinal da escala em x

        //atualizar o scale completo

        transform.localScale = new Vector3(scaleX, transform.localScale.y, transform.localScale.z);

    }

    private void FixedUpdate()
    {

        //float- numero decimal - 0.10f
        tocarChao = Physics2D.OverlapCircle(colisorChao.position, 0.02f);
    }



}
				
			

Ao executar o código, você verá:

  • Um personagem posicionado sobre a única plataforma do cenário.

  • Um cenário simples com uma plataforma fixa no chão.

  • O personagem se movimentando para a esquerda e direita com as teclas A/D ou ←/→.

  • O personagem pulando ao pressionar a tecla Espaço, apenas quando estiver tocando no chão.

  • As colisões funcionando corretamente: o jogador não atravessa a plataforma.

  • As animações mudando automaticamente entre parado, correndo, pulando e caindo, conforme o movimento do jogador.

Posts Similares

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *