WEBVTT

00:06.500 --> 00:10.760
No vídeo anterior, escrevemos The Idol and the Patrol States.

00:10.760 --> 00:18.020
Agora precisamos criar o A. I. classe, que aqui colocaremos em guarda para que ele seja capaz de

00:18.020 --> 00:19.640
fazer a transição através dos estados.

00:19.640 --> 00:28.730
Portanto, vamos clicar com o botão direito do mouse e criar um roteiro afiado em C chamado AI e vamos abri-lo.

00:29.150 --> 00:33.930
Você vai se surpreender o quão curto é este código?

00:33.940 --> 00:40.190
Portanto, este é o código que iremos anexar ao nosso NPC, que é a UG neste caso.

00:40.550 --> 00:44.420
Antes de mais nada, precisamos nos certificar de agarrar o material de malha de navegação.

00:44.420 --> 00:49.850
Assim, usando o motor de unidade AI no topo.

00:49.910 --> 00:56.810
E então também queremos receber todos os pedaços e peças que precisamos enviar para nossos estados.

00:56.810 --> 00:59.720
Portanto, precisamos de nosso agente de malha de navegação.

01:00.650 --> 01:02.960
Precisamos do animador.

01:03.560 --> 01:12.730
Um pouco mais tarde precisaremos do jogador também porque precisamos fazer seu NPC perseguir o jogador.

01:12.740 --> 01:15.590
Portanto, vamos apenas colocar um público.

01:16.950 --> 01:26.280
Transforme o jogador lá dentro e criaremos nosso estado, que é o estado atual.

01:26.970 --> 01:28.500
Portanto, é tudo o que precisamos lá.

01:28.500 --> 01:33.630
Só temos que lembrá-lo para dar o jogador a este código no inspetor.

01:33.870 --> 01:37.620
Logo no início, vamos agarrar nossos agentes.

01:39.210 --> 01:40.260
Agente de malha NAV.

01:40.260 --> 01:44.790
Assim, o agente se iguala a este ponto para obter o componente.

01:47.000 --> 01:49.520
Agente de malha NAV.

01:51.110 --> 01:56.000
E o animador, eles ganham componente.

01:57.280 --> 01:58.450
Animador.

02:00.810 --> 02:03.840
E então criaremos nosso primeiro estado.

02:03.840 --> 02:08.610
Portanto, o estado atual será igual a um novo ídolo.

02:09.840 --> 02:13.350
E para isso, precisamos passar por todos os pedaços e peças.

02:13.350 --> 02:15.590
Portanto, este NPC em particular.

02:15.600 --> 02:17.730
Portanto, este jogo é um objeto.

02:18.630 --> 02:24.570
Depois, precisa do agente, do animador e do jogador.

02:24.600 --> 02:33.900
Agora você poderia fazer um componente dentro de seus estados e simplesmente passar pelo objeto do jogo, exceto que estamos criando

02:33.900 --> 02:37.020
e destruindo novos estados o tempo todo.

02:37.020 --> 02:40.050
E assim vai acabar ficando um pouco atrasado.

02:40.050 --> 02:45.030
E eu tenho uma pequena admissão de que mais tarde chegaremos a um componente dentro de um

02:45.030 --> 02:45.900
dos estados.

02:45.900 --> 02:51.630
Mas há uma forma de contornar isso voltando aqui e certificando-se de que você pegue tudo logo no início,

02:51.630 --> 02:53.850
quando o A. I. é criado.

02:53.970 --> 03:02.490
Agora, em atualização, se você tiver criado algum A. I. antes, a atualização é onde toda a mágica acontece

03:02.490 --> 03:06.540
e a atualização pode ficar como o verdadeiro código do esparguete.

03:06.770 --> 03:12.180
Pode ficar muito, muito confuso e muito difícil de depurar e difícil de acertar.

03:12.690 --> 03:22.830
Mas usando estes estados aqui, colocamos o estado atual vai igualar o processo de ponto de estado atual.

