WEBVTT

00:13.230 --> 00:19.210
Nesta palestra, gostaria que você acompanhasse enquanto examinamos o movimento ao longo de uma linha reta usando vetores.

00:19.270 --> 00:25.480
Faça o download do projeto de recursos que acompanha esta palestra. Lá você encontrará um personagem / homem e,

00:25.660 --> 00:32.200
além disso, está sendo adicionado um script Move e é o script Move em que vamos trabalhar.

00:32.200 --> 00:34.670
Então abra isso e dê uma olhada aqui.

00:34.870 --> 00:39.020
Você pode ver no script que existe um Vector3 que é uma meta.

00:39.340 --> 00:47.170
Portanto, o Vector3 é uma versão 3D do nosso vetor que tem um x, ye z, e estamos inicialmente configurando esse vetor para 5

00:47.170 --> 00:55.120
na direção x, 0 na direção y e 4 na direção z. Como esse é um personagem humanóide em uma

00:55.120 --> 00:58.060
superfície plana, quando o movemos,

00:58.060 --> 01:04.960
não adicionamos nenhum 'y' porque você não quer que ele suba e flutue no

01:05.050 --> 01:05.660
ar.

01:05.950 --> 01:09.940
Se fosse um avião ou algo que voasse, seria completamente diferente.

01:09.940 --> 01:13.290
Observe também que não há nenhuma física envolvida neste projeto.

01:13.300 --> 01:19.710
Estamos movendo esse caractere puramente usando nosso próprio código e é para que possamos manter o controle dele.

01:19.780 --> 01:28.130
Agora, na função Iniciar, estamos adicionando nosso Vector3 à posição atual de nosso personagem.

01:28.330 --> 01:32.160
Então, aqui temos uma transformação e estamos executando um Translate.

01:32.170 --> 01:39.190
O que isso faz é adicionar o 'vetor objetivo' ao 'vetor de transformação'. Com isso salvo, volte ao Unity

01:39.190 --> 01:41.020
e pressione Play.

01:41.350 --> 01:47.710
E o que você verá é seu personagem pular 'essa distância' ao longo desse vetor. Por estar na função Iniciar, está adicionando

01:47.710 --> 01:48.630
todo

01:48.630 --> 01:54.960
o lote de uma só vez e movendo seu personagem para esse objetivo.

01:54.970 --> 01:56.780
Agora isso não

01:56.800 --> 02:03.490
vai funcionar se você quiser mover o personagem pouco a pouco na atualização e

02:03.490 --> 02:11.140
parecer que está se movendo. Então pare de jogar. Vamos voltar para o Move e dar uma olhada

02:11.200 --> 02:13.540
em mover este Translate para baixo na Atualização.

02:13.540 --> 02:19.590
Livre-se do primeiro e salve-o, volte para o Unity e pressione Play.

02:21.280 --> 02:26.470
E o que você notará é que o personagem desaparece completamente, mas se você selecionar o

02:26.950 --> 02:33.010
Homem na Hierarquia, dê uma olhada na transformação e a posição nos x e z estão subindo e subindo

02:33.010 --> 02:38.500
e subindo e isso é porque todo esse vetor está sendo adicionado sempre que uma atualização ocorre.

02:38.500 --> 02:44.500
Então ele está se movendo, ele está pulando muito e se afastando cada vez mais, para

02:44.500 --> 02:48.210
que não possamos vê-lo. Então vamos parar com isso.

02:48.220 --> 02:56.500
O que queremos, em vez de pular para a posição de meta, é avançar pequenos passos por aqui,

02:56.500 --> 02:59.470
exatamente na mesma direção desse vetor.

02:59.710 --> 03:07.750
Portanto, para obter uma versão menor do vetor, você pode dividir o vetor maior por um número que dará algo menor.

03:07.750 --> 03:15.890
Então, se voltarmos para o Move e no Start,

03:15.890 --> 03:28.760
vamos para goal = goal * 0. 5f; e isso vai reduzir pela metade o tamanho da meta.

03:29.090 --> 03:32.450
Então agora ele deve se mover na mesma

03:32.450 --> 03:38.930
direção, mas você deve vê-lo parar no meio do caminho e pular para o local do gol.

03:38.930 --> 03:45.560
Mas depois disso ele continuará pedalando e adicionando a meta. Salve isso, volte para o Unity, pressione Play.

03:49.270 --> 03:55.030
Você provavelmente o viu pular um pouco lá e foi ele se movendo nessas etapas, ainda um grande salto, mas apenas

03:55.060 --> 03:57.040
metade do vetor de cada vez.

03:57.040 --> 03:58.890
Então, vamos voltar para o Move.

