O tempo é uma medida essencial nos sistemas físicos.
E até o final dos anos 60, ela foi definida em termos do giro rotacional da Terra.
Mas como a Terra vem diminuindo a cada ano um pouco, esta linha de base não é mais precisa o suficiente
para os cientistas.
Hoje, o tempo medido em segundos, é baseado na duração da rotação de um átomo radioativo.
O tempo é um mecanismo fundamental utilizado nos jogos.
Não só é apresentado ao jogador para desafios, mas também é usado para tudo, desde
mover objetos, calcular a física, sincronizar redes e escrever shaders.
Com relação à programação de inteligência artificial, o tempo é usado para mover personagens
em um ambiente e sincronizar movimentos, transições e alinhá-los com animações.
É também a medida básica que surge em todos os cálculos físicos.
Nesta palestra, vamos analisar como os motores de jogo, em particular a unidade, trabalham
com o tempo e os diferentes tipos de tempo que há em um jogo de computador vêm de inúmeras fontes.
É claro, há o próprio relógio do computador, depois há o próprio motor, que também executa ciclos que não são baseados
em tempo real, mas no poder de processamento de seu computador.
Você estará familiarizado com o método de atualização da Unidade.
Isto funciona uma vez por moldura.
A rapidez de execução depende de seu sistema operacional de hardware e da carga já existente em seu computador.
Se você tentar usar a atualização como base para o tempo real em um jogo, então seu jogo será executado em velocidades diferentes
em computadores diferentes.
A unidade também tem um método de atualização tardia.
Isto funciona uma vez por quadro também, mas após as atualizações da animação.
Depois há a atualização fixa.
Isto ocorre no ciclo físico e pode ocorrer mais de uma vez por moldura.
E por último, mas não menos importante, há o loop da interface gráfica do usuário.
Também pode funcionar várias vezes por moldura.
É claro que há muito mais acontecendo entre estes loops e há uma grande documentação
no Manual da Unidade que o ilustra.
Vale realmente a pena dar uma olhada, mas o que mais nos interessa para trabalhar com nossa IA é a atualização
fixa, a atualização e a atualização tardia.
Qual destes você usa dependerá do que você está tentando alcançar.
Mas meu objetivo nesta palestra é examinar as diferentes velocidades nas quais eles correm e conceber
uma maneira de mover uma IA em tempo real.
Então, para investigar cada um desses loops, o que eu gostaria que você fizesse é criar um novo projeto
de unidade e trazer o arquivo Stata, que vai com esta palestra.
Nela, quando você abre a cena do tempo, então esta aqui atrás, você verá que há quatro átomos aqui dentro.
Portanto, este é o bem unitário do modelo átomo.
Um é chamado de átomo de atualização, uma vez chamado de átomo tardio, uma vez chamado de átomo fixo e um é chamado de átomo de segundos.
Se você, por sua vez, der uma olhada em cada um deles, você também notará que eles têm roteiros diferentes neles.
Portanto, vamos realmente usar esses scripts para investigar os diferentes loops e a atualização.
Portanto, o Update Atom tem atualização tardia, o Atom tem atualização tardia, o Atom tem atualização fixa, o Atom tem atualização fixa e o Atom
tem atualização de segundos, o que na verdade não é um loop, mas falaremos sobre isso um pouco mais tarde.
Para começar, porém, vamos abrir o roteiro do movimento de atualização que está anexado à atualização Atom.
Portanto, esses roteiros estão na pasta de roteiros.
Vamos abrir um movimento de atualização.
Aqui está apenas o ciclo básico de atualização.
Não há absolutamente nada acontecendo.
O que queremos fazer é mover nosso caráter ao longo de seu eixo Z.
Portanto, esse é o eixo dianteiro.
Temos trabalhado com a mudança de nossos personagens desde o início, praticamente desde o início deste curso.
Portanto, se você clicar em um dos átomos ou vamos pegá-lo, pressione a tecla W, ela lhe mostrará a orientação disso.
Assim você pode ver que estamos trabalhando com o eixo Z, o eixo azul para empurrá-lo para frente aqui.
Assim, em movimento de atualização, vamos traduzir nosso caráter ao longo do Z.
Certo, então este ponto transformado traduz e acrescentaremos zero no X, zero no Y e 0. 01 F no Z.
Certo.
Assim, cada atualização, vai se mover ao longo de seu eixo Z em 0. 01 cada vez.
Portanto, economize isso.
Vamos voltar à unidade e pressionar o jogo para ver o que conseguimos.
As animações que estão em todos estes personagens vão tocar automaticamente.
Não os estamos afundando com qualquer movimento ou qualquer coisa que esteja lá apenas para um simples efeito.
Certo, então agora você pode ver que esta primeira atualização Atom está se movendo muito bem na visão do jogo.
Tenho uma visão de cima para baixo para que possamos realmente comparar as velocidades e os movimentos desses diferentes
caras à medida que avançamos.
Ok, vamos agora usar o mesmo código na atualização fixa e na atualização tardia.
Portanto, vou apenas copiar este movimento de atualização e entraremos na atualização fixa e usaremos isso lá dentro
e depois a atualização tardia e usaremos isso lá dentro.
Agora, com cada uma dessas atualizações, todos os átomos estarão se movendo juntos.
Se não o fizerem, então você notará que há um atraso ou um átomo mais rápido.
Certifique-se de salvar tudo isso e vamos voltar e dar uma olhada nisto.
Portanto, o átomo de atualização está no fundo do poço.
Este aqui, então temos atrasado.
Adam e Adam fixo.
Vamos dar uma olhada nos resultados disto.
Assim que eles começam a se mover.
O que você vai descobrir é que, neste caso, o Adam fixo está realmente andando mais rápido.
Portanto, estas aqui, esta é a atualização.
Adam, sabemos que ele funciona uma vez por moldura e você pode ver que o falecido Adam também está funcionando uma vez por moldura.
A única maneira que este Adam fixo pode estar na frente é que sua atualização fixa está funcionando mais de uma
vez por quadro, o que na verdade lhe dá mais chances de adicionar mais traduções do que estas duas outras.
Certo.
Então agora vamos dar uma olhada nos segundos.
Adam, o que vamos fazer é usar o relógio do computador para mover este átomo.
O que está acontecendo com esses outros átomos é que ele está apenas executando essas atualizações o mais rápido que seu computador pode fazer,
basicamente.
Assim, em outro computador, esses caras possivelmente estariam correndo mais rápido ou poderiam estar indo mais
devagar, dependendo do que for.
Portanto, você não tem um movimento consistente entre seus personagens e isso é muito importante para
a experiência do jogador.
Se usarmos seu relógio de computador para mover algo em, digamos, metros por segundo, que é uma medida
muito comum em sistemas físicos, então será em metros por si só, mas será a mesma taxa de movimento
não importa em qual computador você o execute.
Portanto, vamos entrar em nossa atualização de segundos e modificar este código para nos movermos usando o relógio.
Antes de mais nada, vou apenas adicionar algumas variáveis.
O que precisamos fazer é acompanhar quando nossa atualização começar, para que possamos tirar qualquer tipo de carrapato que tenha acontecido
antes de chegarmos a este ponto e não usar esses carrapatos.
Portanto, esse será o nosso tipo de compensação de início de tempo igual a zero.
E então, só precisamos realmente instalar isso uma vez.
E vou criar aqui um bool, não uma bóia.
Então, o bool começou.
O tempo é igual a falso.
Portanto, a Unidade tem uma medida para nos dizer há quanto tempo nossa aplicação está realmente funcionando, mas precisamos saber quando
esta atualização realmente aconteceu para que a aplicação pudesse ter começado a funcionar.
E, 5 segundos depois, por exemplo, esta atualização começou.
Queremos ter a certeza de nos livrar desses 5 segundos iniciais.
Portanto, aqui dentro, se não tiver tempo de começar.
Então.
O tempo de início é igual ao tempo real de início e então definiremos que o tempo de início é igual a verdade para que não volte para dentro dessa
afirmação, então usaremos esse tempo para realmente mover nosso caráter.
Então este ponto transforma a posição do ponto, estamos definindo a posição porque isto está fazendo tic-tac.
Portanto, está ficando cada vez maior e maior quanto mais tempo esta aplicação realmente funciona.
Portanto, não queremos continuar traduzindo porque seria como uma espécie de tradução exponencial
e levar seu caráter longe demais.
Portanto, estamos apenas usando a posição para atualizar isso.
Tão novo vetor três.
O primeiro será o valor atual x deste personagem.
Então transforme a posição do ponto x, então queremos que o Y seja o mesmo.
Portanto, este ponto transforma o ponto posição ponto y e o valor z será o ponto tempo real desde o início menos o início
de nosso tempo.
Compensação.
Certo.
Portanto, economize isso.
Vamos voltar ao jogo da Unity Press e dar uma olhada.
E agora este personagem estará realmente caminhando em metros por segundo.
Não importa em qual computador você o coloque, ele vai funcionar no mesmo ritmo porque está usando
o tempo real.
E a partir disto, você pode agora ver claramente que estes outros circuitos de atualização não estão mais sincronizados
com o tempo real.
É apenas a velocidade do seu computador.
Enquanto este outro cara que agora está saindo da moldura está indo a uma taxa consistente de metros por segundo.
Certo.
Portanto, esta é uma demonstração dos diferentes momentos que estão mais ou menos em ação em uma aplicação.
E o que estamos procurando é ser mais como este cara aqui em segundos, onde ele é mais preciso
ao relógio.
Felizmente para nós, a unidade fornece algumas grandes ferramentas e já as examinamos em palestras
anteriores e você pode, você sabe, embrulhar seu cérebro e ver se consegue lembrar o que foi fazer
com que esses caras se movessem consistentemente dentro dessas voltas.
Quando voltarmos no próximo vídeo, vamos realmente implementar isso e depois comparar o movimento
de todos esses personagens.