03:23.250 --> 03:32.070
Portanto, lembre-se que o processo nos estados está trabalhando através da entrada da atualização e depois da saída e depois,

03:32.070 --> 03:38.340
quando chega à saída, retorna ao próximo estado para o qual precisa ir, nem mesmo sair.

03:38.340 --> 03:45.450
Se chegar a algum lugar na atualização que precisa jogar fora, ele define o novo estado seguinte,

03:45.450 --> 03:48.810
que depois é passado de volta na saída.

03:48.810 --> 03:49.850
Vamos apenas nos lembrar.

03:49.850 --> 03:54.990
Portanto, voltemos ao estado e subamos ao topo onde tudo isso está acontecendo aqui em processo.

03:54.990 --> 03:58.410
Portanto, provavelmente é muito mais fácil de explicar se estamos realmente olhando para isso.

03:58.410 --> 04:03.960
Portanto, o processo vai correr a partir da IA que o pede.

04:03.990 --> 04:07.920
E então, se a etapa for entrada, ela vai executar a entrada.

04:07.920 --> 04:12.480
O enter então vai garantir que a etapa seja atualizada para atualização.

04:12.480 --> 04:19.290
Portanto, da próxima vez que o processo de atualização de IA for chamado, ele vai executar esta

04:19.290 --> 04:27.450
atualização e vai continuar fazendo isso até que a própria atualização o leve ao estado de saída, quando a saída é

04:27.450 --> 04:31.680
executada e depois retorna, seja qual for o novo estado.

04:31.680 --> 04:38.610
E se tivermos um olhar ocioso, podemos ver isso acontecendo aqui mesmo, onde um novo estado está sendo criado

04:38.610 --> 04:40.290
para ser patrulhado.

04:40.290 --> 04:44.970
Assim, com uma chance de 10% de ociosidade, entraremos em uma patrulha.

04:45.710 --> 04:49.260
Muito bem, então essa é a sua classe de IA.

04:49.260 --> 04:49.890
É isso aí.

04:49.890 --> 04:51.420
É tudo o que precisamos lá dentro.

04:51.420 --> 04:55.830
E você sabe, você pode acrescentar algumas outras coisas se quiser, mas no que diz respeito ao comportamento,

04:55.830 --> 04:57.420
isso é tudo o que precisamos.

04:57.420 --> 05:00.360
E continuamos acrescentando mais estados e ligando-os.

05:00.720 --> 05:02.220
Ok, então vamos salvar isso.

05:02.220 --> 05:03.960
Agora volte para a Unidade.

05:03.960 --> 05:07.980
Você quer arrastar e soltar esse código II para a ARG.

05:07.980 --> 05:13.920
Então, encontre a ARG em sua hierarquia, arraste e solte essa IA para lá.

05:14.010 --> 05:20.700
Agora temos um controlador PHP que terá vindo com seu projeto para que você possa andar por aí,

05:21.420 --> 05:27.840
pegar aquilo e arrastar aquilo para o jogador transformar a parte que está exposta.

05:28.170 --> 05:32.250
Mais uma vez, não entra em jogo, mas será um pouco mais tarde.

05:32.460 --> 05:32.970
Muito bem.

05:32.970 --> 05:36.360
Por isso, agora estamos prontos para pressionar o jogo e dar uma olhada.

05:36.360 --> 05:39.810
Então, deixe-me apenas fazer esta tela de jogo um pouco maior.

05:39.810 --> 05:40.920
Peça de imprensa.

05:41.520 --> 05:41.820
Muito bem.

05:41.820 --> 05:48.390
Assim, você pode usar as teclas WASD para se mover em torno de todas as teclas de seta para este controlador de jogador e podemos

05:48.390 --> 05:49.710
caminhar até a ARG.

05:49.710 --> 05:51.750
Ele ainda não está programado para nos atacar.

