Animações 2D Mecanim

O sistema de animação da Unity é baseado no conceito de clipes de animação

(Animation Clip), que contém informações sobre como determinados objetos devem

alterar sua posição, rotação ou outras propriedades ao longo do tempo.

Os clipes de animação são então organizados em um sistema estruturado

semelhante a um fluxograma, denominado Animator Controller. O Animator Controller

atua como uma “Máquina de Estado”, que controla qual clipe deve estar sendo

reproduzido no momento e quando as animações devem ser alteradas.

Importando os Assets Importe para dentro do seu projeto 2D todos os Sprites referentes ao

personagem que será animado. Nesse material utilizaremos como base os Sprites do

personagem Cute Girl baixados do site gameart2d.

Criando o Personagem Arraste pare dentro da aba Hierarchy o sprite chamado “Idle (1)”, ele servirá

como base para a criação do GameObject do personagem. Renomeie o GameObject

para Personagem.

Em alguns casos os sprites que utilizaremos em nossos projetos podem não estar

como a proporção adequada para o nosso jogo, sejam muito grandes ou muito

pequenos. Para contornar essa situação devemos alterar a sua proporção em relação a

cena apenas modificando a sua propriedade Scale em todos os eixos. No caso do

personagem Cute Girl, ela está um pouco grande, para isso vamos reduzir a sua escala

para 0.4.

Figura 1 - Alterando o Scale

Componentes de uma animação Na Unity para criarmos animações precisamos obrigatoriamente de três

componentes, independentemente se as animações sejam 2D ou 3D. São eles:

• Animator – usado para atribuir uma animação a um GameObject. O componente

Animator requer uma referência a um Animator Controller;

• Animator Controller – define quais clipes de animação serão usados e controla

quando eles devem ser tocados;

• Animation Clip – é a própria animação do personagem.

Cada personagem ou objeto animado deverá possuir os seus próprios componentes.

Animator Component Selecione o personagem Cute Girl e adicione o componente Animator. Não

confundir com “Animation”.

Figura 2 – Adicionando o componente Animator

Animator Controller Agora que o nosso personagem possui um componente Animator, precisamos

criar um Animator Controller e depois associá-lo ao personagem. Dentro do projeto crie

uma pasta chamada Animações, dentro dela crie o Animator Controller clicando com o

botão direito do mouse CREATE >> Animator Controller. Renomeie o Animator

Controller para CuteGirl.

Figura 3 - Animator Controller

Em seguida vamos associar (arrastar) o Animator Controller ao Animator do

Personagem, como demonstra a figura a seguir:

Figura 4 - Associando um Animator Controller a um Animator

Ao clicarmos duas vezes em cima do Animator Controller será exibida uma nova

aba chamada Animator como a mostrada a seguir:

Figura 5 - A aba Animator

A aba Animator tem duas seções principais: a área de layout principal em grade e o

painel Layers (Camadas) e Parameters (Parâmetros) à esquerda.

A seção principal com a grade cinza escura é a área de layout. Você pode usar

esta área para criar, organizar e conectar estados (animações) no seu Animator

Controller. Você pode clicar com o botão direito do mouse na grade para criar novos nós

de estado. Use o botão do meio do mouse ou a tecla Alt para movimentar a câmera.

Clique para selecionar os nós de estado, você pode também reorganizá-los

simplesmente clicando e arrastando os nós.

O painel esquerdo pode ser alternado entre as abas Parameters e Layers. A aba

Parameters permite criar, visualizar e editar os parâmetros que serão utilizados pelo

Animator Controller. Estas são variáveis que você define e que atuam como entradas na

máquina de estados. Para adicionar um parâmetro, clique no ícone “+” e selecione o

tipo de parâmetro no menu pop-up. Para excluir um parâmetro, selecione o parâmetro

nas listas e pressione a tecla delete.

Quando o painel esquerdo é alternado para a visualização Layers, você pode

criar, visualizar e editar camadas no seu Animator Controller. Isso permite que você

