WEBVTT

00:11.790 --> 00:18.090
Esta palestra se estende à última palestra, agora movendo nossos personagens em direção a uma

00:18.090 --> 00:23.050
meta, onde eles irão parar. Para fazer isso, você precisará de um local de objetivo.

00:23.050 --> 00:30.640
Criei um cubo simples clicando com o botão direito do mouse em Objeto 3D> Cubo e posicionando-o em algum lugar

00:30.640 --> 00:31.760
do ambiente.

00:32.050 --> 00:36.970
Vamos fazer com que um dos personagens avance em direção à meta, para começar.

00:36.970 --> 00:43.780
Portanto, selecione os personagens que estão em cena e remova o script que já está

00:43.960 --> 00:45.640
anexado a eles.

00:45.640 --> 00:49.540
Agora vamos criar um novo arquivo C # chamado MoveToGoal.

00:49.570 --> 00:53.380
É um pouco diferente do código Move que escrevemos

00:53.710 --> 01:02.320
antes, mas ainda precisamos calcular com vetores e, no início, adicionamos um float para velocidade e defini esse valor como

01:02.350 --> 01:04.170
1. 0

01:04.290 --> 01:09.120
Na verdade, eu posso configurar isso para 2, para que as coisas corram um pouco mais rápido dessa vez.

01:09.340 --> 01:13.490
Então eu tenho uma transformação exposta pública chamada 'goal' que

01:13.490 --> 01:20.520
agora está mudando em relação ao código anterior. Antes, tínhamos objetivo como vetor.

01:20.710 --> 01:30.430
Agora é uma posição no meio ambiente. Dentro do LateUpdate, precisamos calcular a direção.

01:30.430 --> 01:38.230
Este é o vetor entre a posição do objetivo e a posição do personagem. Para fazer isso, simplesmente subimos para

01:38.230 --> 01:41.350
onde estamos indo (para

01:41.350 --> 01:47.050
a posição da meta) menos para onde estamos atualmente.

01:47.590 --> 01:52.150
Então este é 'para onde estamos indo' e é para 'onde estamos'.

01:52.240 --> 01:53.790
Tem que estar nessa ordem.

01:53.830 --> 01:58.930
Se você trocá-los para o outro lado, seu vetor estará voltado para a

01:58.960 --> 02:03.340
direção oposta e seu personagem seguirá o mesmo vetor ...

02:03.380 --> 02:06.580
ou pelo menos ao longo do mesmo tipo de linha em direção ao seu

02:06.710 --> 02:08.890
alvo, mas ele estará viajando na direção oposta.

02:09.020 --> 02:14.940
Se você conseguir que isso aconteça, você sabe que tem essas duas coisas pelo caminho errado.

02:15.020 --> 02:21.710
Depois de calcular o novo vetor para viajar, você novamente usa o seu Translate e coloca o seu vetor

02:21.710 --> 02:23.740
calculado dentro, multiplica pela velocidade

02:23.810 --> 02:27.080
e multiplica pelo tempo. deltaTime.

02:27.080 --> 02:29.680
Então, ainda estamos viajando ao longo de um

02:29.720 --> 02:31.840
vetor, mas desta vez o calculamos.

02:31.910 --> 02:34.880
Então salve isso, volte para o Unity.

02:34.880 --> 02:41.870
Agora você vai querer pegar um de seus personagens e arrastar e soltar esse script do projeto para eles.

02:41.930 --> 02:48.350
Aqui você pode ver que eu tenho o script MoveToGoal anexado e eu configurei a velocidade para 2 (bem, o código fez

02:48.350 --> 02:49.240
assim mesmo).

02:49.340 --> 02:54.380
Segure seu cubo e arraste-o e solte-o como a posição do objetivo.

02:54.380 --> 02:57.860
Agora pressione Play e veja o que acontece.

02:58.100 --> 03:04.190
Assim, seu personagem calculou a direção que ele precisa seguir e chegará ao local do

