WEBVTT

00:11.150 --> 00:17.300
Nesta palestra, criaremos a base de um simples carro de corrida dirigido por A. EU. Até agora, desenvolvemos um NPC que pode

00:17.360 --> 00:21.200
seguir um progressor de circuito de waypoint a uma taxa constante, mas,

00:21.200 --> 00:21.790
na

00:21.950 --> 00:24.920
realidade, não é assim que os carros se movem.

00:24.920 --> 00:31.700
Em vez disso, precisamos considerar a velocidade, aceleração e desaceleração dos carros e programar o NPC para saber

00:31.700 --> 00:34.040
quando acelerar e quando desacelerar.

00:35.830 --> 00:41.610
Velocity é o vetor que representa a velocidade do NPC, bem como a direção em que está viajando.

00:41.740 --> 00:49.250
A velocidade é usada para impulsionar o NPC para frente. Aceleração e desaceleração são consideradas forças que podem aumentar

00:49.250 --> 00:52.770
ou reduzir a velocidade ao longo do tempo.

00:52.880 --> 00:59.790
Eles também são vetores. Normalmente, a aceleração é uma força para frente e a desaceleração é uma

00:59.810 --> 01:00.790
força para trás,

01:00.800 --> 01:05.510
embora elas possam ser aplicadas em qualquer ângulo. Por exemplo, no caso de uma colisão lateral.

01:05.510 --> 01:10.550
Até agora, desenvolvemos um NPC que seguirá um ponto que está rastreando um circuito de waypoint.

01:10.550 --> 01:14.930
Este ponto usaremos como olhos dos NPCs para saber como a pista está girando.

01:15.200 --> 01:20.410
Quando a pista estiver em linha reta, o NPC e o rastreador terão o mesmo vetor para frente.

01:20.510 --> 01:26.330
No entanto, quando o circuito está dobrado, o ângulo entre o rastreador e os vetores avançados dos NPCs fica maior.

01:26.330 --> 01:36.320
Para acompanhar, enquanto montamos este carro simples A. EU. , baixe os recursos do WaypointsCarsStarter com

01:36.360 --> 01:37.080
isso.

01:37.390 --> 01:42.100
Ao abri-lo, você verá exatamente o que estou vendo aqui, embora suas visualizações de

01:42.100 --> 01:48.470
cena e jogo possam ser um pouco diferentes, mas nela você tem uma pista de corrida com um circuito de

01:48.550 --> 01:52.430
waypoint já configurado nela, usando o mesmo código que usamos na última

01:52.690 --> 01:58.690
palestra e eu adicionei em um carro laranja. Aquele carro laranja tem um cubo ligado a ele.

01:58.690 --> 02:03.580
Agora, este carro laranja tem o WaypointProgressTracker configurado.

02:03.790 --> 02:09.660
O cubo é definido como o destino para esse WaypointProgressTracker e há um

02:09.670 --> 02:18.250
script C # chamado SimpleAICar anexado ao carro. Esse script, se o abrirmos, você verá que é muito

02:18.250 --> 02:24.760
semelhante ao último lote de código que temos para empurrar objetos em uma linha reta,

02:24.760 --> 02:27.880
enquanto eles estão continuamente buscando um objetivo.

02:27.910 --> 02:35.250
Então, vamos pegar esse script e modificá-lo para adicionar um pouco de dinâmica do carro a ele.

02:35.530 --> 02:43.210
Você também deve ter visto, de volta a essa cena do jogo, que há um velocímetro que foi adicionado.

02:43.210 --> 02:49.570
Isso é guiado pelo código chamado AnalogSpeedConverter e não vamos entrar nisso, mas

02:49.570 --> 02:54.160
a velocidade do carro está sendo alimentada no velocímetro.

02:54.220 --> 02:59.740
Por isso, fornece uma representação visual do que o carro está fazendo em relação à sua velocidade.

02:59.740 --> 03:06.680
Agora, com este carro, se pressionarmos Play, você o verá percorrer a pista a uma velocidade constante.

03:06.790 --> 03:12.960
Então vai subir para 200 (como você pode ver no mostrador) e seguir constantemente ao redor do

03:12.970 --> 03:15.580
cubo, esteja você no canto ou não.

03:15.580 --> 03:20.590
Essa velocidade não é muito indicativa de uma velocidade real, por isso diz que está chegando a

03:20.590 --> 03:24.300
200, mas são 200 'metros por segundo' ou 200 'quilômetros por hora'.

03:24.430 --> 03:26.820
Não parece que ele esteja viajando em nenhuma dessas velocidades e