tenha várias camadas de animação em um único Animator Controller trabalhando ao

mesmo tempo, cada uma controlada por uma máquina de estado separada.

O Animator Controller gerencia os vários estados de animação e as transições

entre eles usando uma espécie de “Máquina de Estado”, que pode ser considerada

como um tipo de fluxograma, ou um programa simples escrito em uma linguagem de

programação visual dentro da Unity.

Animation Clip Os clipes de animação (Animation Clip) são um dos principais elementos do

sistema de animação da Unity. A Unity suporta a importação de animação de fontes

externas e oferece a capacidade de criar clipes de animação a partir do zero no editor

usando a janela Animation, que pode ser acessado em WINDOW >> ANIMATION ou

pelo atalho CTRL + 6.

Na maioria das situações, é normal termos várias animações e alternar entre elas

quando certas condições do jogo ocorrem. Por exemplo, você pode alternar de uma

animação de caminhada para um salto sempre que a barra de espaço for pressionada.

No entanto, mesmo se você tiver apenas um único clipe de animação, ainda precisará

colocá-lo em um Animator Controller para usá-lo em um objeto de jogo.

Para criarmos um Animation Clip, clique com o botão direito do mouse dentro

da pasta Animações e selecione CREATE >> ANIMATION. Renomeie o arquivo para

“Parado”.

Figura 6 - Criando uma animação

Esse Animation Clip será o responsável por armazenar a animação que

representa o personagem parado. Porém, antes de animarmos os sprites de parado,

devemos associar esse Animation Clip ao Animation Controller do personagem. Para

fazer essa associação devemos arrastar o Animation Clip “Parado” para dentro do

Animation Controller “CuteGirl” (Antes de arrastar o Animation Clip, verifique se o

Animation Controller desejado está aberto dentro da aba Animator).

Figura 7 - Associando um Animation Clip a um Animation Controller

Com o Animation Clip “Parado” já associado ao seu Animator Controller,

podemos finalmente associar os sprites que serão utilizados para essa animação. Dentro

da pasta Sprites, selecione todos os dezesseis sprites que compõem essa animação (Idle

(1) até Idle (16)) e o arraste para dentro da aba Animation. Altere o número de quadros

da animação de sessenta para vinte e quatro dentro da opção Samples. Para saber um

pouco mais sobre taxa de quadros (FPS) acesse:

https://www.tecmundo.com.br/video/10926-o-que-sao-frames-por-segundo-.htm

Figura 8 - Criando uma animação a partir de sprites

Queremos também que essa animação seja tocada de forma ininterrupta (loop),

ou seja, quando todos os quadros forem tocados a animação deverá ser tocada

novamente a partir do início. Selecione o Animation Clip “Parado” e dentro do painel

Inspector marque a opção Loop Time como mostra a imagem a seguir:

Figura 9 - Animação tocando em loop

Ao entrarmos no modo Play podemos reparar que a animação “Parado” está

sendo executada em loop.

O nosso personagem já é capaz de executar a animação “Parado” de forma

ininterrupta, porém a personagem deve possuir mais três animações de um total de

quatro, são elas: Parado (já criada), Correndo, Pulando e Morrendo.

Vamos agora criar essas três novos Animation Clip repetindo os mesmos passos

utilizados na criação da animação “Parado”, com apenas uma modificação, as animações

“Pulando” e “Morrendo” não precisam ser executadas em loop.

Existem diversas formas para criarmos novos clipes de animação na Unity, uma

delas é acessando a aba Animation com o GameObject que receberá o clip selecionado

dentro da aba Hierarchy. Ao lado esquerdo da opção Samples existe uma caixa com os

nomes de todas as animações já associadas ao GameObject, acessando essa caixa

selecione a opção CREATE NEW CLIP. Renomeie o clipe com o nome desejado e o salve

dentro da pasta de animações. Criando um novo clip com essa abordagem ele já