05:51.840 --> 05:58.470
Agora ele está com 10% de chance de ir em patrulha, mas não parece estar.

05:58.470 --> 06:03.090
Agora sei por que isto acontece, e vou voltar e mostrar-lhes isso em um momento.

06:03.090 --> 06:06.660
Mas por enquanto você pode, eu acho, apenas aproveitar seu estado de ociosidade.

06:06.810 --> 06:09.570
E é assim que ele se parece quando está ocioso.

06:09.600 --> 06:14.850
Ok, então basta pressionar a tecla escape para recuperar o cursor do mouse e parar de jogar e vamos

06:14.850 --> 06:16.890
apenas voltar ao código do estado.

06:16.890 --> 06:20.640
Deixe-me mostrar-lhe onde essa questão está ocorrendo.

06:21.000 --> 06:21.460
Certo.

06:21.510 --> 06:32.040
Portanto, a parte realmente, realmente importante de todo este sistema estatal é que isto aqui funciona bem para

06:32.040 --> 06:34.260
ir de uma coisa a outra.

06:34.260 --> 06:40.170
Então, entramos em atualização, atualizamos, atualizamos, atualizamos enquanto você precisar

06:40.170 --> 06:46.400
atualizar e depois entramos na saída e depois retornamos ao próximo estado para o qual precisamos ir.

06:47.010 --> 06:50.970
O que está acontecendo no inativo e eu provavelmente fiz isso errado também na patrulha.

06:50.970 --> 06:53.340
Se formos para ociosos, vamos dar uma olhada.

06:53.340 --> 06:59.130
A entrada está sendo feita no momento, está ociosa e depois está funcionando.

06:59.130 --> 07:00.240
Sua base é a entrada.

07:00.240 --> 07:07.140
Agora sua base de entrada é a atualização de eventos, o que é ótimo porque da próxima vez que o processo chegar, ele irá

07:07.140 --> 07:08.700
executar a atualização.

07:09.060 --> 07:13.710
Agora vamos voltar para a atualização.

07:13.710 --> 07:17.670
Portanto, agora estamos chegando para atualizar com uma chance aleatória.

07:17.810 --> 07:19.600
Começamos a patrulhar.

07:19.880 --> 07:26.120
Em seguida, preparamos o evento para sair do palco, o que é tudo muito bom porque isso vai nos levar

07:26.120 --> 07:29.630
ao próximo estágio dentro de nosso processo.

07:30.530 --> 07:31.250
Mas será que sim?

07:31.250 --> 07:36.800
Porque olhemos para baixo, estamos executando esta atualização baseada e se subirmos

07:36.890 --> 07:44.180
e dermos uma olhada no que faz, ela está indo em frente e preparando nosso cenário de volta para a atualização.

07:44.180 --> 07:47.780
Portanto, mesmo que o tenhamos definido para sair, ele só vai voltar para ser atualizado.

07:47.780 --> 07:50.990
Portanto, na verdade, não precisamos chamá-lo aqui.

07:50.990 --> 07:59.690
E então fazer isso aqui está apenas destruindo nosso código para que você possa se livrar dele, pois não está fazendo

07:59.690 --> 08:00.830
muito por nós.

08:01.160 --> 08:05.540
Ou você poderia colocá-lo acima desta declaração e permitir que a declaração se modifique.

08:05.540 --> 08:07.580
Portanto, vamos nos livrar disso.

08:07.580 --> 08:13.250
Agora vou apenas verificar se não fiz isso também na patrulha, porque isso nos dará a mesma pequena

08:13.250 --> 08:18.230
situação mais tarde, pois não estamos realmente trocando de patrulha.

08:18.230 --> 08:21.260
Quando entramos em uma patrulha, ficamos presos ali para sempre no momento.

08:21.260 --> 08:29.210
Vamos nos livrar desta atualização porque é uma espécie de atualização de configuração supérflua para atualizar constantemente.

08:30.400 --> 08:30.970
Certo.

