WEBVTT

00:11.500 --> 00:14.400
Além de transformar um personagem e movê-lo ao longo de um

00:14.440 --> 00:20.230
vetor definido, também podemos transformá-lo e empurrá-lo na direção em que ele está voltado (ou ao longo de um de seus vetores locais).

00:20.980 --> 00:21.650
No

00:21.670 --> 00:29.950
Unity, um personagem possui 3 vetores locais: z para frente, y para cima e x para direita, independentemente da rotação do personagem,

00:29.950 --> 00:35.800
podemos avançar com qualquer um desses vetores locais com a função Traduzir, especificando o movimento em

00:35.830 --> 00:43.300
um (ou mais ) dos eixos locais x, ye z. Para mover o personagem para frente a uma velocidade

00:43.300 --> 00:49.720
constante, modificaríamos apenas sua coordenada z. Para mover um personagem a uma velocidade constante,

00:49.780 --> 00:53.160
modificaríamos sua coordenada x e, para mover o personagem

00:53.170 --> 00:56.060
para cima, modificaríamos sua coordenada y.

00:56.100 --> 01:02.220
Você também pode mover um personagem para trás, para a esquerda e para baixo, especificando uma velocidade negativa.

01:02.410 --> 01:07.450
Se você modificar a rotação de um eixo enquanto o gira, o personagem se moverá em uma

01:07.450 --> 01:08.400
direção mundial

01:08.500 --> 01:12.190
diferente, no entanto, continuará se movendo ao longo do eixo especificado localmente.

01:12.220 --> 01:17.980
Por exemplo, se um personagem muda de direção enquanto é empurrado ao longo de um eixo z, ele se moverá ao

01:17.980 --> 01:18.910
redor do mundo,

01:19.090 --> 01:25.060
mas, em relação a si mesmo, ainda estará se movendo ao longo do eixo z, pois são os eixos à frente dos

01:25.060 --> 01:29.020
personagens que foram alterados no rotação e não a sua velocidade de movimento.

01:29.410 --> 01:31.950
Então, vamos tentar isso tudo em um projeto.

01:31.960 --> 01:38.530
Faça o download do projeto 'PushForward', que é o recurso que acompanha esta palestra e, quando você o

01:38.530 --> 01:44.680
abrir, abra a cena dos zumbis (porque tudo fica melhor com os zumbis) e abra e dê

01:44.830 --> 01:51.490
uma olhada no que você tem lá . Se você pressionar Play neste momento, notará que tem um zumbi animado que

01:51.490 --> 01:54.570
não vai a lugar nenhum ... rápido e

01:54.700 --> 01:57.440
com aparência de cubo.

01:57.580 --> 02:02.500
Se você usar as teclas de seta, descobrirá que pode girar esse cubo e movê-lo.

02:02.500 --> 02:11.650
Este cubo será nosso objetivo e, ao movê-lo, poderemos ver a rotação desse zumbi e como vamos empurrá-lo

02:11.650 --> 02:13.720
para a frente.

02:13.720 --> 02:20.170
Tudo bem, então vamos parar de jogar isso. O próprio cubo, se você estiver interessado, possui um código 'Drive' e você

02:20.170 --> 02:27.780
pode dar uma olhada nesse script e no que ele faz, apenas o move ao redor. Novamente, ele segue o mesmo caminho que estamos fazendo

02:27.820 --> 02:34.130
com o nosso personagem zumbi e também tem uma rotação lá também, mas esse não

02:34.300 --> 02:36.750
é o foco desta lição.

02:36.850 --> 02:44.590
Estamos olhando para mover o zumbi, mudar sua direção (para que ele esteja sempre olhando para este cubo) e empurrá-lo ao longo

02:44.590 --> 02:46.390
de seu eixo z.

02:46.390 --> 02:52.260
Agora, se você clicar no modelo em si e dar uma olhada, verá que o eixo z está voltado para a

02:52.410 --> 02:55.020
frente e é para isso que estamos avançando.

02:55.270 --> 03:03.120
Portanto, crie um novo arquivo C # chamado 'MoveLocal'. Nesse script, você adicionará isso.

03:03.130 --> 03:06.250
Portanto, é semelhante ao que tivemos na palestra anterior.

03:06.280 --> 03:12.720
Temos um 'objetivo' que passaremos (que será nosso cubo) e teremos velocidade.

03:12.880 --> 03:19.690
Agora, você precisará ajustar essa velocidade, com base na animação e se ela se encaixa nela. Às vezes, se a sua velocidade está

03:19.690 --> 03:27.250
indo muito rápida ou muito lenta para a animação em particular, o personagem escorrega e há muitas

03:27.250 --> 03:33.190
maneiras de corrigir isso, mas também não estamos entrando nessa profundidade com a

03:33.220 --> 03:33.990
animação.

03:34.120 --> 03:34.430
Certo.

03:34.450 --> 03:42.100
Então, adicione isso e, na atualização, temos uma transformação. LookAt para mudar a direção em que estamos procurando

03:42.100 --> 03:49.180
nosso zumbi, que será a posição do 'objetivo' e, em seguida, empurraremos o zumbi ao longo do eixo