03:59.050 --> 04:07.340
O que acontece se multiplicarmos por 0. 01, obtemos 10% desse vetor.

04:07.450 --> 04:13.390
Qualquer coisa que você multiplicar ou dividir no vetor ainda estará exatamente na mesma direção em que

04:13.390 --> 04:15.530
você deseja que seu personagem vá.

04:15.760 --> 04:18.280
Então, vamos jogar este, dê uma olhada.

04:20.540 --> 04:25.330
Isso é muito mais suave no movimento e ele está se movendo em direção ao local do gol.

04:25.340 --> 04:29.900
Agora, a localização do objetivo em si não era uma posição no espaço.

04:30.050 --> 04:32.090
Foi uma "direção do gol".

04:32.210 --> 04:38.170
Portanto, há uma diferença entre um ponto e um vetor. Um ponto é um ponto fixo em algum lugar do seu mundo.

04:38.860 --> 04:46.470
Um vetor é apenas um conjunto de instruções de qual direção se mover, de qualquer local do mundo.

04:46.480 --> 04:53.260
Portanto, seu personagem agora está em algum lugar, se você clicar nele, ainda se movendo a 10% do

04:53.260 --> 04:54.820
'objetivo' de cada vez.

04:54.820 --> 05:01.620
Agora, se simplesmente multiplicarmos "nosso vetor, queremos que nosso personagem se mova" por um número

05:01.660 --> 05:07.870
pequeno, sempre que esse vetor mudar, isso afetará a velocidade de nossos caracteres.

05:07.870 --> 05:13.840
Ele não estará se movendo a uma velocidade constante e podemos ilustrar isso adicionando outro personagem.

05:13.840 --> 05:23.110
Então, antes de tudo, tornemos público nosso objetivo de vetor, para que possamos alterá-lo, e ainda o

05:23.170 --> 05:27.300
multiplicaremos por 0. 01 e traduza ao longo disso.

05:27.490 --> 05:28.970
Então apenas salve isso.

05:29.020 --> 05:41.430
Agora, se voltarmos para a Unity, faça com que o Homem e apenas Ctrl-D dupliquem e depois o movam para fora e tentem colocá-lo nessa

05:41.430 --> 05:46.950
direção, queremos que eles se movam paralelos um ao outro.

05:46.950 --> 05:48.760
Então, eu só quero colocá-lo lá.

05:48.930 --> 05:54.740
Mas para esse cara, seu objetivo de movimento, vamos multiplicá-lo por 2.

05:54.740 --> 05:57.010
Portanto, é duas vezes mais longe.

05:57.060 --> 05:59.940
Está aqui em algum lugar.

06:00.120 --> 06:05.800
Então, vamos fazer 10, 0 e

06:06.270 --> 06:07.460
8.

06:07.530 --> 06:15.580
Então agora, quando executamos, veremos velocidades diferentes. veja como esse cara está indo muito mais rápido,

06:15.580 --> 06:21.820
porque 10% desse vetor mais longo será um salto maior que 10% do menor.

06:21.820 --> 06:29.380
Portanto, eles não estão em uma velocidade uniforme e isso tornará o movimento do seu personagem inconsistente quando

06:29.410 --> 06:34.530
eles estiverem se movendo ao longo de diferentes vetores de comprimento.

06:34.660 --> 06:37.830
Portanto, a questão é como podemos obter

06:38.110 --> 06:45.810
um vetor de tamanho padrão, que aponte na mesma direção ao longo do vetor em que estamos viajando.

06:45.970 --> 06:55.690
A solução é obter sua versão 'Normalizada'. A versão normalizada de qualquer vetor é um

06:55.690 --> 07:04.120
vetor com 1 comprimento e é possível encontrar a versão normalizada de um vetor dividindo cada

07:04.130 --> 07:09.520
um dos valores x, ye z do vetor pela magnitude.

07:09.520 --> 07:12.530
Agora você também pode obter o Unity para fazer isso por você.

07:12.730 --> 07:21.160
Vamos voltar ao movimento e, em vez de ter nosso objetivo aqui,

07:21.160 --> 07:28.270
estamos avançando multiplicado por 0. 01 apenas para torná-lo muito menor, queremos torná-lo em um tamanho padrão.

07:28.270 --> 07:30.750
Então, vamos nos livrar disso completamente e

07:31.150 --> 07:40.360
o que estamos tentando fazer é traduzir o objetivo. normalizado ... assim e que será um

07:40.360 --> 07:45.160
vetor de comprimento de unidade 1 indo na mesma direção.

07:45.160 --> 07:49.480
Agora, quando você joga, isso provavelmente será longe demais.

07:49.600 --> 07:57.840
Então, se voltarmos e executá-lo. Sim, você pode ver que eles se moviam na mesma taxa,

