WEBVTT

00:02.450 --> 00:05.300
O tempo é uma medida essencial nos sistemas físicos.

00:05.300 --> 00:11.210
E até o final dos anos 60, ela foi definida em termos do giro rotacional da Terra.

00:11.330 --> 00:18.020
Mas como a Terra vem diminuindo a cada ano um pouco, esta linha de base não é mais precisa o suficiente

00:18.020 --> 00:19.430
para os cientistas.

00:19.730 --> 00:26.420
Hoje, o tempo medido em segundos, é baseado na duração da rotação de um átomo radioativo.

00:27.220 --> 00:29.980
O tempo é um mecanismo fundamental utilizado nos jogos.

00:30.010 --> 00:35.710
Não só é apresentado ao jogador para desafios, mas também é usado para tudo, desde

00:35.710 --> 00:41.200
mover objetos, calcular a física, sincronizar redes e escrever shaders.

00:41.980 --> 00:47.380
Com relação à programação de inteligência artificial, o tempo é usado para mover personagens

00:47.380 --> 00:52.210
em um ambiente e sincronizar movimentos, transições e alinhá-los com animações.

00:52.630 --> 00:57.340
É também a medida básica que surge em todos os cálculos físicos.

00:57.370 --> 01:03.910
Nesta palestra, vamos analisar como os motores de jogo, em particular a unidade, trabalham

01:03.910 --> 01:11.510
com o tempo e os diferentes tipos de tempo que há em um jogo de computador vêm de inúmeras fontes.

01:11.530 --> 01:18.730
É 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

01:18.730 --> 01:23.470
em tempo real, mas no poder de processamento de seu computador.

01:23.680 --> 01:26.650
Você estará familiarizado com o método de atualização da Unidade.

01:26.740 --> 01:29.080
Isto funciona uma vez por moldura.

01:29.470 --> 01:36.520
A rapidez de execução depende de seu sistema operacional de hardware e da carga já existente em seu computador.

01:36.760 --> 01:42.610
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

01:42.610 --> 01:44.710
em computadores diferentes.

01:45.870 --> 01:49.110
A unidade também tem um método de atualização tardia.

01:49.140 --> 01:54.120
Isto funciona uma vez por quadro também, mas após as atualizações da animação.

01:54.480 --> 01:56.550
Depois há a atualização fixa.

01:56.580 --> 02:01.770
Isto ocorre no ciclo físico e pode ocorrer mais de uma vez por moldura.

02:02.310 --> 02:07.260
E por último, mas não menos importante, há o loop da interface gráfica do usuário.

02:07.290 --> 02:11.070
Também pode funcionar várias vezes por moldura.

02:11.460 --> 02:16.740
É claro que há muito mais acontecendo entre estes loops e há uma grande documentação

02:16.740 --> 02:19.050
no Manual da Unidade que o ilustra.

02:19.080 --> 02:28.020
Vale realmente a pena dar uma olhada, mas o que mais nos interessa para trabalhar com nossa IA é a atualização

02:28.020 --> 02:31.860
fixa, a atualização e a atualização tardia.

02:33.130 --> 02:37.450
Qual destes você usa dependerá do que você está tentando alcançar.

02:37.480 --> 02:43.810
Mas meu objetivo nesta palestra é examinar as diferentes velocidades nas quais eles correm e conceber

02:43.810 --> 02:46.900
uma maneira de mover uma IA em tempo real.

02:47.260 --> 02:53.380
Então, para investigar cada um desses loops, o que eu gostaria que você fizesse é criar um novo projeto

02:53.380 --> 02:57.160
de unidade e trazer o arquivo Stata, que vai com esta palestra.

02:57.460 --> 03:07.300
Nela, quando você abre a cena do tempo, então esta aqui atrás, você verá que há quatro átomos aqui dentro.

03:07.300 --> 03:10.840
Portanto, este é o bem unitário do modelo átomo.

03:10.960 --> 03:20.290
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.

03:20.320 --> 03:25.320
Se você, por sua vez, der uma olhada em cada um deles, você também notará que eles têm roteiros diferentes neles.

03:25.330 --> 03:31.120
Portanto, vamos realmente usar esses scripts para investigar os diferentes loops e a atualização.

03:31.120 --> 03:41.050
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

03:41.050 --> 03:48.520
tem atualização de segundos, o que na verdade não é um loop, mas falaremos sobre isso um pouco mais tarde.

03:48.520 --> 03:55.900
Para começar, porém, vamos abrir o roteiro do movimento de atualização que está anexado à atualização Atom.

03:56.170 --> 03:58.510
Portanto, esses roteiros estão na pasta de roteiros.

03:58.540 --> 04:01.930
Vamos abrir um movimento de atualização.

04:01.930 --> 04:04.330
Aqui está apenas o ciclo básico de atualização.

