Além de transformar um personagem e movê-lo ao longo de um
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).
No
Unity, um personagem possui 3 vetores locais: z para frente, y para cima e x para direita, independentemente da rotação do personagem,
podemos avançar com qualquer um desses vetores locais com a função Traduzir, especificando o movimento em
um (ou mais ) dos eixos locais x, ye z. Para mover o personagem para frente a uma velocidade
constante, modificaríamos apenas sua coordenada z. Para mover um personagem a uma velocidade constante,
modificaríamos sua coordenada x e, para mover o personagem
para cima, modificaríamos sua coordenada y.
Você também pode mover um personagem para trás, para a esquerda e para baixo, especificando uma velocidade negativa.
Se você modificar a rotação de um eixo enquanto o gira, o personagem se moverá em uma
direção mundial
diferente, no entanto, continuará se movendo ao longo do eixo especificado localmente.
Por exemplo, se um personagem muda de direção enquanto é empurrado ao longo de um eixo z, ele se moverá ao
redor do mundo,
mas, em relação a si mesmo, ainda estará se movendo ao longo do eixo z, pois são os eixos à frente dos
personagens que foram alterados no rotação e não a sua velocidade de movimento.
Então, vamos tentar isso tudo em um projeto.
Faça o download do projeto 'PushForward', que é o recurso que acompanha esta palestra e, quando você o
abrir, abra a cena dos zumbis (porque tudo fica melhor com os zumbis) e abra e dê
uma olhada no que você tem lá . Se você pressionar Play neste momento, notará que tem um zumbi animado que
não vai a lugar nenhum ... rápido e
com aparência de cubo.
Se você usar as teclas de seta, descobrirá que pode girar esse cubo e movê-lo.
Este cubo será nosso objetivo e, ao movê-lo, poderemos ver a rotação desse zumbi e como vamos empurrá-lo
para a frente.
Tudo bem, então vamos parar de jogar isso. O próprio cubo, se você estiver interessado, possui um código 'Drive' e você
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
com o nosso personagem zumbi e também tem uma rotação lá também, mas esse não
é o foco desta lição.
Estamos olhando para mover o zumbi, mudar sua direção (para que ele esteja sempre olhando para este cubo) e empurrá-lo ao longo
de seu eixo z.
Agora, se você clicar no modelo em si e dar uma olhada, verá que o eixo z está voltado para a
frente e é para isso que estamos avançando.
Portanto, crie um novo arquivo C # chamado 'MoveLocal'. Nesse script, você adicionará isso.
Portanto, é semelhante ao que tivemos na palestra anterior.
Temos um 'objetivo' que passaremos (que será nosso cubo) e teremos velocidade.
Agora, você precisará ajustar essa velocidade, com base na animação e se ela se encaixa nela. Às vezes, se a sua velocidade está
indo muito rápida ou muito lenta para a animação em particular, o personagem escorrega e há muitas
maneiras de corrigir isso, mas também não estamos entrando nessa profundidade com a
animação.
Certo.
Então, adicione isso e, na atualização, temos uma transformação. LookAt para mudar a direção em que estamos procurando
nosso zumbi, que será a posição do 'objetivo' e, em seguida, empurraremos o zumbi ao longo do eixo
z usando nossa velocidade e multiplicando-a por Time. deltaTime.
Agora estou fazendo isso na atualização e o
que eu disse antes?
Eu sempre esqueço de colocar o LateUpdate, então vamos colocar isso lá.
Agora salve isso.
Volte para o Unity e você deseja anexar esse 'MoveLocal' a Jill (Jill é
o nome do nosso zumbi) no nível mais alto. Procurando Jill no inspetor, ela terá uma transformação, um animador e,
em seguida, o script que você adicionou lá. No script, você verá que
o 'objetivo' foi exposto; então, segure seu cubo e arraste-o e solte-o como o objetivo de nível superior.
Ok, agora pressione Play e ela começará a se mover em direção ao cubo.
Agora, se afastarmos isso, por causa do LookAt, ela estará constantemente girando e olhando para o cubo.
Atualmente, todo mundo nesta cena está flutuando acima do solo, mas
você pode ajustar isso pegando seu personagem e dirigindo-o para o chão e também agarrando
seu cubo e dirigindo-o assim.
Ok, então faça outra peça.
Agora você pode ver que o personagem ainda está flutuando um pouco acima do solo
e temos o mesmo problema com a cintilação que tivemos na palestra anterior, em
que o personagem alcançará o objetivo e continuará tentando alcançá-lo. , ultrapassando levemente e voltando
e trocando de direção,
mas se você mover o cubo, ele será interrompido.
Agora ela ainda
está flutuando no ar e isso destaca outro problema com esse código específico, que é que ela vai mudar e olhar
para esse cubo, onde quer que esteja.
O LookAt não discrimina se o cubo está no ar. Então, vamos mover esse cubo assim e ver
como esse LookAt está movendo o eixo z, para que ele mude e sempre fique voltado para o cubo.
Se pausarmos isso e dermos uma olhada em Jill, você verá que o eixo z está sendo virado para a nossa posição de
cubo e isso causará muitos problemas quando você começar a mover objetos que realmente devem permanecer no chão
(como um humanóide) para olhar para a posição do objetivo que está no espaço 3D e pode estar no
ar.
Para recapitular, o que o LookAt está fazendo é girar o modelo para que o eixo z
aponte para a posição da meta.
Portanto, não importa onde o espaço 3D
esteja posicionado, o objetivo será orientar o modelo 3D, de modo que ele esteja voltado para essa direção e esse seja
um problema real para os personagens que precisam permanecer no chão.
Em vez disso, o que queremos fazer é que nosso personagem gire na direção do objeto, mas apenas
nos planos xe y, de modo que o eixo z se alinhe com a posição do objeto em um eixo vertical
a partir dele, em exatamente a mesma altura do personagem.
Portanto, precisamos que o personagem execute um LookAt em um ponto que seja o mesmo y do personagem, mas que
seja o mesmo x e z que o objeto de objetivo. Conseguir isso no Unity é apenas um
pequeno ajuste ao nosso código MoveLocal. Em vez de executar um LookAt no objetivo (que é o
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
cubo, como
você pode ver aqui , mas sua posição y é igual ao nosso personagem.
Em seguida, usamos essa nova posição que calculamos (que chamei de
lookAtGoal e a usamos dentro da LookAt. Então, depois de atualizar seu código, se você salvá-lo, volte para o Unity e
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
o zumbi caráter qualquer.
Então, ela permanece no chão e seu z não está sendo rotacionado para cima.
Está ficando paralelo ao chão.
Uma última coisa a completar nosso código é fazer com que o zumbi pare de se mover quando chegar ao local,
para que você não fique com a 'agitação'.
Primeiro, precisamos adicionar um valor de 'precisão'.
Portanto, isso é muito semelhante ao código que fizemos antes.
Vou definir isso para 1. 0f.
neste caso, e você pode ajustar isso mais tarde.
Em seguida, queremos testar a precisão antes de realizar uma tradução, para que continuemos a LookAt mesmo se estivermos
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
distância da meta, porque nunca calculamos a direção, portanto isso é um pouco
diferente do código anterior.
Mas o que realmente é gelo que vem com nossos vetores é que podemos calcular a distância entre duas posições
e podemos fazer isso com o Vector3. Distância e queremos encontrar a
distância entre a nossa localização atual (que é transformar. posição) e a posição do
objetivo.
Então objetivo. position Portanto, essa
é a sua declaração 'if' e queremos testar se a distância é maior que a nossa precisão,
o que nos permitirá seguir em frente, caso
contrário não executará o Translate.
Então, ao elaborar este Vector3. Distância entre essas duas posições, é essencialmente a mesma
coisa que encontrar a direção (ou o vetor) entre esses dois valores afastando um do outro e
depois usando o. magnitude.
É o mesmo cálculo, são apenas diferentes maneiras de resolver isso. Então você pode entrar aqui e calcular a
direção e obter a magnitude desse vetor, ou pode usar esta função de distância.
Certo.
Então salve isso e agora vamos voltar para o Unity e executá-lo ... e dirigir por aí ... vamos dirigir um pouco mais perto.
Agora ainda podemos ver, neste caso, que ficamos 'nervosos'.
A razão é que a nossa distância atual está calculando-a entre a distância do cubo real e a distância do
zumbi, mas o zumbi não está tentando
chegar à posição do cubo, está tentando chegar à posição que está embaixo do
cubo em a mesma altura.
Portanto, há muito pouca esperança (especialmente se esse cubo estiver no ar) por estar próximo a ele,
porque não é permitido mover-se em uma direção ascendente.
Então, faremos esse pequeno ajuste no nosso código, de volta aqui. Em vez de tentar obter a distância
entre nosso personagem e a posição do objetivo, o que pode não ser possível porque
essa posição está no ar, em vez disso, queremos apenas obter o LookAt.
Então, vamos colocar isso lá, salvá-lo e voltar e correr.
Agora, quando o zumbi se aproxima o suficiente do nosso cubo, ele pára de se mover.
É claro que a animação ainda está em execução, mas
não estamos trabalhando com isso no momento e não importa o quão alto você mova isso e a
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.
Então agora eu posso dirigir este cubo e o zumbi ainda o seguirá, mas permanecerá no chão ...
e quando chegarmos perto o suficiente, ele irá parar.
É assim que você move um personagem ao longo de seu eixo dianteiro.