adicionado automaticamente dentro do Animation Controller do GameObject.

Figura 10 - Adicionando um novo Animation Clip

Transição entre animações Com todas as quatro animações criadas, vamos acessar a aba Animator. Ela deve

estar com a visualização similar à da figura a seguir (com o clique esquerdo do mouse

você pode reposicionar todos os estados de uma animação):

Figura 11 - Aba Animator após a criação de todas as animações

Acessando a aba Animator, podemos reparar que a animação “Parado” possui

uma cor diferente das demais além de ter uma ligação com a “caixa” chamada Entry.

Mas por que?

Toda que vez que um GameObject animado aparece em uma cena na Unity, a

engine necessita saber qual animação deve ser tocada primeiro. A “caixa” Entry tem

justamente essa finalidade, ou seja, todo clipe ligado a ela será executado antes de todos

os outros. Já o clipe “Parado” possui uma cor diferente (laranja) para explicitar ao

desenvolvedor que esse clipe é o estado padrão (“default state”).

Podemos alterar o clipe padrão clicando com o botão direito do mouse em cima

do estado desejado e selecionar a opção SET AS LAYER DEFAULT STATE.

Figura 12 - Alterando a animação padrão

O nosso personagem deve ser capaz de trocar de um estado (animação) para o

outro, para isso, devemos informar para a Unity que um estado é capaz de transitar para

outro estado, ou seja, a animação “Parado” em algum momento deve parar sua

execução e tocar a animação de “Correndo” e vice-versa.

Vamos agora fazer a transição do estado “Parado” para o estado “Correndo”.

Clique com o botão direito do mouse em cima de “Parado” e selecione a opção Make

Transition e faça a ligação com o estado “Correndo”.

Figura 13 - Fazendo a transição de Parado para Correndo

O estado de “Correndo”, também deve ser capaz de voltar para o estado de “Parado”,

para isso devemos fazer uma nova transição, agora de “Correndo” para “Parado”.

Figura 14 - Fazendo a transição de Correndo para Parado

Ao entrarmos no modo Play, podemos visualizar que existe uma transição entre

as animações. A animação de “Parado” é tocada uma vez até o seu fim e em seguida

ocorre a transição para a animação “Correndo”. Ela também é tocada apenas uma vez e

retorna novamente para a animação “Parado” e esse ciclo é repetido enquanto o jogo

está sendo executado.

Em nosso jogo não queremos que as transições entre as animações ocorram de

forma automática e sim quando determinadas condições forem alcançadas. Por

exemplo, queremos que a animação “Correndo” seja tocada de forma ininterrupta

enquanto o personagem estiver se movendo do contrário a animação “Parado” deve

estar em execução.

Em ambas as setas que representam a transição das animações devemos fazer

algumas modificações. Primeiro, selecione a seta que aponta de “Parado” para

“Correndo” e acesse o painel Inspector.

Figura 15 - Editando a transição entre animações

• Desmarque a opção Has Exit Time;

• Desmarque a opção Fixed Duration;

• Altere o valor da opção Transition Duration para ZERO.

Figura 16 - Removendo a transição automática e o "delay" na troca de animações

Repita os mesmos passos na transição entre as animações de “Correndo” para “Parado”.

Movimentando o jogador Com as animações de “Parado” e “Correndo” já criadas e configuradas, vamos

adicionar o movimento ao nosso personagem. Primeiro devemos adicionar alguns

outros componentes como o Box Collider 2D e o Rigidbody 2D.

Após adicionar o Box Collider 2D ao personagem ajuste o colisor (clicando em

Edit Collider) para que fique mais ou menos com a mesma dimensão do sprite do

personagem. Tente alinhar a parte de baixo do colisor com os pés do personagem para

evitar dar a impressão que o personagem está flutuando na cena.

Figura 17 - Editando o Box Collider 2D

Precisamos fazer também um pequeno ajuste dentro do Rigidbody 2D, acesse a