04:04.330 --> 04:06.280
Não há absolutamente nada acontecendo.

04:06.310 --> 04:10.570
O que queremos fazer é mover nosso caráter ao longo de seu eixo Z.

04:10.570 --> 04:12.880
Portanto, esse é o eixo dianteiro.

04:12.880 --> 04:18.550
Temos trabalhado com a mudança de nossos personagens desde o início, praticamente desde o início deste curso.

04:18.550 --> 04:27.280
Portanto, se você clicar em um dos átomos ou vamos pegá-lo, pressione a tecla W, ela lhe mostrará a orientação disso.

04:27.280 --> 04:32.860
Assim você pode ver que estamos trabalhando com o eixo Z, o eixo azul para empurrá-lo para frente aqui.

04:33.430 --> 04:38.410
Assim, em movimento de atualização, vamos traduzir nosso caráter ao longo do Z.

04:38.440 --> 04:50.680
Certo, então este ponto transformado traduz e acrescentaremos zero no X, zero no Y e 0. 01 F no Z.

04:51.220 --> 04:51.610
Certo.

04:51.610 --> 04:58.780
Assim, cada atualização, vai se mover ao longo de seu eixo Z em 0. 01 cada vez.

04:59.020 --> 05:00.100
Portanto, economize isso.

05:00.100 --> 05:05.380
Vamos voltar à unidade e pressionar o jogo para ver o que conseguimos.

05:05.380 --> 05:10.240
As animações que estão em todos estes personagens vão tocar automaticamente.

05:10.240 --> 05:15.640
Não os estamos afundando com qualquer movimento ou qualquer coisa que esteja lá apenas para um simples efeito.

05:15.760 --> 05:23.140
Certo, então agora você pode ver que esta primeira atualização Atom está se movendo muito bem na visão do jogo.

05:23.140 --> 05:29.020
Tenho uma visão de cima para baixo para que possamos realmente comparar as velocidades e os movimentos desses diferentes

05:29.020 --> 05:30.900
caras à medida que avançamos.

05:30.910 --> 05:37.510
Ok, vamos agora usar o mesmo código na atualização fixa e na atualização tardia.

05:37.510 --> 05:44.710
Portanto, vou apenas copiar este movimento de atualização e entraremos na atualização fixa e usaremos isso lá dentro

05:44.740 --> 05:48.160
e depois a atualização tardia e usaremos isso lá dentro.

05:48.160 --> 05:56.590
Agora, com cada uma dessas atualizações, todos os átomos estarão se movendo juntos.

05:56.590 --> 06:01.000
Se não o fizerem, então você notará que há um atraso ou um átomo mais rápido.

06:01.000 --> 06:06.880
Certifique-se de salvar tudo isso e vamos voltar e dar uma olhada nisto.

06:06.880 --> 06:10.360
Portanto, o átomo de atualização está no fundo do poço.

06:11.110 --> 06:13.870
Este aqui, então temos atrasado.

06:14.820 --> 06:17.250
Adam e Adam fixo.

06:17.250 --> 06:21.150
Vamos dar uma olhada nos resultados disto.

06:21.810 --> 06:23.730
Assim que eles começam a se mover.

06:24.180 --> 06:32.490
O que você vai descobrir é que, neste caso, o Adam fixo está realmente andando mais rápido.

06:32.490 --> 06:35.220
Portanto, estas aqui, esta é a atualização.

06:35.220 --> 06:44.260
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.

06:44.280 --> 06:51.810
A única maneira que este Adam fixo pode estar na frente é que sua atualização fixa está funcionando mais de uma

06:51.810 --> 06:59.460
vez por quadro, o que na verdade lhe dá mais chances de adicionar mais traduções do que estas duas outras.

07:00.950 --> 07:01.460
Certo.

07:01.460 --> 07:05.700
Então agora vamos dar uma olhada nos segundos.

07:05.720 --> 07:11.780
Adam, o que vamos fazer é usar o relógio do computador para mover este átomo.

07:12.200 --> 07:19.190
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,

07:19.190 --> 07:20.210
basicamente.

07:20.210 --> 07:27.140
Assim, em outro computador, esses caras possivelmente estariam correndo mais rápido ou poderiam estar indo mais

07:27.140 --> 07:29.240
devagar, dependendo do que for.

07:29.480 --> 07:35.300
Portanto, você não tem um movimento consistente entre seus personagens e isso é muito importante para

07:35.300 --> 07:36.920
a experiência do jogador.

07:37.220 --> 07:43.820
Se usarmos seu relógio de computador para mover algo em, digamos, metros por segundo, que é uma medida

07:43.820 --> 07:49.580
muito comum em sistemas físicos, então será em metros por si só, mas será a mesma taxa de movimento