03:49.180 --> 03:56.260
z usando nossa velocidade e multiplicando-a por Time. deltaTime.

03:56.290 --> 03:58.750
Agora estou fazendo isso na atualização e o

03:58.840 --> 04:00.080
que eu disse antes?

04:00.100 --> 04:02.900
Eu sempre esqueço de colocar o LateUpdate, então vamos colocar isso lá.

04:03.130 --> 04:04.750
Agora salve isso.

04:04.930 --> 04:10.550
Volte para o Unity e você deseja anexar esse 'MoveLocal' a Jill (Jill é

04:10.570 --> 04:18.280
o nome do nosso zumbi) no nível mais alto. Procurando Jill no inspetor, ela terá uma transformação, um animador e,

04:18.280 --> 04:24.670
em seguida, o script que você adicionou lá. No script, você verá que

04:24.670 --> 04:34.560
o 'objetivo' foi exposto; então, segure seu cubo e arraste-o e solte-o como o objetivo de nível superior.

04:34.600 --> 04:40.630
Ok, agora pressione Play e ela começará a se mover em direção ao cubo.

04:40.810 --> 04:51.950
Agora, se afastarmos isso, por causa do LookAt, ela estará constantemente girando e olhando para o cubo.

04:52.070 --> 04:57.470
Atualmente, todo mundo nesta cena está flutuando acima do solo, mas

04:57.470 --> 05:05.030
você pode ajustar isso pegando seu personagem e dirigindo-o para o chão e também agarrando

05:05.930 --> 05:09.100
seu cubo e dirigindo-o assim.

05:09.100 --> 05:15.190
Ok, então faça outra peça.

05:15.250 --> 05:20.570
Agora você pode ver que o personagem ainda está flutuando um pouco acima do solo

05:20.860 --> 05:25.600
e temos o mesmo problema com a cintilação que tivemos na palestra anterior, em

05:25.600 --> 05:30.760
que o personagem alcançará o objetivo e continuará tentando alcançá-lo. , ultrapassando levemente e voltando

05:30.760 --> 05:32.470
e trocando de direção,

05:32.470 --> 05:35.800
mas se você mover o cubo, ele será interrompido.

05:35.920 --> 05:37.490
Agora ela ainda

05:37.530 --> 05:45.640
está flutuando no ar e isso destaca outro problema com esse código específico, que é que ela vai mudar e olhar

05:45.910 --> 05:50.750
para esse cubo, onde quer que esteja.

05:50.830 --> 05:57.220
O LookAt não discrimina se o cubo está no ar. Então, vamos mover esse cubo assim e ver

05:57.220 --> 06:03.880
como esse LookAt está movendo o eixo z, para que ele mude e sempre fique voltado para o cubo.

06:03.880 --> 06:12.460
Se pausarmos isso e dermos uma olhada em Jill, você verá que o eixo z está sendo virado para a nossa posição de

06:12.490 --> 06:19.300
cubo e isso causará muitos problemas quando você começar a mover objetos que realmente devem permanecer no chão

06:19.300 --> 06:26.380
(como um humanóide) para olhar para a posição do objetivo que está no espaço 3D e pode estar no

06:26.470 --> 06:27.200
ar.

06:28.040 --> 06:36.230
Para recapitular, o que o LookAt está fazendo é girar o modelo para que o eixo z

06:36.230 --> 06:39.140
aponte para a posição da meta.

06:39.320 --> 06:42.410
Portanto, não importa onde o espaço 3D

06:42.410 --> 06:50.060
esteja posicionado, o objetivo será orientar o modelo 3D, de modo que ele esteja voltado para essa direção e esse seja

06:50.240 --> 06:54.150
um problema real para os personagens que precisam permanecer no chão.

06:54.200 --> 07:01.550
Em vez disso, o que queremos fazer é que nosso personagem gire na direção do objeto, mas apenas

07:01.640 --> 07:10.310
nos planos xe y, de modo que o eixo z se alinhe com a posição do objeto em um eixo vertical

07:10.310 --> 07:14.570
a partir dele, em exatamente a mesma altura do personagem.

07:14.690 --> 07:21.420
Portanto, precisamos que o personagem execute um LookAt em um ponto que seja o mesmo y do personagem, mas que

07:21.530 --> 07:29.210
seja o mesmo x e z que o objeto de objetivo. Conseguir isso no Unity é apenas um

07:29.210 --> 07:36.620
pequeno ajuste ao nosso código MoveLocal. Em vez de executar um LookAt no objetivo (que é o

07:36.710 --> 07:44.570
nosso cubo pelo qual estamos passando), calculamos uma nova posição do objetivo a ser observada, que estará na mesma posição x e z do

07:44.570 --> 07:45.450
cubo, como

07:45.620 --> 07:49.900
você pode ver aqui , mas sua posição y é igual ao nosso personagem.