08:30.970 --> 08:35.680
Portanto, agora que estamos confiantes ou estou confiante de que isto vai funcionar, vamos salvá-lo.

08:35.770 --> 08:43.480
Voltaremos ao jogo da Unity Press e depois vamos ver.

08:43.870 --> 08:48.280
Assim você pode ver que ele saiu imediatamente em patrulha.

08:48.730 --> 08:50.470
Portanto, 10% de chance.

08:50.950 --> 08:52.720
Isso é verificar isso.

08:52.720 --> 08:53.530
10% de chance.

08:53.530 --> 08:54.730
Cada atualização.

08:54.730 --> 08:55.900
Portanto, isso é bastante rápido.

08:56.380 --> 09:02.230
E agora ele vai caminhar entre todos os pontos de passagem.

09:04.320 --> 09:12.090
Agora ele não os está pegando em ordem porque vai depender de como o ambiente do jogo vai em frente e atualiza

09:12.090 --> 09:14.260
esses waypoints.

09:14.280 --> 09:17.100
Ele passará, no entanto, um a um.

09:17.100 --> 09:25.350
Portanto, neste caso, a ordem que os objetos de jogo com código de tag que temos no ambiente do jogo está fazendo com

09:25.350 --> 09:27.960
que eles se cruzem como um padrão.

09:28.200 --> 09:33.840
Às vezes, isso os coloca em um padrão quadrado, mas desta vez não é.

09:34.440 --> 09:40.830
Então ele vai apenas patrulhar e ir entre todos esses pontos para sempre e sempre.

09:43.950 --> 09:44.310
Muito bem.

09:44.310 --> 09:50.100
Agora, você provavelmente está pensando neste ponto, como posso ter meus waypoints na ordem certa?

09:50.160 --> 09:55.260
Bem, uma maneira de fazê-lo é posicioná-los de acordo com seu nome.

09:55.260 --> 10:01.080
Portanto, se tivermos um olhar na hierarquia, temos estes pontos de verificação como

10:01.080 --> 10:05.880
este e eles estão situados de modo que eles contornam o mapa real.

10:06.360 --> 10:15.420
Se você quiser pegá-los em ordem alfabética, então você poderia usar o nome deles e usar um link de sistema

10:15.420 --> 10:16.660
ali dentro.

10:16.680 --> 10:23.880
Portanto, se você entrar no código do seu ambiente de jogo onde você está realmente pegando aqueles pontos de verificação para fazer isso,

10:23.880 --> 10:27.600
você só tem que adicionar duas linhas de código, o que eu já fiz aqui.

10:27.690 --> 10:30.030
A primeira no topo é nossa biblioteca.

10:30.030 --> 10:37.740
Portanto, acrescente um link de pontos do sistema que lhe permitirá fazer um pouco de ordem na sua lista.

10:37.740 --> 10:41.100
E você pode ver isso aqui embaixo depois que criamos a instância.

10:41.100 --> 10:51.630
Portanto, os pontos de verificação instantânea vão se igualar aos pontos de verificação instantânea ordenados pelo nome dos pontos de passagem.

10:52.620 --> 10:57.120
E depois estamos apenas colocando de volta na lista e colocando-a de volta em nossos pontos de controle.

10:57.120 --> 11:04.380
Portanto, isto os reordenará em ordem alfabética, ascendendo em ordem alfabética do nome.

11:04.380 --> 11:09.810
Assim, você poderia passar e renomeá-los como waypoint um waypoint para 8. 3, o que você quiser, desde que estejam em ordem

11:09.810 --> 11:13.180
alfabética e depois tenham essa ordem em particular.

11:13.200 --> 11:20.130
É porque estamos fazendo uma busca de objetos de jogo com TAG que não podemos nunca ter certeza da ordem real

11:20.130 --> 11:26.220
em que vamos conseguir esses objetos de jogo, mas podemos então forçar uma ordem usando isso.