07:49.580 --> 07:53.570
não importa em qual computador você o execute.

07:53.570 --> 08:01.610
Portanto, vamos entrar em nossa atualização de segundos e modificar este código para nos movermos usando o relógio.

08:01.970 --> 08:05.000
Antes de mais nada, vou apenas adicionar algumas variáveis.

08:05.000 --> 08:13.130
O que precisamos fazer é acompanhar quando nossa atualização começar, para que possamos tirar qualquer tipo de carrapato que tenha acontecido

08:13.130 --> 08:17.480
antes de chegarmos a este ponto e não usar esses carrapatos.

08:17.480 --> 08:22.040
Portanto, esse será o nosso tipo de compensação de início de tempo igual a zero.

08:22.040 --> 08:25.610
E então, só precisamos realmente instalar isso uma vez.

08:25.610 --> 08:28.010
E vou criar aqui um bool, não uma bóia.

08:28.010 --> 08:30.530
Então, o bool começou.

08:30.530 --> 08:32.750
O tempo é igual a falso.

08:33.080 --> 08:39.620
Portanto, a Unidade tem uma medida para nos dizer há quanto tempo nossa aplicação está realmente funcionando, mas precisamos saber quando

08:39.650 --> 08:44.120
esta atualização realmente aconteceu para que a aplicação pudesse ter começado a funcionar.

08:44.120 --> 08:47.690
E, 5 segundos depois, por exemplo, esta atualização começou.

08:47.690 --> 08:51.290
Queremos ter a certeza de nos livrar desses 5 segundos iniciais.

08:51.290 --> 08:57.080
Portanto, aqui dentro, se não tiver tempo de começar.

08:58.550 --> 08:59.510
Então.

09:02.170 --> 09:13.630
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

09:13.630 --> 09:20.350
afirmação, então usaremos esse tempo para realmente mover nosso caráter.

09:20.350 --> 09:29.020
Então este ponto transforma a posição do ponto, estamos definindo a posição porque isto está fazendo tic-tac.

09:29.230 --> 09:33.670
Portanto, está ficando cada vez maior e maior quanto mais tempo esta aplicação realmente funciona.

09:33.670 --> 09:38.410
Portanto, não queremos continuar traduzindo porque seria como uma espécie de tradução exponencial

09:38.410 --> 09:40.150
e levar seu caráter longe demais.

09:40.150 --> 09:43.300
Portanto, estamos apenas usando a posição para atualizar isso.

09:43.300 --> 09:45.490
Tão novo vetor três.

09:45.580 --> 09:50.380
O primeiro será o valor atual x deste personagem.

09:50.380 --> 09:58.390
Então transforme a posição do ponto x, então queremos que o Y seja o mesmo.

09:58.390 --> 10:09.790
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

10:09.790 --> 10:11.920
de nosso tempo.

10:13.360 --> 10:14.020
Compensação.

10:15.100 --> 10:15.810
Certo.

10:15.820 --> 10:16.150
Certo.

10:16.150 --> 10:16.930
Portanto, economize isso.

10:16.930 --> 10:19.990
Vamos voltar ao jogo da Unity Press e dar uma olhada.

10:19.990 --> 10:25.810
E agora este personagem estará realmente caminhando em metros por segundo.

10:25.810 --> 10:32.770
Não importa em qual computador você o coloque, ele vai funcionar no mesmo ritmo porque está usando

10:32.770 --> 10:33.910
o tempo real.

10:34.240 --> 10:42.250
E a partir disto, você pode agora ver claramente que estes outros circuitos de atualização não estão mais sincronizados

10:42.280 --> 10:44.110
com o tempo real.

10:44.110 --> 10:46.660
É apenas a velocidade do seu computador.

10:46.660 --> 10:55.660
Enquanto este outro cara que agora está saindo da moldura está indo a uma taxa consistente de metros por segundo.

10:56.740 --> 10:57.220
Certo.

10:57.220 --> 11:04.870
Portanto, esta é uma demonstração dos diferentes momentos que estão mais ou menos em ação em uma aplicação.

11:04.870 --> 11:11.200
E o que estamos procurando é ser mais como este cara aqui em segundos, onde ele é mais preciso

11:11.200 --> 11:12.070
ao relógio.

11:12.070 --> 11:17.860
Felizmente para nós, a unidade fornece algumas grandes ferramentas e já as examinamos em palestras

11:17.860 --> 11:23.290
anteriores e você pode, você sabe, embrulhar seu cérebro e ver se consegue lembrar o que foi fazer

11:23.290 --> 11:27.830
com que esses caras se movessem consistentemente dentro dessas voltas.

11:27.850 --> 11:33.700
Quando voltarmos no próximo vídeo, vamos realmente implementar isso e depois comparar o movimento

11:33.700 --> 11:35.710
de todos esses personagens.
