0:00:00.470,0:00:02.445
Nesta lição iremos abordar

0:00:02.445,0:00:05.542
alguns dos usos mais comuns da classe Animator.

0:00:06.097,0:00:09.100
Para uma documentação completa da classe Animator

0:00:09.100,0:00:11.519
veja o link da documentação abaixo.

0:00:12.723,0:00:15.295
De modo a afetar as transições entre os estados

0:00:15.295,0:00:17.781
de um animator controller nos precisamos configurar[br]

0:00:17.781,0:00:20.393
os parâmetros do Animator para valores apropriados.

0:00:20.875,0:00:23.192
Para fazer isso, precisamos usar algumas

0:00:23.192,0:00:25.468
funções da classe Animator.

0:00:26.396,0:00:29.871
Aqui nós temos uma cena com o modelo de Ethan.[br]

0:00:30.495,0:00:32.635
Ethan tem um animator component

0:00:32.635,0:00:35.920
e um script chamado Ethan Script adcionado.

0:00:36.959,0:00:39.373
O componente animator esta usando um

0:00:39.373,0:00:41.373
controller chamado EthanController.

0:00:41.873,0:00:43.873
Se abrirmos EthanController

0:00:43.873,0:00:46.277
podemos ver que existem 4 estados.

0:00:46.277,0:00:49.586
Idle, Walk, Run e Jump.

0:00:50.625,0:00:53.281
Além disso, existem dois parâmetros.

0:00:53.281,0:00:55.225
Um flutuador chamado velocidade e um

0:00:55.225,0:00:57.225
trigger chamado Jump.

0:00:57.960,0:01:00.435
O controlador é configurado para

0:01:00.435,0:01:03.153
Ethan fazer uma transição de Idle para Walk

0:01:03.153,0:01:05.978
e Run executar com base na velocidade.

0:01:06.647,0:01:09.626
Além disso, se o parâmetro Jump for habilitado

0:01:09.626,0:01:12.226
quando Ethan estiver correndo Ethan vai entrar

0:01:12.226,0:01:13.837
em um estado Jump

0:01:15.071,0:01:17.293
Todas as animações do modelo Ethan

0:01:17.293,0:01:19.473
são controlados por estes dois parâmetros,

0:01:19.473,0:01:21.110
que vamos aprender a controlar

0:01:21.110,0:01:23.110
com nosso script de Ethan.

0:01:24.397,0:01:27.419
Dentro do Ethan Script primeiro nos temos que criar

0:01:27.419,0:01:30.357
uma variável animator chamada anim

0:01:30.357,0:01:32.550
para conter o nosso objeto animator.

0:01:33.327,0:01:35.957
Nós teremos uma referência a este objeto animator

0:01:35.957,0:01:38.624
no método start escrevendo

0:01:38.624,0:01:42.805
anim = getComponent <Animator>

0:01:43.719,0:01:47.007
Para obter mais detalhes sobre a função getComponent

0:01:47.007,0:01:49.007
veja a lição no link abaixo.

0:01:49.977,0:01:52.214
O nosso animator controller está configurado

0:01:52.214,0:01:54.409
para que o parametro speed diga

0:01:54.409,0:01:57.035
que a animação de movimento está reproduzindo.

0:01:57.682,0:01:59.682
Podemos usar o input do jogador

0:01:59.682,0:02:01.319
para controlar este comportamento.[br]

0:02:02.182,0:02:04.100
A primeira coisa que precisamos fazer é

0:02:04.100,0:02:06.597
criar uma variável float chamada Move

0:02:06.597,0:02:08.154
no método update

0:02:09.636,0:02:12.165
Depois, vamos definir a variável Move

0:02:12.165,0:02:14.500
para ser igual ao eixo vertical de entrada

0:02:14.500,0:02:17.645
escrevendo Input.GetAxis

0:02:17.645,0:02:21.347
e entre parênteses nós vamos passar a string Vertical.

0:02:22.496,0:02:24.496
O que se segue é que queremos passar

0:02:24.496,0:02:26.496
o valor da variável Move ao

0:02:26.496,0:02:29.402
atributo Speed do animator controller.

0:02:30.164,0:02:32.788
Isto é feito com a função setFloat

0:02:32.788,0:02:34.788
da classe Animator.

