Nesta palestra, criaremos a base de um simples carro de corrida dirigido por A. EU. Até agora, desenvolvemos um NPC que pode
seguir um progressor de circuito de waypoint a uma taxa constante, mas,
na
realidade, não é assim que os carros se movem.
Em vez disso, precisamos considerar a velocidade, aceleração e desaceleração dos carros e programar o NPC para saber
quando acelerar e quando desacelerar.
Velocity é o vetor que representa a velocidade do NPC, bem como a direção em que está viajando.
A velocidade é usada para impulsionar o NPC para frente. Aceleração e desaceleração são consideradas forças que podem aumentar
ou reduzir a velocidade ao longo do tempo.
Eles também são vetores. Normalmente, a aceleração é uma força para frente e a desaceleração é uma
força para trás,
embora elas possam ser aplicadas em qualquer ângulo. Por exemplo, no caso de uma colisão lateral.
Até agora, desenvolvemos um NPC que seguirá um ponto que está rastreando um circuito de waypoint.
Este ponto usaremos como olhos dos NPCs para saber como a pista está girando.
Quando a pista estiver em linha reta, o NPC e o rastreador terão o mesmo vetor para frente.
No entanto, quando o circuito está dobrado, o ângulo entre o rastreador e os vetores avançados dos NPCs fica maior.
Para acompanhar, enquanto montamos este carro simples A. EU. , baixe os recursos do WaypointsCarsStarter com
isso.
Ao abri-lo, você verá exatamente o que estou vendo aqui, embora suas visualizações de
cena e jogo possam ser um pouco diferentes, mas nela você tem uma pista de corrida com um circuito de
waypoint já configurado nela, usando o mesmo código que usamos na última
palestra e eu adicionei em um carro laranja. Aquele carro laranja tem um cubo ligado a ele.
Agora, este carro laranja tem o WaypointProgressTracker configurado.
O cubo é definido como o destino para esse WaypointProgressTracker e há um
script C # chamado SimpleAICar anexado ao carro. Esse script, se o abrirmos, você verá que é muito
semelhante ao último lote de código que temos para empurrar objetos em uma linha reta,
enquanto eles estão continuamente buscando um objetivo.
Então, vamos pegar esse script e modificá-lo para adicionar um pouco de dinâmica do carro a ele.
Você também deve ter visto, de volta a essa cena do jogo, que há um velocímetro que foi adicionado.
Isso é guiado pelo código chamado AnalogSpeedConverter e não vamos entrar nisso, mas
a velocidade do carro está sendo alimentada no velocímetro.
Por isso, fornece uma representação visual do que o carro está fazendo em relação à sua velocidade.
Agora, com este carro, se pressionarmos Play, você o verá percorrer a pista a uma velocidade constante.
Então vai subir para 200 (como você pode ver no mostrador) e seguir constantemente ao redor do
cubo, esteja você no canto ou não.
Essa velocidade não é muito indicativa de uma velocidade real, por isso diz que está chegando a
200, mas são 200 'metros por segundo' ou 200 'quilômetros por hora'.
Não parece que ele esteja viajando em nenhuma dessas velocidades e
é por causa da maneira que estamos calculando isso.
Então, vamos mudar isso também e atualizá-lo, para que o mostrador faça sentido.
De volta ao nosso código, a primeira coisa que faremos é modificar a maneira como a velocidade é configurada.
Então, eu quero que você se livre dessas duas linhas (ou as mova) e vamos colocar isso.
Então começamos com uma aceleração de 5, depois uma desaceleração que eu tenho também com 5 (esses
dois valores que você pode alterar, com base em quanta potência e potência de frenagem o carro terá), uma velocidade
mínima e uma velocidade
máxima (porque sem isso, você pode fazer seu carro recuar quando não quiser, porque está com freios
demais) e uma velocidade máxima para impedir que ele vá muito rápido ao infinito.
A velocidade em si desce aqui, agora tirei o público disso porque a velocidade não é mais uma variável
exposta.
Nós vamos calcular isso.
Nós não vamos definir isso.
As outras coisas que tenho aqui são aceleração, desaceleração, velocidade mínima e máxima NÃO como variáveis expostas,
embora você possa expô-las mais tarde.
Portanto, eles devem ser definidos pelo usuário.
A razão pela qual faço isso é porque sempre esqueço quando estou editando que, se eu tentar alterar
os valores aqui e eles estiverem expostos, isso não muda no Inspetor e, depois,
passo muito tempo tentando descobrir por que meu código não está funcionando.
Por isso, acho melhor não tê-los expostos até que eu tenha tudo funcionando do jeito que eu quero.
Em seguida, adicionaremos nosso cálculo para a velocidade.
Desça um pouco antes que a velocidade seja usada, nesta função Traduzir aqui e acima
disso, adicionaremos ESTE: 'Velocidade ='. Estamos usando um Mathf. Prenda e isso garantirá que
qualquer cálculo de velocidade que colocarmos aqui seja fixado entre o minSpeed e o maxSpeed.
Portanto, este bit primeiro no grampo está fazendo um cálculo para nós, que será colocado em 'velocidade'.
Se, no entanto, estiver fora desse intervalo, ele será fixado em 0 ou seja qual for o
maxSpeed.
Este cálculo está aumentando a velocidade com ... aceleração * Tempo. deltaTime e porque multiplicamos
pelo tempo. deltaTime lá em cima, podemos descer e removê-lo
do Translate
para que eles estivessem apenas com uma velocidade simples.
Agora, a outra coisa com este conversor de velocidade (que mostra o mostrador na tela) é que são necessários
um valor 'min' e 'max' para determinar quanto deve girar a agulha.
Agora, nesse caso, será minSpeed e 100 será o maxSpeed.
Então, nesse caso, vai ficar entre 0 e 100.
Então, vamos salvar isso, voltar para o Unity e pressionar
Play. Agora, em vez do mostrador girar e atingir a velocidade máxima, ele acelerará lentamente.
Então você pode ver o mostrador aumentando e o carro seguindo o cubo. Você também pode ver que precisamos
corrigir a formatação da nossa velocidade e, em
seguida, chegamos a um ponto que você pode ver aqui. Veja como o carro está pulando
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
chegando ao ponto em que precisam estar e
esse carro não pode seguir o rastreador porque está preso ao seu redor. Agora, para corrigir isso, se você entrar
no carro e descer para o circuito conectado ao WaypointProgressTracker, o 'Look Ahead For Target' será definido como
1 e também o
'Look Ahead For Speed', que são grandes demais.
Abaixe-os para 0. 1 em vez disso, de
modo que não estamos olhando tão à frente.
Estamos ficando muito mais próximos desse rastreador de waypoints.
Então, se voltarmos a correr, você verá que está ficando agradável e perto, mas o que não
vai fazer é ficar muito longe e também não vai cortar os cantos.
Assim, à medida que você aumenta esse valor para o 'Look Ahead Target', você começa a levar seu carro cada vez mais
longe do rastreador de waypoints. Se eu apenas pausar isso por um segundo ... porque está calculando em uma linha reta
até esse ponto, quando o rastreador de waypoint está ao virar da esquina aqui
em cima e se os carros aqui, ele pode seguir diretamente pela pista aqui e
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
na pista perfeitamente, e é por isso que você precisa ajustar esses 'Look Ahead Target' e acelerar os valores para sua determinada
circunstância e suas certas pistas. Então, se voltarmos a jogar ...
agora chegamos a 100, o que é extremamente rápido, como você pode ver nesta pista, mas o
carro está seguindo o rastreador e seguindo a pista, então isso é bom.
Agora, o que está acontecendo é que está chegando a 100 e
essa é a sua velocidade constante. Claro, carros de verdade não fazem isso.
Você não vira a esquina aos 100.
Então agora queremos alterá-lo para travar quando chegarmos a um canto. Se você puder correr e parar em um
canto, terá uma situação como esta.
Observe como o vetor voltado para frente dos carros não está alinhado com o vetor voltado para frente do rastreador.
Sempre que isso acontece, significa que o carro está viajando em uma
direção diferente do rastreador e, portanto, sabemos que o rastreador dobrou uma esquina e o carro não.
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
nosso código calculando o ângulo entre cada vetor para frente. De volta ao código, adicionaremos outra
variável
na parte superior: 'float brakeAngle' e este será o ângulo no qual aplicaremos
os freios; portanto, como é uma variável, você pode alterá-la para
diferentes tipos de carros. Alguns podem ser muito cautelosos e frear quando há um pequeno ângulo.
Outros podem ser um pouco mais temerários e você pode ter um ângulo grande, mas vamos definir 20 para
começar como nosso ângulo.
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
carro.
Então,
faremos isso aqui na atualização. Atualmente, estamos calculando a velocidade por
si só aqui e só temos a aceleração. Agora a desaceleração será a mesma coisa, mas será um sinal de menos.
Vamos substituir esta linha
aqui por esta. Portanto, isso calcula com um Vector3. Ângulo. Você pode atribuir dois vetores para
que o vetor direto da meta e o vetor direto do
carro e depois teste se esse ângulo é maior que o ângulo do freio.
Se for, então vamos desacelerar (então vamos aplicar os freios essencialmente), caso
contrário, continuaremos acelerando. Enquanto estivermos aqui, corrigiremos
o texto lido no velocímetro, convertendo a velocidade para um 'int', apenas para cortar todas
as casas decimais.
Certo, salve isso.
Agora vamos brincar.
Então, começamos a acelerar e, quando chegarmos à primeira curva, você verá que a velocidade tem um pouco
de soluço; depois, conforme ela gira em torno de outras esquinas, a agulha da velocidade diminui
um pouco, pouco.
Mas o problema é que ainda está acelerando e, se deixarmos que funcione por tempo suficiente, ele atingirá
a velocidade máxima.
Agora, a razão disso está ocorrendo porque a rotação entre o vetor de avanço dos carros e o vetor de
avanço dos cubos não é
diferente o suficiente para nos preocuparmos em aplicar os freios.
O motivo é que, se pararmos de jogar, entre no carro e vá até o seu WaypointProgressTracker.
Se você der uma olhada, você tem esse valor 'Look Ahead For Speed', que está atualmente definido como 0. 1
Agora, esse é o cubo girando, pois, à frente, ele pode olhar na pista e quanto ele
pode girar. Então, isso é como a velocidade de rotação dos cubos.
Agora, se mudarmos para algo como 1, permitirá que o cubo seja atualizado muito
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
o que isso fará é permitir que o carro aplique os freios nos cantos. Assim, quando chega à esquina, veja
que o cubo gira e gira rapidamente (e aqui em cima também o fará) e os
freios estão agora sendo muito aplicados, porque há uma grande diferença entre o carro e o cubo e
você pode ver que realmente está colocando um amortecedor na velocidade aqui.
Então, novamente, tudo se resume a "O que você procura, nisto? "e" Como você deseja que ela pareça e funcione? "
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
x 1 metro x 1 metro e, portanto, essa pista
(você pode ver que o cubo branco foi feito como um cubo unitário), não é uma
pista muito grande.
Você não pode esperar obter uma grande velocidade. Se você deseja velocidades do mundo real, também precisa ter
certeza de que sua faixa está nas coordenadas de tamanho do mundo real.
Então, vamos deixar isso aqui e, na próxima aula, começaremos a personalizar as propriedades para
criar um comportamento exclusivo do NPC.