03:05.090 --> 03:06.440
objetivo e então

03:06.950 --> 03:14.840
meio que para de se mover, mas está tremendo. O motivo é que você ainda está dentro desse loop de atualização, solicitando

03:14.840 --> 03:18.100
que calcule a direção do objetivo e avance para ele.

03:19.120 --> 03:28.180
Agora, na maioria dos casos, você não encontrará o seu personagem no local exato do seu objetivo

03:28.180 --> 03:34.650
e, portanto, precisará incluir algum tipo de cálculo 'o suficiente o suficiente'.

03:35.490 --> 03:37.730
Antes de fazer isso, quero lhe mostrar uma coisa.

03:37.750 --> 03:45.000
Se movermos nosso personagem para cá agora e pressionar Play, ele calculará um novo vetor para o objetivo e avançará

03:45.000 --> 03:46.890
em direção ao objetivo.

03:46.890 --> 03:51.410
Agora, para interromper a oscilação que ocorre quando eles atingem a meta, volte

03:51.780 --> 03:57.220
para o código e queremos colocar algo na atualização aqui para testar se alcançamos nossa meta.

03:57.270 --> 04:03.900
Se atingimos nosso objetivo, não queremos continuar calculando o vetor e movendo-se em direção

04:03.900 --> 04:04.980
a ele.

04:05.010 --> 04:12.880
Então você pode fazer isso testando o comprimento da direção. Você já calculou esse vetor e consegue se lembrar como é

04:13.050 --> 04:17.940
chamado o comprimento de um vetor? É a magnitude.

04:17.940 --> 04:30.560
Então podemos dizer 'se (direção. magnitude> 5), em seguida, vá em direção

04:30.770 --> 04:32.820
à meta.

04:32.960 --> 04:36.170
Então salve isso e vamos dar uma olhada.

04:36.170 --> 04:42.160
Assim, toda vez que o loop e a direção são calculados, cada vez mais

04:42.170 --> 04:48.930
curto, o próprio vetor. Ele não permanece definido para o vetor original. Mesmo que ainda esteja

04:49.220 --> 04:51.510
na mesma direção, será mais curto.

04:52.480 --> 04:54.330
Então agora você pode ver que ele se moveu.

04:54.340 --> 05:00.400
mas não muito longe, e isso ocorre porque uma distância de 5 é

05:00.400 --> 05:06.640
mais ou menos nessa distância, porque esses são pequenos personagens e você deve verificar

05:06.910 --> 05:11.240
a escala que está acontecendo no seu mundo.

05:11.350 --> 05:18.240
Então, vamos voltar aqui e vamos fazer este 1 e executá-lo novamente.

05:23.540 --> 05:29.770
Ok, então isso deve estar a uma distância de 1 do cubo e se clicarmos no cubo e dermos uma olhada no que eu criei, você

05:29.770 --> 05:33.320
poderá ver que a escala é 0. 2)

05:33.400 --> 05:37.000
Isso torna esse cubo (em termos

05:37.000 --> 05:45.840
mundiais) com cerca de 20 cm de diâmetro. Quando um cubo está no tamanho 1, que é o tamanho padrão,

05:45.840 --> 05:48.850
isso seria 1m x 1m x 1m

05:48.850 --> 05:55.570
no mundo do Unity e, portanto, você pode imaginar que 5 desses cubos se encaixariam nesse espaço lá,

05:55.570 --> 05:58.670
a uma distância de 5 a partir de antes.

05:58.690 --> 06:04.270
Agora você pode ver que um ainda é muito grande, se você quiser que seu personagem esteja no topo da localização

06:04.270 --> 06:05.020
do objetivo.

06:05.020 --> 06:11.470
Então, vamos tentar mais uma vez com um valor menor. Volte para o MoveToGoal e mudaremos

06:11.470 --> 06:14.100
para 0. 2f.