07:50.060 --> 07:57.590
Em seguida, usamos essa nova posição que calculamos (que chamei de

07:57.650 --> 08:07.430
lookAtGoal e a usamos dentro da LookAt. Então, depois de atualizar seu código, se você salvá-lo, volte para o Unity e

08:07.430 --> 08:15.110
execute-o, você pode mover seu cubo para a altura (como você pode ver aqui, meu cubo já está flutuando) e isso não afeta

08:15.260 --> 08:16.930
o zumbi caráter qualquer.

08:16.940 --> 08:24.070
Então, ela permanece no chão e seu z não está sendo rotacionado para cima.

08:24.080 --> 08:31.750
Está ficando paralelo ao chão.

08:31.760 --> 08:37.280
Uma última coisa a completar nosso código é fazer com que o zumbi pare de se mover quando chegar ao local,

08:37.280 --> 08:39.620
para que você não fique com a 'agitação'.

08:39.620 --> 08:43.340
Primeiro, precisamos adicionar um valor de 'precisão'.

08:43.860 --> 08:46.870
Portanto, isso é muito semelhante ao código que fizemos antes.

08:47.780 --> 08:50.710
Vou definir isso para 1. 0f.

08:50.870 --> 08:54.610
neste caso, e você pode ajustar isso mais tarde.

08:54.770 --> 09:01.640
Em seguida, queremos testar a precisão antes de realizar uma tradução, para que continuemos a LookAt mesmo se estivermos

09:01.640 --> 09:10.760
perto o suficiente, mas não chegaremos mais perto. Então 'if' e, neste caso, não temos uma direção. magnitude a ser usada como nossa

09:10.760 --> 09:17.840
distância da meta, porque nunca calculamos a direção, portanto isso é um pouco

09:17.840 --> 09:20.270
diferente do código anterior.

09:20.270 --> 09:26.990
Mas o que realmente é gelo que vem com nossos vetores é que podemos calcular a distância entre duas posições

09:27.290 --> 09:32.300
e podemos fazer isso com o Vector3. Distância e queremos encontrar a

09:32.450 --> 09:41.060
distância entre a nossa localização atual (que é transformar. posição) e a posição do

09:41.120 --> 09:42.150
objetivo.

09:42.170 --> 09:46.740
Então objetivo. position Portanto, essa

09:46.840 --> 09:57.130
é a sua declaração 'if' e queremos testar se a distância é maior que a nossa precisão,

09:57.190 --> 10:01.990
o que nos permitirá seguir em frente, caso

10:02.110 --> 10:05.660
contrário não executará o Translate.

10:06.130 --> 10:13.060
Então, ao elaborar este Vector3. Distância entre essas duas posições, é essencialmente a mesma

10:13.450 --> 10:20.350
coisa que encontrar a direção (ou o vetor) entre esses dois valores afastando um do outro e

10:20.350 --> 10:23.490
depois usando o. magnitude.

10:23.500 --> 10:29.470
É o mesmo cálculo, são apenas diferentes maneiras de resolver isso. Então você pode entrar aqui e calcular a

10:29.470 --> 10:34.390
direção e obter a magnitude desse vetor, ou pode usar esta função de distância.

10:34.510 --> 10:34.720
Certo.

10:34.720 --> 10:44.310
Então salve isso e agora vamos voltar para o Unity e executá-lo ... e dirigir por aí ... vamos dirigir um pouco mais perto.

10:45.950 --> 10:53.000
Agora ainda podemos ver, neste caso, que ficamos 'nervosos'.

10:53.170 --> 11:01.300
A razão é que a nossa distância atual está calculando-a entre a distância do cubo real e a distância do

11:01.930 --> 11:04.500
zumbi, mas o zumbi não está tentando

11:04.500 --> 11:10.060
chegar à posição do cubo, está tentando chegar à posição que está embaixo do

11:10.240 --> 11:12.770
cubo em a mesma altura.

11:13.030 --> 11:20.740
Portanto, há muito pouca esperança (especialmente se esse cubo estiver no ar) por estar próximo a ele,

11:20.740 --> 11:25.180
porque não é permitido mover-se em uma direção ascendente.

11:25.360 --> 11:32.260
Então, faremos esse pequeno ajuste no nosso código, de volta aqui. Em vez de tentar obter a distância

11:32.800 --> 11:38.920
entre nosso personagem e a posição do objetivo, o que pode não ser possível porque

11:38.920 --> 11:44.190
essa posição está no ar, em vez disso, queremos apenas obter o LookAt.

11:44.220 --> 11:51.780
Então, vamos colocar isso lá, salvá-lo e voltar e correr.

11:51.820 --> 11:57.350
Agora, quando o zumbi se aproxima o suficiente do nosso cubo, ele pára de se mover.

11:57.370 --> 12:01.960
É claro que a animação ainda está em execução, mas

12:01.960 --> 12:10.000
não estamos trabalhando com isso no momento e não importa o quão alto você mova isso e a

12:10.300 --> 12:19.660
distância real entre os dois, apenas se preocupa com a distância entre si. e esta posição aqui que está na mesma altura.

12:19.690 --> 12:27.570
Então agora eu posso dirigir este cubo e o zumbi ainda o seguirá, mas permanecerá no chão ...

12:29.470 --> 12:35.060
e quando chegarmos perto o suficiente, ele irá parar.

12:35.070 --> 12:39.150
É assim que você move um personagem ao longo de seu eixo dianteiro.