03:26.830 --> 03:29.110
é por causa da maneira que estamos calculando isso.

03:29.260 --> 03:33.410
Então, vamos mudar isso também e atualizá-lo, para que o mostrador faça sentido.

03:33.440 --> 03:38.930
De volta ao nosso código, a primeira coisa que faremos é modificar a maneira como a velocidade é configurada.

03:38.950 --> 03:45.360
Então, eu quero que você se livre dessas duas linhas (ou as mova) e vamos colocar isso.

03:45.370 --> 03:51.700
Então começamos com uma aceleração de 5, depois uma desaceleração que eu tenho também com 5 (esses

03:51.700 --> 03:59.500
dois valores que você pode alterar, com base em quanta potência e potência de frenagem o carro terá), uma velocidade

03:59.500 --> 04:01.210
mínima e uma velocidade

04:01.220 --> 04:07.690
máxima (porque sem isso, você pode fazer seu carro recuar quando não quiser, porque está com freios

04:07.690 --> 04:13.480
demais) e uma velocidade máxima para impedir que ele vá muito rápido ao infinito.

04:13.480 --> 04:19.570
A velocidade em si desce aqui, agora tirei o público disso porque a velocidade não é mais uma variável

04:19.570 --> 04:19.920
exposta.

04:19.920 --> 04:21.300
Nós vamos calcular isso.

04:21.310 --> 04:23.140
Nós não vamos definir isso.

04:23.210 --> 04:29.980
As outras coisas que tenho aqui são aceleração, desaceleração, velocidade mínima e máxima NÃO como variáveis expostas,

04:29.990 --> 04:32.490
embora você possa expô-las mais tarde.

04:32.500 --> 04:35.210
Portanto, eles devem ser definidos pelo usuário.

04:35.260 --> 04:40.360
A razão pela qual faço isso é porque sempre esqueço quando estou editando que, se eu tentar alterar

04:40.360 --> 04:44.210
os valores aqui e eles estiverem expostos, isso não muda no Inspetor e, depois,

04:44.220 --> 04:47.920
passo muito tempo tentando descobrir por que meu código não está funcionando.

04:48.100 --> 04:53.290
Por isso, acho melhor não tê-los expostos até que eu tenha tudo funcionando do jeito que eu quero.

04:53.290 --> 04:55.990
Em seguida, adicionaremos nosso cálculo para a velocidade.

04:56.090 --> 05:02.500
Desça um pouco antes que a velocidade seja usada, nesta função Traduzir aqui e acima

05:02.620 --> 05:10.810
disso, adicionaremos ESTE: 'Velocidade ='. Estamos usando um Mathf. Prenda e isso garantirá que

05:10.810 --> 05:17.480
qualquer cálculo de velocidade que colocarmos aqui seja fixado entre o minSpeed e o maxSpeed.

05:17.650 --> 05:24.610
Portanto, este bit primeiro no grampo está fazendo um cálculo para nós, que será colocado em 'velocidade'.

05:24.640 --> 05:31.180
Se, no entanto, estiver fora desse intervalo, ele será fixado em 0 ou seja qual for o

05:31.330 --> 05:32.130
maxSpeed.

05:32.200 --> 05:42.490
Este cálculo está aumentando a velocidade com ... aceleração * Tempo. deltaTime e porque multiplicamos

05:42.490 --> 05:49.060
pelo tempo. deltaTime lá em cima, podemos descer e removê-lo

05:49.060 --> 05:50.110
do Translate

05:50.110 --> 05:53.770
para que eles estivessem apenas com uma velocidade simples.

05:53.770 --> 06:00.550
Agora, a outra coisa com este conversor de velocidade (que mostra o mostrador na tela) é que são necessários

06:00.550 --> 06:04.840
um valor 'min' e 'max' para determinar quanto deve girar a agulha.

06:04.960 --> 06:12.850
Agora, nesse caso, será minSpeed e 100 será o maxSpeed.

06:12.910 --> 06:16.180
Então, nesse caso, vai ficar entre 0 e 100.

06:16.180 --> 06:20.920
Então, vamos salvar isso, voltar para o Unity e pressionar

06:21.070 --> 06:27.690
Play. Agora, em vez do mostrador girar e atingir a velocidade máxima, ele acelerará lentamente.

06:27.730 --> 06:32.560
Então você pode ver o mostrador aumentando e o carro seguindo o cubo. Você também pode ver que precisamos

06:32.560 --> 06:35.050
corrigir a formatação da nossa velocidade e, em