sub propriedade Contraints e marque a opção Freeze Rotation no eixo Z, isso evitará

que ao movimentarmos o personagem pelo cenário ele rotacione pela cena ao colidir

com algum desnível ou rampa.

Figura 18 - "Travando" a rotação no eixo Z

Para evitar que o personagem cai no “infinito” por causa da ação da física da

Unity, vamos adicionar uma plataforma a cena. Dentro da pasta Sprites clique com o

botão direito e acesse CREATE >> SPRITES >> SQUARE. Renomeie o arquivo para bloco.

Figura 19 - Criando um sprite

Em seguida posicione o sprite bloco na parte de baixo da cena e chame esse

GameObject de Plataforma, redimensione-o para que sua largura seja um pouco maior

que a largura da tela (câmera). Adicione também um componente do tipo Box Collider

2D, isso fara com que a nossa personagem consiga se movimentar em cima da

plataforma.

Figura 20 - Adicionando uma plataforma

Em seguida crie um novo Script chamado ControlaPersonagem e o associe ao

GameObject Personagem.

Figura 21 - Composição final do GameObject Personagem

O script ControlaPersonagem contém toda a lógica que permitirá ao nosso

personagem se mover e animar. Na verdade, é um componente que está ligado ao

personagem. Esse script implementa três funções (Movimentar, Pular e Virar), uma para

cada ação, além disso, esse componente deve levar em consideração o componente

Animator, para mostrar a animação certa para o personagem.

Vamos começar adicionando três variáveis: uma que irá armazenar o

componente Animator (anim), outra para o Rigidbody2D (rb) e por fim uma outra que

controlará a velocidade de deslocamento do personagem (velocidade).

Podemos acessar os componentes Animator e Rigidbody2D do personagem

dentro do método Awake chamando o método GetComponent ().

using System.Collections; using System.Collections.Generic; using UnityEngine; public class ControlaPersonagem : MonoBehaviour { [SerializeField] private float velocidade = 5; private Rigidbody2D rb; private Animator anim; private void Awake() { rb = GetComponent<Rigidbody2D>(); anim = GetComponent<Animator>(); } private void FixedUpdate() { float movimentoHorizontal = Input.GetAxis("Horizontal"); Movimentar(movimentoHorizontal); } private void Movimentar(float movimento) { rb.velocity = new Vector2(movimento * velocidade, rb.velocity.y); }

}

O primeiro método que vamos criar será o Movimentar, que tem como

parâmetro um valor do tipo float chamado movimento que será responsável por indicar

a direção do movimento. Dentro desse método iremos atribuir a propriedade velocity

(que pertence à classe Rigidbody2D) um objeto do tipo Vector2 que contém em seu

primeiro parâmetro a movimentação no eixo X (movimento * velocidade), enquanto no

segundo parâmetro (eixo Y) iremos atribuir o próprio valor da velocidade em seu próprio

eixo, não alterando o seu valor.

Ao executarmos o jogo, podemos ver que o personagem possui uma

movimentação bem suavizada e controlada pelas setas do teclado ou pelas teclas A e D.

Alterando o estado de parado para correndo Agora que o personagem já está se movendo pela cena, devemos efetuar a troca

de animações. Para trocarmos de animação de forma dinâmica na Unity devemos

primeiro definir como a transição deve ser efetuada. Dentro da Unity vamos acessar o a

janela Animator e depois o painel Parameters.

Precisamos criar um parâmetro que será o responsável pela troca da animação

“Parado” para a animação “Correndo”. A transição entre essas animações deverá ter

como base a velocidade do personagem no eixo X, ou seja, quando a velocidade do

personagem for maior que ZERO, o personagem estará se movimentando e com isso a

animação “Correndo” deverá ser executada. Quando a velocidade em X for menor que

ZERO, o personagem estará parado e assim a animação “Parado” deverá ser executada

novamente.

Figura 22 - Parâmetros de uma animação

Clique no botão “+” e selecione a opção float. Renomeie esse parâmetro para