06:14.240 --> 06:17.510
Salve isso e execute-o novamente e o

06:18.040 --> 06:22.120
personagem deve estar muito próximo do alvo neste caso,

06:22.180 --> 06:27.080
e você pode ver que ele é, então isso é bastante aceitável.

06:27.220 --> 06:34.510
Vou mover esse valor de 0. Suba no topo, então vamos fazer essa 'precisão de flutuação pública' porque é a precisão

06:34.840 --> 06:40.540
que estamos dispostos a levar até perto de uma meta. Vamos configurá-lo para

06:40.540 --> 06:42.930
0. 01f.

06:43.120 --> 06:45.790
Então, vamos chegar bem perto e, aqui

06:45.790 --> 06:49.730
embaixo, colocaremos precisão ... Curtiu isso.

06:49.930 --> 06:56.710
Tudo bem, então salve isso e vamos voltar e executá-lo e ver se isso faz alguma diferença

06:56.710 --> 06:58.780
com a precisão muito apertada.

06:59.540 --> 07:01.060
Isso é muito bom.

07:01.280 --> 07:07.510
O que eu quero lhe mostrar é algo que fará com que seu personagem ainda tremer com esse

07:07.510 --> 07:08.560
código em particular.

07:08.980 --> 07:15.500
Vamos mudar a velocidade para cinco com essa precisão muito apertada e vamos executá-la novamente Ok,

07:18.940 --> 07:23.820
então o personagem tremeu antes de finalmente chegar a essa precisão.

07:24.020 --> 07:30.680
O que está acontecendo aqui é que ele atingiu a meta, ultrapassou a marca, recalcula a direção

07:30.680 --> 07:40.110
de volta em direção à meta, ultrapassa a marca e acaba saltando assim, porque sua velocidade de 5 pontos aqui está empurrando a meta

07:40.110 --> 07:44.760
e depois empurrando de volta ao objetivo e empurrando-o sobre o

07:44.760 --> 07:46.210
objetivo assim também.

07:46.440 --> 07:53.100
Nesse caso, tivemos sorte em que, eventualmente, ele se moveu para uma posição em que pudesse chegar dentro dessa

07:53.100 --> 07:53.690
precisão,

07:53.700 --> 07:58.770
mas às vezes você não entra nessa precisão e você tem um comportamento realmente

07:58.800 --> 08:03.310
estranho acontecendo até o personagem dançando por aí o ponto do gol.

08:03.420 --> 08:07.470
Isso porque nunca está chegando lá dentro de sua precisão.

08:07.470 --> 08:13.440
Portanto, se você conseguir isso, brinque com seus valores de precisão até que você os levante alto o

08:13.440 --> 08:19.170
suficiente para impedir que isso aconteça; caso contrário, você terá que reduzir a velocidade com que

08:19.380 --> 08:21.920
eles estão atacando sua posição de gol.

08:22.290 --> 08:25.360
Vou colocar essa precisão de volta em 1 para este e

08:25.380 --> 08:27.310
depois para o outro personagem ...

08:27.360 --> 08:32.130
vamos colocar o mesmo código nele e deixá-lo com a velocidade padrão, mas

08:32.130 --> 08:37.680
vamos definir a precisão como 0. 1 em vez de 1.

08:37.740 --> 08:43.350
Também precisamos definir o cubo no local do gol para esse cara aqui e agora, se você

08:43.650 --> 08:50.450
pressionar Play, eles irão para a posição do gol. Como estamos trabalhando atualmente, eles deslizarão da posição atual

08:50.450 --> 08:55.460
para a posição do gol, mas não se virarão e enfrentarão a direção em

08:55.460 --> 08:57.410
que estão viajando e isso

08:57.410 --> 09:01.060
seria uma boa adição para um personagem fazer isso .

09:01.960 --> 09:10.150
Antigamente, tínhamos que calcular os ângulos entre os vetores e de que lado estavam os