06:35.320 --> 06:41.230
seguida, chegamos a um ponto que você pode ver aqui. Veja como o carro está pulando

06:41.230 --> 06:48.400
e girando em círculos ao redor do rastreador? É o mesmo problema que tivemos no passado com nossos NPCs, quando eles não estão

06:48.400 --> 06:50.570
chegando ao ponto em que precisam estar e

06:50.680 --> 06:57.190
esse carro não pode seguir o rastreador porque está preso ao seu redor. Agora, para corrigir isso, se você entrar

06:57.200 --> 07:06.300
no carro e descer para o circuito conectado ao WaypointProgressTracker, o 'Look Ahead For Target' será definido como

07:06.300 --> 07:08.960
1 e também o

07:09.010 --> 07:13.220
'Look Ahead For Speed', que são grandes demais.

07:13.270 --> 07:17.320
Abaixe-os para 0. 1 em vez disso, de

07:17.320 --> 07:20.450
modo que não estamos olhando tão à frente.

07:20.560 --> 07:24.170
Estamos ficando muito mais próximos desse rastreador de waypoints.

07:24.190 --> 07:30.930
Então, se voltarmos a correr, você verá que está ficando agradável e perto, mas o que não

07:30.940 --> 07:36.600
vai fazer é ficar muito longe e também não vai cortar os cantos.

07:36.760 --> 07:44.890
Assim, à medida que você aumenta esse valor para o 'Look Ahead Target', você começa a levar seu carro cada vez mais

07:44.890 --> 07:51.460
longe do rastreador de waypoints. Se eu apenas pausar isso por um segundo ... porque está calculando em uma linha reta

07:51.490 --> 07:56.410
até esse ponto, quando o rastreador de waypoint está ao virar da esquina aqui

07:56.590 --> 08:01.600
em cima e se os carros aqui, ele pode seguir diretamente pela pista aqui e

08:01.990 --> 08:09.670
você descobrirá que, à medida que constrói mais sistemas, obterá o carro fica atrás do cubo e ele faz curvas e não fica

08:09.670 --> 08:16.990
na pista perfeitamente, e é por isso que você precisa ajustar esses 'Look Ahead Target' e acelerar os valores para sua determinada

08:16.990 --> 08:21.120
circunstância e suas certas pistas. Então, se voltarmos a jogar ...

08:21.160 --> 08:29.650
agora chegamos a 100, o que é extremamente rápido, como você pode ver nesta pista, mas o

08:29.740 --> 08:36.430
carro está seguindo o rastreador e seguindo a pista, então isso é bom.

08:36.450 --> 08:39.660
Agora, o que está acontecendo é que está chegando a 100 e

08:39.720 --> 08:43.290
essa é a sua velocidade constante. Claro, carros de verdade não fazem isso.

08:43.290 --> 08:45.420
Você não vira a esquina aos 100.

08:45.420 --> 08:52.660
Então agora queremos alterá-lo para travar quando chegarmos a um canto. Se você puder correr e parar em um

08:52.770 --> 08:55.860
canto, terá uma situação como esta.

08:55.860 --> 09:03.300
Observe como o vetor voltado para frente dos carros não está alinhado com o vetor voltado para frente do rastreador.

09:03.360 --> 09:08.200
Sempre que isso acontece, significa que o carro está viajando em uma

09:08.490 --> 09:14.490
direção diferente do rastreador e, portanto, sabemos que o rastreador dobrou uma esquina e o carro não.

09:14.490 --> 09:21.060
Quando isso acontece, queremos aplicar os freios (ou reduzir a desaceleração em nosso cálculo de velocidade) e podemos determinar quando fazer isso em

09:21.060 --> 09:27.300
nosso código calculando o ângulo entre cada vetor para frente. De volta ao código, adicionaremos outra

09:27.300 --> 09:28.100
variável

09:28.100 --> 09:35.220
na parte superior: 'float brakeAngle' e este será o ângulo no qual aplicaremos

09:35.220 --> 09:41.370
os freios; portanto, como é uma variável, você pode alterá-la para

09:41.370 --> 09:46.020
diferentes tipos de carros. Alguns podem ser muito cautelosos e frear quando há um pequeno ângulo.

09:46.050 --> 09:52.530
Outros podem ser um pouco mais temerários e você pode ter um ângulo grande, mas vamos definir 20 para

09:52.590 --> 09:54.080
começar como nosso ângulo.

09:54.240 --> 10:02.280
Então esse é o ângulo do freio que testará o ângulo entre o vetor de avanço da meta e o vetor de avanço do

10:02.340 --> 10:02.970
carro.