0:02:35.661,0:02:38.381
Estamos usando setFloat ja que Speed

0:02:38.381,0:02:40.381
É um parâmetro float.

0:02:40.381,0:02:42.381
Se tivesse dado um parâmetro Booleano

0:02:42.381,0:02:44.381
se tivéssemos usado SetBool.

0:02:44.381,0:02:46.784
Se tivesse sido um parâmetro trigger tinhamos

0:02:46.784,0:02:49.443
utilizado SetTrigger e assim

0:02:50.513,0:02:52.375
Para cada uma destas funções

0:02:52.375,0:02:54.375
várias maneiras que podem ser chamados.

0:02:54.875,0:02:56.875
A forma mais comum é primeiro passar

0:02:56.875,0:02:59.000
o nome do parâmetro que está ajustando

0:02:59.000,0:03:00.630
como uma string.

0:03:00.630,0:03:02.781
Em seguida, o próximo elemento é o valor

0:03:02.781,0:03:04.781
que você deseja que o parámetro seja.

0:03:05.640,0:03:08.125
Neste caso, vamos chamar o

0:03:08.125,0:03:11.117
método SetFloat de nossa variável animator, digitando

0:03:11.117,0:03:13.117
anim.SetFloat[br]

0:03:13.617,0:03:16.735
e, em seguida, em parênteses a string Speed

0:03:16.735,0:03:18.735
e nossa variável Move.

0:03:19.622,0:03:22.400
Devolta ao Unity podemos executar nossa cena.

0:03:22.400,0:03:24.400
Podemos ver que, se pressionar a tecla W

0:03:24.400,0:03:27.594
ou a seta para cima, o nosso modelo agora se move.[br]

0:03:27.594,0:03:29.594
O parâmetro Speed e a animação de

0:03:29.594,0:03:33.249
movimento reproduzido agora é controlado pelo jogador.

0:03:34.343,0:03:35.942
Passe um nome string

0:03:35.942,0:03:38.479
para o parâmetro que desejamos pode ser ineficiente

0:03:38.479,0:03:40.410
já que significa que o animator precisa

0:03:40.410,0:03:43.203
avaliar a string de cada vez que é chamado.

0:03:43.725,0:03:45.725
A maneira mais rápida para definir os valores dos parâmetros

0:03:45.725,0:03:47.725
é utilizar hashIDs.

0:03:48.225,0:03:50.225
Cada string que o animator pode usar é

0:03:50.225,0:03:52.057
dado em um hashID.

0:03:52.057,0:03:54.197
Este é um valor inteiro que é único

0:03:54.197,0:03:55.737
para cada string diferente.

0:03:56.237,0:03:58.237
Podemos armazenar este valor e, em seguida,

0:03:58.237,0:04:00.811
definir os parâmetros usando esta ID em seu lugar.

0:04:01.621,0:04:03.760
Para fazer isso, primeiro precisamos

0:04:03.760,0:04:05.525
armazenar o valor.

0:04:05.525,0:04:08.656
vamos criar uma variável inteira chamada jumphash

0:04:08.656,0:04:10.656
para armazenar o Hashid.

0:04:11.198,0:04:13.198
Obtemos o valor para a nossa variável de hash

0:04:13.198,0:04:16.208
chamando o método estático do animator class

0:04:16.208,0:04:18.208
string to hash.

0:04:18.208,0:04:21.019
Como esse método é estático, podemos acessá-lo

0:04:21.019,0:04:25.358
escrevendo Animator.StringToHash.

0:04:26.286,0:04:28.915
Em parênteses passamos a string

0:04:28.915,0:04:31.567
que queremos saber o seu valor HashID:

0:04:32.506,0:04:34.506
A fim de fazer com que o nosso modelo salte

0:04:34.506,0:04:36.870
precisamos definir o parâmetro de Jump

0:04:36.870,0:04:38.870
do tipo trigger no animator controller.

0:04:39.370,0:04:41.871
No nosso caso, queremos fazer que o modelo salte[br]

0:04:41.871,0:04:43.871
quando a barra de espaço é pressionado.

0:04:44.371,0:04:46.123
Então começamos escrevendo

0:04:46.123,0:04:51.302
if Input.GetKeyDown e, em seguida, entre parênteses