09:10.150 --> 09:16.000
vetores, em relação aos outros vetores, para descobrir como mudar seu

09:16.000 --> 09:16.790
personagem.

09:17.020 --> 09:20.810
Agora, temos essa excelente função chamada LookAt that Unity,

09:20.830 --> 09:26.590
que faz todo esse trabalho duro para nós e vou colocá-la na função Start, para que

09:26.590 --> 09:30.480
nosso personagem primeiro se vire e veja para onde está indo.

09:30.670 --> 09:37.710
Esse método ou função é chamado LookAt e você o adiciona ao final da transformação e, em seguida, fornece

09:37.710 --> 09:44.080
a posição do objetivo que você deseja que seu personagem olhe, e ele se moverá e

09:44.080 --> 09:45.360
olhará nessa direção.

09:45.370 --> 09:54.190
Agora, neste momento, se eu executá-lo, porque alteramos a orientação do caractere que o Translate não funcionará corretamente, salvaremos isso

09:54.700 --> 10:00.610
e voltaremos e daremos uma rápida olhada no que você recebe e eu

10:00.610 --> 10:03.010
' Vou mostrar como consertar.

10:03.010 --> 10:09.070
Então, nós entendemos isso e você pode ver que os personagens tendem a se inclinar em

10:09.070 --> 10:14.990
direção a ele, e esse personagem vai girar em espiral até chegar perto o suficiente.

10:15.040 --> 10:23.560
O que está acontecendo é que agora que esses caracteres não estão mais girando

10:23.560 --> 10:26.280
(0,0,0) aqui na transformação.

10:26.290 --> 10:31.600
Se você acompanhou e mudou a rotação de seus personagens, provavelmente não conseguiu descobrir o que

10:31.600 --> 10:33.450
estava errado com seu código,

10:33.460 --> 10:35.560
e esse é o problema exato.

10:35.560 --> 10:42.340
Portanto, no seu MoveToGoal, o que você deseja fazer no seu Translate é 'traduzir'

10:42.370 --> 10:49.360
seu personagem ao longo desse vetor no 'espaço do mundo', em oposição ao 'espaço local'.

10:49.360 --> 10:56.890
Agora, se você salvar isso e correr, verá que seus personagens se voltam para o objetivo deles e

10:57.370 --> 11:03.070
depois viajam em direção a ele. Na cena, tenho essas linhas vermelhas que você teria visto e

11:03.100 --> 11:08.280
estão desenhando os vetores do código com um Debug. DrawRay, que desenha um raio

11:08.410 --> 11:14.300
da posição em uma direção específica e, em seguida, você dá uma cor.

11:14.320 --> 11:17.370
Isso é realmente útil para depuração para ver o que está acontecendo.

11:17.380 --> 11:24.730
Então, acabei de incluir isso, para que você possa usá-lo em seu próprio código para ver quais vetores estão fazendo o que

11:24.730 --> 11:26.770
e para que lado estão apontando.

11:26.770 --> 11:29.810
Tudo bem, então essa é a maneira mais fácil de fazer um LookAt.

11:30.010 --> 11:37.210
Você deve ter notado que, neste momento, se o rodarmos novamente e você agarrar o cubo e na

11:37.210 --> 11:43.570
cena em que você o mover, os personagens responderão à sua localização naturalmente, por causa do

11:43.570 --> 11:45.460
que está nessa atualização.

11:45.490 --> 11:50.590
Observe que o LookAt não está atualizando e é porque ainda está na função Iniciar.

11:50.590 --> 11:59.380
Portanto, se alterarmos esse LookAt aqui e garantirmos que o recalculemos toda vez em nossa Atualização, os personagens sempre estarão

12:00.010 --> 12:08.830
olhando para aquele cubo e, em seguida, o que você poderia fazer é obter um script de condução para poder

12:08.860 --> 12:16.620
conduzir esse cubo com o teclas de seta e os caracteres se moveriam onde quer que fosse.