10:03.150 --> 10:03.950
Então,

10:03.960 --> 10:11.450
faremos isso aqui na atualização. Atualmente, estamos calculando a velocidade por

10:11.460 --> 10:19.110
si só aqui e só temos a aceleração. Agora a desaceleração será a mesma coisa, mas será um sinal de menos.

10:19.140 --> 10:21.470
Vamos substituir esta linha

10:23.020 --> 10:32.260
aqui por esta. Portanto, isso calcula com um Vector3. Ângulo. Você pode atribuir dois vetores para

10:32.260 --> 10:35.990
que o vetor direto da meta e o vetor direto do

10:36.340 --> 10:40.880
carro e depois teste se esse ângulo é maior que o ângulo do freio.

10:40.960 --> 10:47.630
Se for, então vamos desacelerar (então vamos aplicar os freios essencialmente), caso

10:47.740 --> 10:51.330
contrário, continuaremos acelerando. Enquanto estivermos aqui, corrigiremos

10:51.370 --> 10:58.390
o texto lido no velocímetro, convertendo a velocidade para um 'int', apenas para cortar todas

10:58.390 --> 10:59.890
as casas decimais.

10:59.890 --> 11:00.810
Certo, salve isso.

11:00.820 --> 11:02.510
Agora vamos brincar.

11:02.590 --> 11:08.440
Então, começamos a acelerar e, quando chegarmos à primeira curva, você verá que a velocidade tem um pouco

11:08.710 --> 11:14.380
de soluço; depois, conforme ela gira em torno de outras esquinas, a agulha da velocidade diminui

11:14.380 --> 11:15.470
um pouco, pouco.

11:15.520 --> 11:21.160
Mas o problema é que ainda está acelerando e, se deixarmos que funcione por tempo suficiente, ele atingirá

11:21.160 --> 11:22.330
a velocidade máxima.

11:22.330 --> 11:29.860
Agora, a razão disso está ocorrendo porque a rotação entre o vetor de avanço dos carros e o vetor de

11:29.890 --> 11:32.010
avanço dos cubos não é

11:32.050 --> 11:36.080
diferente o suficiente para nos preocuparmos em aplicar os freios.

11:36.130 --> 11:43.290
O motivo é que, se pararmos de jogar, entre no carro e vá até o seu WaypointProgressTracker.

11:43.510 --> 11:50.410
Se você der uma olhada, você tem esse valor 'Look Ahead For Speed', que está atualmente definido como 0. 1

11:50.410 --> 12:00.760
Agora, esse é o cubo girando, pois, à frente, ele pode olhar na pista e quanto ele

12:00.760 --> 12:04.380
pode girar. Então, isso é como a velocidade de rotação dos cubos.

12:04.390 --> 12:13.240
Agora, se mudarmos para algo como 1, permitirá que o cubo seja atualizado muito

12:13.240 --> 12:20.010
mais rapidamente para mais adiante. Agora, se você observar o cubo enquanto pressionamos Play aqui, você o verá girando em seu próprio eixo e

12:20.110 --> 12:25.360
o que isso fará é permitir que o carro aplique os freios nos cantos. Assim, quando chega à esquina, veja

12:25.360 --> 12:32.000
que o cubo gira e gira rapidamente (e aqui em cima também o fará) e os

12:32.040 --> 12:39.520
freios estão agora sendo muito aplicados, porque há uma grande diferença entre o carro e o cubo e

12:39.520 --> 12:44.470
você pode ver que realmente está colocando um amortecedor na velocidade aqui.

12:44.470 --> 12:51.110
Então, novamente, tudo se resume a "O que você procura, nisto? "e" Como você deseja que ela pareça e funcione? "

12:51.130 --> 12:57.730
Depende do tamanho do seu mundo e também do tamanho da pista, porque o mundo ... lembre-se de que um cubo é de 1 metro

12:57.730 --> 13:01.120
x 1 metro x 1 metro e, portanto, essa pista

13:01.340 --> 13:06.620
(você pode ver que o cubo branco foi feito como um cubo unitário), não é uma

13:06.630 --> 13:07.970
pista muito grande.

13:07.990 --> 13:13.690
Você não pode esperar obter uma grande velocidade. Se você deseja velocidades do mundo real, também precisa ter

13:13.690 --> 13:17.250
certeza de que sua faixa está nas coordenadas de tamanho do mundo real.

13:17.410 --> 13:22.420
Então, vamos deixar isso aqui e, na próxima aula, começaremos a personalizar as propriedades para

13:22.420 --> 13:24.520
criar um comportamento exclusivo do NPC.
