WEBVTT

00:11.580 --> 00:17.770
A maneira como configuramos nosso caractere atual é usar o LookAt para virar para o local de destino,

00:17.910 --> 00:22.980
mas o problema é que ele faz com que seu personagem se encaixe instantaneamente.

00:22.980 --> 00:31.120
Em vez disso, queremos introduzir um método para que nosso personagem se volte lentamente em direção ao alvo.

00:31.260 --> 00:37.070
Para fazer isso, usaremos o intERPolation Linear Esférico ou SLERP para abreviar e o

00:37.320 --> 00:43.620
que ele faz é interpolar entre o vetor que estamos enfrentando atualmente e a direção

00:43.620 --> 00:45.790
em que queremos estar.

00:45.930 --> 00:53.010
Isso é feito durante um período de tempo específico, para que você possa girar um pouco de ângulo a cada vez

00:53.010 --> 00:55.290
até chegar à direção da meta.

00:55.290 --> 01:00.510
Vamos começar a implementar isso no Unity. Então, vamos modificar o projeto anterior com o

01:00.780 --> 01:03.300
qual terminamos dentro do script MoveLocal.

01:03.300 --> 01:12.380
A primeira coisa que precisamos é de um flutuador para a velocidade de rotação, então vamos chamá-lo de rotSpeed e defini-lo como 0. 5f.

01:12.460 --> 01:18.480
As chances são de que, assim que você começar a mover seus personagens, você não desejará que a velocidade e a

01:18.480 --> 01:20.490
velocidade de rotação sejam exatamente iguais.

01:20.610 --> 01:27.020
Portanto, ter dois valores diferentes funciona muito bem porque você pode ajustar qualquer um deles. É claro que, neste caso, eu os tenho

01:27.030 --> 01:28.520
da mesma forma.

01:28.540 --> 01:32.400
Na verdade, eu posso simplesmente diminuir para 0. 1

01:32.400 --> 01:39.660
Agora, temos um lookAtGoal, mas também precisamos calcular a direção que queremos seguir, então

01:39.660 --> 01:45.180
voltamos ao que tínhamos originalmente e combinamos esses dois.

01:45.180 --> 01:48.720
Então, queremos trabalhar na nossa direção que precisamos enfrentar.

01:48.720 --> 02:03.340
Portanto, é uma direção Vector3 e será igual ao nosso lookAtGoal menos nossa posição atual.

02:03.390 --> 02:12.360
Agora, a única outra mudança que precisamos fazer é transformar esse LookAt aqui em um slerp que usará a direção como

02:12.750 --> 02:14.070
seu rumo.

02:14.310 --> 02:18.340
Portanto, exclua a linha LookAt e substitua-a por esta.

02:18.390 --> 02:26.850
O slerp está definindo a rotação do seu personagem, portanto, estamos fazendo isso. transformar. rotação = ao invés

02:26.910 --> 02:35.220
de uma posição ou um Translate e isso. A rotação é então definida usando o

02:35.310 --> 02:44.400
método slerp que você pode encontrar na classe Quaternion. O Quaternion é uma estrutura de dados complexa que mantém uma rotação

02:45.030 --> 02:47.360
e pode fazer todo tipo

02:47.370 --> 02:52.940
de coisa fantástica, mas, neste caso, está mudando o ângulo de uma direção para outra.

02:53.130 --> 02:57.920
Portanto, o slerp em si assume a rotação atual do seu personagem.

02:58.350 --> 03:07.350
Em seguida, ele executa uma LookRotation em sua direção; portanto, a direção é o nosso vetor calculado que está apontando em

03:07.350 --> 03:13.650
direção ao nosso objetivo, mas não podemos executar o slerp no vetor de direção.

03:13.650 --> 03:18.750
Queremos fazer o slerp no ângulo pelo qual temos que girar, para chegar de onde estamos

03:18.750 --> 03:20.940
olhando atualmente para a direção específica.

03:20.940 --> 03:23.400
Então este Quaternion. LookRotation

03:23.400 --> 03:33.420
nos dará a rotação que precisa ocorrer para estar na 'direção' e, assim, combinando esses dois e

03:33.420 --> 03:36.130
comparando-os pouco a pouco, então

03:36.180 --> 03:39.970
lentamente passamos de um para o outro.

03:39.990 --> 03:46.650
Agora, a taxa em que giramos é o terceiro valor que você coloca dentro desse método e

03:46.650 --> 03:54.210
o baseamos no mesmo tipo de velocidade que usamos para mover um personagem para a frente, onde deltaTime é

03:54.210 --> 03:57.120
multiplicado pelo tempo de rotação .

03:57.120 --> 03:57.300
Certo.

03:57.300 --> 04:03.210
Então, vamos salvar isso, entrar no Unity e ver como isso funciona. Certifique-se de que seu personagem esteja voltado

04:03.210 --> 04:11.420
para longe do objetivo, para que você possa ver a virada ocorrendo. Então pressione Play e o personagem continuará avançando ao longo de

04:11.750 --> 04:17.020
seu vetor de avanço, que é o que queremos e, ao mesmo tempo, esse

04:17.210 --> 04:22.700
slerp está operando para mudar seu personagem e você pode ver aqui na cena que

04:22.700 --> 04:26.130
ele está começando. arco ao redor para lá.

04:26.140 --> 04:30.780
Agora está um pouco lenta, essa velocidade de rotação, então vamos parar com isso.

04:30.950 --> 04:31.950
Volte para

04:31.970 --> 04:33.710
o nosso MoveLocal e aumente-o.

04:33.710 --> 04:40.940
Então, se colocarmos isso para dizer 4 e salvá-lo e executá-lo novamente.

04:44.130 --> 04:53.280
Descobrimos que o personagem gira muito mais nitidamente e agora podemos dirigir nosso cubo e

04:53.280 --> 04:56.690
o personagem girará e seguirá.

04:56.730 --> 05:02.700
Então é assim que você move seu personagem para a frente e executa

05:02.700 --> 05:04.140
um slerp

05:04.350 --> 05:12.420
para colocar seu personagem na direção certa e apenas nesses poucos vídeos, abordamos praticamente todos os princípios essenciais

05:12.420 --> 05:18.160
de que você precisará para obter alguns comportamento complexo acontecendo nos NPCs.