velocidade.

Figura 23 - O parâmetro velocidade

Com o parâmetro velocidade criado, devemos associá-lo a transição de “Parado”

para “Correndo”. Clique na seta que representa essa transição e dentro do painel

Inspector, acesse Conditions e clique no botão “+”.

Figura 24 - Adicionando uma condição a uma transição

Na caixa de seleção que irá aparecer dentro da seção Conditions, selecione o

parâmetro criado anteriormente (velocidade), em seguida o valor Greater e por ultimo

defina o valor como 0.01.

Figura 25 - Parâmetro da transição entre Parado para Correndo

A seguir faremos praticamente o mesmo com a transição de “Correndo” para

“Parado”, onde iremos apenas alterar o valor de Greater para Less.

Figura 26 - Parâmetro da transição entre Correndo para Parado

Com o parâmetro de transição entre as animações definido, podemos retornar a

classe ControlaPersonagem. Vamos colocar dentro do método Update a

responsabilidade de executar a troca de animações frame após frame. Em particular,

precisamos definir o parâmetro velocidade criado dentro da máquina de estados da

animação com a velocidade do personagem ao longo do eixo x.

Vamos fazer uma chamada a função SetFloat que pertence à classe Animator

utilizando a variável anim. Este método faz referência a todos os parâmetros criados

dentro do Animator que sejam do tipo float. Devemos passar como o primeiro

parâmetro do método uma string que representará o parâmetro criado anteriormente

(o valor passado como string deve ser escrito de forma igual ao parâmetro criado dentro

do painel Animator, respeitando caracteres maiúsculos e minúsculos).

O segundo parâmetro é o valor que atribuiremos ao parâmetro velocidade.

Utilizaremos o método Abs da classe Mathf para podermos extrair o valor absoluto (sem

sinal) da propriedade velocity.

/*Continua a classe ControlaPersonagem acima*/ private void Update() { anim.SetFloat("velocidade", Mathf.Abs(rb.velocity.x)); }

/*Continua a classe ControlaPersonagem abaixo*/

Ao entrarmos no modo Play podemos ver a troca de animações ocorrendo

sempre que há alguma alteração na velocidade do personagem.

“Virando” o Personagem (Flip) Ao movimentarmos o nosso personagem utilizando as setas do teclado ocorre a

transição entre as animações perfeitamente, porém quando andamos para trás

utilizando a seta para a esquerda podemos notar que o personagem faz um verdadeiro

“Moonwalk” (Michael Jackson).

Para corrigirmos esse bug precisamos adicionar uma variável booleana a nossa

classe ControlaPersonagem, ela será responsável por controlar a direção para onde o

personagem deve estar virado no momento. Vamos chamar essa variável de

viradoParaDireita e iniciar o seu valor com true dentro do método Start.

Sempre que o personagem estiver virado para a direita o valor da variável deverá

ser true, caso ele esteja virado para a esquerda o valor deverá ser alterado para false.