07:58.040 --> 08:02.490
mas era bastante nervoso e era um grande salto a cada atualização.

08:02.690 --> 08:10.430
Mas agora sabemos que temos um movimento de unidade 1 padronizado a cada atualização e agora que temos isso, podemos

08:10.430 --> 08:17.500
multiplicar isso por um valor de velocidade para mudar a rapidez com que nosso personagem está indo.

08:17.510 --> 08:25.570
Então, vamos criar outra 'velocidade de flutuação pública' e definiremos isso (porque queremos

08:25.570 --> 08:38.790
torná-lo um pouco mais lento) 0. 1f e multiplique seu objetivo normalizado pela sua velocidade ... assim e agora porque é público, você pode

08:39.060 --> 08:43.460
alterar a velocidade de cada um desses personagens,

08:43.460 --> 08:49.420
mas deixaremos 0. 1 para os dois porque queremos vê-los se movendo na mesma taxa. Pressione Reproduzir ...

08:50.330 --> 08:56.240
e lá vai você ... e eles continuarão para todo o

08:56.240 --> 09:03.290
sempre, porque, embora tenhamos dado a eles vetores iniciais completamente diferentes, eles estavam apontando na

09:03.290 --> 09:04.380
mesma direção

09:04.430 --> 09:07.920
e depois foram normalizados até a unidade

09:08.090 --> 09:13.950
1, e acabaram exatamente com o mesmo vetor multiplicado exatamente na mesma velocidade.

09:13.970 --> 09:20.180
Portanto, não importa quanto tempo o vetor seja, se você o normalizar, você acaba com o mesmo

09:20.180 --> 09:22.190
pequeno vetor da unidade 1.

09:22.190 --> 09:28.430
Agora, essas velocidades, mesmo que você ache que é uma velocidade consistente, o outro fator envolvido

09:28.430 --> 09:36.950
(volte para o seu código de movimento) é a velocidade com que esta atualização ocorre porque toda vez que seu jogo executa uma

09:37.340 --> 09:43.060
atualização, não é necessariamente exatamente a mesma hora em que a última atualização aconteceu.

09:43.070 --> 09:50.540
Portanto, você obterá inconsistências na velocidade e, embora provavelmente nem perceba isso, verá em muitos códigos que as

09:50.540 --> 09:55.440
pessoas se multiplicam pelo tempo. deltaTime e o

09:55.520 --> 10:03.050
que isso faz é suavizar e permitir a diferença na atualização em execução.

10:03.080 --> 10:09.220
A outra coisa que devo dizer também antes de terminarmos é tornar este LateUpdate.

10:09.350 --> 10:14.390
Qualquer movimento que você tenha sobre seus personagens (e especialmente quando você começar a adicionar câmeras

10:14.390 --> 10:17.540
que acompanham as coisas), você quer que tudo aconteça

10:17.540 --> 10:20.780
depois que toda a física tiver sido calculada na cena.

10:20.780 --> 10:28.040
Atualmente, não temos física, por isso não é um problema, mas você deve adquirir o hábito de colocar seus movimentos no

10:28.040 --> 10:34.080
LateUpdate, o que eu ainda não sou e fique à vontade para me corrigir o tempo todo,

10:34.130 --> 10:41.670
se eu tiver um loop de atualização com o movimento em porque eu sou obrigado a, porque esse é um mau hábito meu.

10:41.780 --> 10:51.360
Portanto, isso deve ser tudo o que precisamos agora para ter um bom movimento suave e consistente de nosso caráter.

10:51.560 --> 10:55.520
Salve isso. Vamos voltar para o Unity e pressionar Play ... e agora...

10:56.640 --> 10:58.030
bem, essa velocidade é bem pequena, não é?

10:58.320 --> 11:00.260
Você pode dizer que a multiplicação do tempo. O deltaTime também diminuiu bastante o

11:00.300 --> 11:06.240
ritmo, porque será um valor bastante pequeno devido à diferença

11:06.630 --> 11:13.560
de tempo entre os loops de atualização e, portanto, isso permite que você brinque com as velocidades que você está definindo em seus personagens. Então, talvez, em vez de

11:13.590 --> 11:19.920
0. 1, convém alterá-los para 1 e experimentá-lo.

11:19.920 --> 11:27.800
Isso é um pouco melhor, mas esse é realmente o código que você deve usar quando parar de mover um personagem.

11:27.870 --> 11:35.770
Tudo bem, então é isso para mover algo em linha reta e

11:35.790 --> 11:42.000
como obter velocidade consistente nos movimentos do seu personagem. Na próxima palestra, começaremos a procurar avançar em direção a uma meta e transformar

11:42.000 --> 11:44.780
nossos personagens.