0:04:51.302,0:04:54.736
usaremos KeyCode.Space.

0:04:55.775,0:04:58.135
Dentro da nossa declaração if nós

0:04:58.135,0:05:00.774
estabeleceremos o parâmetro Jump do tipo trigger usando

0:05:00.774,0:05:03.257
o método anim.SetTrigger.

0:05:03.923,0:05:05.923
Dentro de parênteses e vamos ao

0:05:05.923,0:05:07.923
jumpHash passar nossa variável.

0:05:09.017,0:05:11.017
Lembre-se que esta variável contém o

0:05:11.017,0:05:13.768
hasID do nosso parâmetro Jump.

0:05:14.567,0:05:16.774
Note que Jump é um trigger

0:05:16.774,0:05:19.213
não temos de também passar esse valor.

0:05:20.351,0:05:22.893
Devolta ao Unity podemos executar nossa cena.

0:05:23.666,0:05:26.209
Note que quando estamos correndo também podemos

0:05:26.209,0:05:28.209
apertar a tecla de espaço para pular

0:05:29.096,0:05:31.096
Agora nós utilizamos ambos

0:05:31.096,0:05:33.096
parâmetros Speed do tipo float e

0:05:33.096,0:05:35.716
Jump do tipo trigger para fazer que nosso modelo

0:05:35.716,0:05:36.989
seja mais dinâmico.

0:05:37.843,0:05:40.146
Ocasionalmente, quando esta se escrevendo a lógica

0:05:40.146,0:05:42.271
por trás da animação nós queremos

0:05:42.271,0:05:45.017
encontrar em que estado o controller está.

0:05:45.986,0:05:47.986
Digamos por exemplo que nós queremos ser capazes

0:05:47.986,0:05:50.153
de ativar o trigger Jump quando o modelo

0:05:50.153,0:05:52.153
estiver no estado Run.

0:05:52.653,0:05:55.495
O animator tem algumas funções que podemos chamar

0:05:55.495,0:05:57.495
para encontrar em que estado o controller

0:05:57.495,0:05:59.008
está atualmente.

0:05:59.677,0:06:01.872
Nós podemos fazer isso criando

0:06:01.872,0:06:04.243
uma variavel animator state info

0:06:04.243,0:06:06.813
que chamaremos de StateInfo.

0:06:07.641,0:06:10.045
A classe animator state info

0:06:10.045,0:06:12.443
armazena o nome, nome hash,

0:06:12.443,0:06:14.443
e varias outras peças de informação

0:06:14.443,0:06:15.839
de estado.

0:06:17.675,0:06:19.911
Nós estabelecemos nossa variavel state info

0:06:19.911,0:06:24.830
igual a função anim.GetCurrentAnimatorStateInfo.

0:06:25.703,0:06:28.838
Dentro do parêntesis nós vamos passar o indice

0:06:28.838,0:06:31.253
do layer que queremos saber mais sobre.

0:06:31.253,0:06:33.406
dado que se trata da base layer

0:06:33.406,0:06:35.406
nós vamos colocar em 0.

0:06:36.086,0:06:38.086
Novamente nós podemos comparar o nome dos

0:06:38.086,0:06:40.703
estados de maquina atuais com o string

0:06:40.703,0:06:42.425
porque ja que é mais eficiente comparar

0:06:42.425,0:06:45.019
hashIDs faremos isso melhor.

0:06:46.044,0:06:48.044
Nós começaremos criando um inteiro chamado

0:06:48.044,0:06:51.200
runStateHash e configurando a que seja igual a nossa

0:06:51.200,0:06:54.151
função Animator.StringToHash.

0:06:54.872,0:06:57.023
Nós vamos passar em parentesis

0:06:57.023,0:07:00.243
o string base layer .Run

0:07:01.434,0:07:04.212
nós temos que incluir a base layer.part

0:07:04.212,0:07:06.544
já que podemos ter estados com o mesmo nome

0:07:06.544,0:07:08.146
em diferentes layers.

0:07:08.947,0:07:11.672
Agora nós podemos modificar nossa declaração if

0:07:11.672,0:07:13.910
para tambem unicamente permitir nosso modelo saltar

0:07:13.910,0:07:17.140
si stateInfo.nameHash

0:07:17.140,0:07:21.140
é igual a nossa variável runStateHash.