public class ControlaPersonagem : MonoBehaviour { [SerializeField] private float velocidade = 5; private bool viradoParaDireita; private Rigidbody2D rb; private Animator anim; private void Awake() { rb = GetComponent<Rigidbody2D>(); anim = GetComponent<Animator>(); } private void Start() { viradoParaDireita = true; } /*Continua a classe ControlaPersonagem abaixo*/

O controle da variável viradoParaDireita deverá ser efetuado pelo método

Virar(), que será criado dentro da classe ControlaPersonagem. Este método receberá

com parâmetro um valor do tipo float chamado de movimento que será responsável por

indicar a direção na qual o personagem está se movendo. O método Virar funcionará da

seguinte forma:

• caso o personagem esteja virado para a esquerda (viradoParaDireita == false) e

o movimento do personagem é alterado para a direita (movimento > 0) ou;

• caso o personagem esteja virado para a direita (viradoParaDireita == true) e o

movimento do personagem é alterado para a esquerda (movimento < 0);

Caso alguma das condições acima seja verdadeira, deverá ser efetuado o

espelhamento dos sprites do personagem. Para espelharmos um GameObject, podemos

multiplicar a propriedade localScale somente no eixo X por -1, fazendo com que o sprite

vire sempre para o lado oposto ao atual. Não devemos esquecer que logo após fazer o

“flip” do personagem devemos também inverter o valor da variável viradoParaDireita.

/*Continua a classe ControlaPersonagem acima*/ private void Movimentar(float movimento) { rb.velocity = new Vector2(movimento * velocidade, rb.velocity.y); Virar(movimento); } private void Virar(float movimento) { if((viradoParaDireita == false && movimento > 0) || (viradoParaDireita == true && movimento < 0 )) { transform.localScale = new Vector3( transform.localScale.x * -1, transform.localScale.y, transform.localScale.z); viradoParaDireita = !viradoParaDireita; } }

/*Continua a classe ControlaPersonagem abaixo*/

Para finalizar devemos chamar o método Virar dentro do método Movimentar

passando o valor da variável movimento como parâmetro. Ao executarmos o jogo

podemos ver o espelhamento do sprite funcionando perfeitamente.

O sistema de pulo Para criarmos um mecanismo de pulo eficiente dentro do jogo é necessário

adicionarmos novos elementos ao projeto. Primeiro, precisamos criar algo que sirva

como referência para a posição dos “pés” do personagem. Esse mecanismo deverá ser

capaz de nos informar quando o personagem estiver em contato com o chão ou em algo

no qual ele possa se locomover normalmente.

Segundo, precisamos criar uma forma de diferenciar os tipos de terreno

existentes no jogo e que também que seja capaz de enviar a informação de que ouve

uma colisão com o jogador ou qualquer outro objeto do jogo.

Uma vez que definirmos esses dois novos componentes, podemos entrar em

ação com o sistema de pulo. O sistema de pulo deverá entrar em ação apenas quando o

jogador apertar o botão designado para pular e se o personagem estiver em contato

com alguma superfície que lhe proporcione o pulo (evitando pulos no ar ou em

superfícies grudentas por exemplo).

Vamos definir a posição dos “pés”. Crie um GameObject vazio dentro do

personagem e o posicione entre as suas pernas próximo ao seus pés. Renomeie esse

GameObject para “Posicao dos pes”. Para facilitar a visualização da posição dos pés,

vamos adicionar um ícone colorido a ele.

Figura 27 - Adicionando um ícone a um GameObject

Em seguida vamos criar uma Layer (camada) que será usada para diferenciar qual

o tipo de terreno onde os “pés” do personagem estarão colidindo. Layers (camadas) são

comumente usadas pelas câmeras para renderizar apenas uma parte da cena e pelas

luzes para iluminar apenas algumas partes do cenário. Também podem ser utilizados

por raycasting e para ignorar seletivamente Colliders e ou para criar colisões.

Para criarmos uma nova Layer, acesse o menu Inspector, clique dentro da caixa

de seleção Layer e na opção Add Layer.

Figura 28 - Adicionando uma Layer

Após acessar a janela Tags & Layers, na linha oito, crie a layer chamada “chao”.

Figura 29 - Criando uma layer

Em seguida selecione o GameObject Plataforma e associe a layer chao a ele. Todo

GameObject em nosso jogo que possuir o comportamento de chão deverá possuir a

layer “chao”.

Figura 30 - Atribuindo a layer chao

Com todas as modificações necessárias para o sistema de pulo prontas, podemos

voltar para o script ControlaPersonagem e fazer algumas adições. Primeiro,

precisaremos criar mais cinco variáveis:

• alturaDoPulo: irá definir a força do pulo do personagem;

• estaNoChao: irá verificar quando o personagem está com os pés no chão;

• posicaoDosPes: irá armazenar a posição do GameObject posicaoDosPes;

• raioPosicaoDosPes: define o tamanho do raio da circunferência que irá verificar

a colisão com a camada chão;

• mascaraChao: irá armazenar a layer considerada chão;

public class ControlaPersonagem : MonoBehaviour { [SerializeField] private float velocidade = 5; [SerializeField] private float alturaDoPulo = 5; private bool viradoParaDireita; private bool estaNochao; [SerializeField] private Transform posicaoDosPes; [SerializeField] private float raioPosicaoDosPes = 0.2f; [SerializeField] private LayerMask mascaraChao; private Rigidbody2D rb; private Animator anim;

/*Continua a classe ControlaPersonagem abaixo*/

Dentro do método FixedUpdate, iremos utilizar o método OverlapCircle da classe

Physiscs2D. Esse método irá criar um círculo imaginário baseado nos parâmetros

passados e retornará true caso esse circulo tenha contato com a layer designada. Vamos

atribuir o valor de retorno deste método a variável estaNoChao;

/*Continua a classe ControlaPersonagem acima*/

private void FixedUpdate() { estaNochao = Physics2D.OverlapCircle( posicaoDosPes.transform.position, raioPosicaoDosPes, mascaraChao); float movimentoHorizontal = Input.GetAxis("Horizontal"); Movimentar(movimentoHorizontal); }

/*Continua a classe ControlaPersonagem abaixo*/

Apesar da função acima funcionar de forma satisfatória, não conseguimos

visualizar a circunferência de colisão dos pés do personagem com o chão. Felizmente a

classe MonoBehaviour possui um método chamado OnDrawGizmos que tem a

capacidade de desenhar formas que podemos utilizar para testar (debugar) certas

funções dentro do jogo. O desenho realizado pelo método OnDrawGizmos será somente

exibido dentro da aba Scene do jogo.

/*Continua a classe ControlaPersonagem acima*/

private void OnDrawGizmos() { Gizmos.color = Color.red; //Altera a cor da linha do desenho, por padrão a cor será branca; Gizmos.DrawWireSphere(posicaoDosPes.position, raioPosicaoDosPes); }

/*Continua a classe ControlaPersonagem abaixo*/

Figura 31 - Desenhando a circunferência de colisão

Com o mecanismo que atribui valor a variável estaNoChao funcionando, vamos

criar o método Pular dentro da classe ControlaPersonagem.

O pulo do personagem deverá ser efetuado sempre que a tecla espaço for

pressionada (a tecla espaço é mapeada por padrão como “Jump” dentro do painel Input

na Unity) e se o valor da variável estaNoChao for true. Caso as duas condições sejam

verdadeiras, adicionaremos um força (AddForce) utilizando como base o vetor que

aponta para cima (Vector2.up) multiplicados pela força do pulo (alturaDoPulo). Para

suavizarmos o movimento do pulo iremos passar como segundo parâmetro a

propriedade Impulse da classe ForceMode2D.

/*Continua a classe ControlaPersonagem acima*/ private void Pular() { if(Input.GetButtonDown("Jump") && estaNochao == true) { rb.AddForce(Vector2.up * alturaDoPulo, ForceMode2D.Impulse); } }

/*Continua a classe ControlaPersonagem abaixo*/ A chamada do método Pular deverá ser feita dentro do método Update.

/*Continua a classe ControlaPersonagem acima*/ private void Update() { anim.SetFloat("velocidade", Mathf.Abs(rb.velocity.x)); Pular(); }

/*Continua a classe ControlaPersonagem abaixo*/ Ao executarmos o jogo e pressionarmos a tecla espaço podemos ver o

personagem executando o pulo de forma satisfatória.

Figura 32 - Executando o pulo

Executando a animação de pulo Para deixar o nosso pulo mais realista devemos fazer com que a animação de

pulo seja tocada toda vez que o jogador não estiver com o GameObject “posicao dos

pes” em contato com a camada chão. Iremos utilizar como base a propriedade

estaNoChao da classe ControlaPersonagem.

Dentro da Unity acesse a janela Animator e vamos criar um novo parâmetro do

tipo Bool. Nomeie esse parâmetro de estaNoChao.

Em seguida iremos fazer as transições entre as animações:

• Parado → Pulando

• Pulando → Parado

• Correndo → Pulando

Figura 34 - Transições para a animação "Pulando"

Não se esqueça de remover a transição automática entre as animações e o

“delay” na troca entre elas. Selecione a seta que indica a transição e faça os seguintes

ajustes em todas as transições para a animação “Pulando”.

• Desmarque a opção Has Exit Time;

• Desmarque a opção Fixed Duration;

• Altere o valor da opção Transition Duration para ZERO.

A troca do estado de “Parado” para “Pulando” deverá ser efetuada sempre que

o valor do parâmetro estaNoChao for false, ou seja, quando os pés do personagem não

estiverem em contato com o chão.

Quando o valor de estaNoChao for true ocorrerá a troca de estado no sentido

contrário. O mesmo raciocínio será aplicado na troca de estados de Correndo para

Pulando.

Figura 33 - Criando um parâmetro booleano para controlar a transição da animação “Pulando”

Com a transição entre as animações e os parâmetros definidos corretamente,

vamos adicionar dentro do método Update da classe ControlaPersonagem uma

chamada ao método SetBool da classe Animator que será o responsável por executar o

gerenciamento da animação de “Pulando”.

/*Continua a classe ControlaPersonagem acima*/ private void Update() { anim.SetFloat("velocidade", Mathf.Abs(rb.velocity.x)); anim.SetBool("estaNoChao", estaNochao); Pular(); }

/*Continua a classe ControlaPersonagem abaixo*/

Ao entrarmos no modo Play, podemos ver a animação de pulo funcionando

corretamente.

Eliminando o bug da parede (Physics Materials 2D) O nosso jogo possui um pequeno bug quando o personagem encosta em alguma

parede ou objeto. Para podermos visualizar essa situação duplique a plataforma e a

redimensione como a imagem a seguir:

Figura 38 - Duplicando a plataforma

Figura 36 – Condição de troca de Parado para Pulando Figura 35 - Condição de troca de Pulando para Parado

Figura 37 - Condição de troca de Correndo para Pulando

Entre no modo Play e execute um pulo perto do grau formado entre as

plataformas e continue segurando as setas de movimento no teclado. Podemos reparar

que enquanto as setas estão pressionadas o personagem fica preso como se estive

“travado”.

Figura 39 - personagem travado na plataforma

Podemos corrigir esse efeito indesejado aplicando um material especial a

superfície da plataforma. Na Unity podemos alterar o comportamento de uma superfície

utilizando um objeto do tipo Physics Material 2D. Para criarmos um objeto desse tipo

clique com o botão direito dentro do painel Project em seguida selecione CREATE >>

PHYSICS MATERIAL 2D.

Figura 40 - Criando um objeto do tipo Physics Material 2D

Nomeie esse material para “escorregadio” e o coloque dentro de uma pasta

chamada “superfícies”.

Figura 41 - O material escorregadio

Quando se trata de um Physics Material 2D na Unity, existem apenas dois

parâmetros a serem levados em consideração:

• Friction: indica a quantidade de atrito; quanto menos atrito, mais escorregadio

é o material.

• Bounciness: Indica quanta energia o material devolve quando algo atinge o

material.

Para tornar o nosso material escorregadio e assim evitar que o nosso

personagem fique grudado nas paredes altere o valor da propriedade Friction para

ZERO.

Figura 42 - Tornando o material escorregadio

Para aplicarmos um material desse tipo a uma superfície ou a um GameObject

devemos associá-lo diretamente a propriedade Material do seu componente Collider

(no caso da plataforma um Box Collider).

Figura 43 - Associando o material escorregadio a plataforma

Não esqueça de aplicar o material a todos os GameObjects do seu jogo que

necessitem desse efeito.