WEBVTT

00:03.160 --> 00:09.730
Na palestra anterior, montamos as bases de nossa árvore de comportamento e imprimimos os nós reais e a estrutura

00:09.730 --> 00:11.560
em que eles entram.

00:11.590 --> 00:15.120
Agora os nós no fundo são os nós da folha.

00:15.130 --> 00:21.010
São eles que vão fazer o trabalho e fazer com que nosso agente, que é nosso assaltante neste caso, se movimente

00:21.010 --> 00:25.330
de fato no mapa, que está simulando que ele está realmente fazendo algo.

00:25.330 --> 00:31.450
Portanto, o primeiro conjunto de comportamentos que temos é ir para Diamond e depois voltar para a van.

00:31.600 --> 00:32.050
Certo.

00:32.050 --> 00:38.500
Portanto, antes de mais nada, nosso pequeno agente aqui embaixo, nosso ladrão, se você clicar nele na

00:38.500 --> 00:44.830
hierarquia e der uma olhada no inspetor, você verá que ele já tem um agente de malha de navegação ali.

00:44.830 --> 00:49.780
Por isso, precisamos de ter acesso a esse agente de malha de navegação dentro do roteiro.

00:49.900 --> 00:57.580
Também precisamos saber nesse roteiro a localização do diamante, que está nesta parte

00:57.580 --> 01:01.150
da galeria e também a van que está aqui.

01:01.330 --> 01:04.270
E esses dois objetos estão na hierarquia, é claro.

01:04.270 --> 01:08.860
Assim, nós os temos também, e podemos passá-los para o roteiro para o ladrão.

01:08.860 --> 01:13.600
Portanto, vamos entrar ali e subir aqui em cima.

01:13.600 --> 01:15.310
Nós vamos passar esses para dentro.

01:15.310 --> 01:20.830
Portanto, queremos um objeto de jogo público e esse será nosso diamante.

01:21.940 --> 01:24.610
E depois queremos um objeto de jogo público.

01:26.450 --> 01:27.380
Van.

01:27.680 --> 01:31.160
Agora também queremos criar aqui nosso agente de malha de navegação.

01:31.160 --> 01:37.250
Então, para cima, vamos usar o ponto I do motor unitário.

01:38.180 --> 01:42.590
E então, aqui embaixo, podemos realmente criar nosso agente.

01:42.590 --> 01:46.340
Portanto, é um agente de malha de navegação.

01:46.910 --> 01:57.530
E para conseguirmos isso logo no início, vamos agente igual a este ponto obter agente de malha de navegação

01:57.860 --> 01:59.960
componente.

02:01.160 --> 02:05.870
Certo, então agora podemos realmente orientá-lo a ir ao diamante.

02:05.870 --> 02:15.410
Assim, se colocarmos no início aqui, por exemplo, o agente definirá o destino e passará pela posição de transformação do diamante,

02:15.680 --> 02:22.550
ele então se moverá para lá independentemente do que a árvore estiver fazendo.

02:22.550 --> 02:25.610
Isto é apenas um teste de nosso agente montado com nossa malha de navegação.

02:25.610 --> 02:30.110
Portanto, basta salvar isso e entraremos em unidade.

02:30.260 --> 02:32.060
Selecione a borracha.

02:32.090 --> 02:36.020
Agora você vai encontrar Diamond e Van expostos nesse roteiro.

02:36.020 --> 02:41.510
E assim você pode agarrar o diamante, que na verdade está preso a este objeto chamado plinto.

02:41.660 --> 02:44.660
E vamos arrastar e soltar isso em diamante.

02:44.660 --> 02:50.540
E a van em si está aqui em cima, fuga de furgão e arraste-a e solte-a ali.

02:50.570 --> 02:50.840
Certo.

02:50.840 --> 02:58.220
Agora, quando pressionarmos o jogo, aquele agente definirá o destino para que ele se mova ao longo de nossa malha de navegação.

02:58.220 --> 03:04.730
Ele vai atravessar a abertura mais próxima que é atualmente aquela porta, porque na verdade é apenas um objeto

03:04.730 --> 03:08.600
vazio sem nenhum colisor em particular ou qualquer coisa.

03:08.600 --> 03:10.610
E ele vai até o diamante.

03:10.610 --> 03:13.910
Muito bem, então sabemos que a parte de malha de navegação está agora funcionando.

03:13.910 --> 03:18.140
Temos de ligar tudo isso com uma ação real.

03:18.440 --> 03:23.240
Portanto, uma ação tem um processo associado a ela.

03:23.240 --> 03:28.010
Vamos voltar ao nosso código para o nó e nos lembrar o que está acontecendo.

03:28.010 --> 03:35.420
Configuramos este status para que cada nó retorne ao sucesso se estiver terminado e foi bem sucedido

03:35.420 --> 03:41.570
se ainda estiver funcionando e falhou se estiver terminado e falhou de fato.

03:41.840 --> 03:46.400
Então, há três coisas agora, de onde elas realmente são devolvidas?

03:46.400 --> 03:53.420
Bem, eles são devolvidos do processo que acontece dentro de cada nó e dependendo do tipo de

03:53.420 --> 03:56.300
nó dependerá do tipo de processo.

03:56.300 --> 04:05.750
Então vamos descer aqui e eu vou acrescentar um novo processo de status virtual público e este processo aqui,

04:05.750 --> 04:10.910
que é basicamente apenas o nível do nó, porque vamos anular tudo

04:10.910 --> 04:18.890
isso, vamos retornar status ponto de sucesso como padrão para aquele nó em particular.

04:18.920 --> 04:19.110
Certo.

04:19.190 --> 04:20.630
Portanto, poupe isso.

04:20.630 --> 04:26.720
Agora vamos entrar em nossa árvore de comportamento e dar-lhe um processo.

04:26.720 --> 04:32.780
Assim, na árvore de comportamento, nós vamos entrar aqui

04:33.830 --> 04:43.220
e, acima de tudo, colocaremos em um processo de status de anulação pública como esse.

04:43.220 --> 04:46.550
Agora, não estamos devolvendo o que a base faz neste caso.

04:46.550 --> 04:54.380
O que vamos realmente retornar nesta árvore é o que a criança retornar, porque lembre-se que sua árvore

04:54.380 --> 04:59.690
de comportamento tem que correr, seus filhos não correm sozinhos.

04:59.690 --> 05:02.600
Assim, cada nó, se tiver crianças, ele corre as crianças.

05:02.600 --> 05:07.310
E então, com base no que as crianças respondem, torna-se esse status.

05:07.310 --> 05:16.310
Por isso, aqui vou correr criança de volta ponto de criança atual.

05:17.020 --> 05:18.130
Processo.

05:18.850 --> 05:23.920
Então o que quer que retorne, esse será o status retornado pela árvore de comportamento.

05:23.920 --> 05:30.580
E isto realmente faz com que a árvore de comportamento execute então o processo de objetos infantis.

05:30.610 --> 05:38.890
Agora, neste caso, os objetos de nossos filhos, se voltarmos para nosso ladrão, vão para o diamante e vão para

05:38.890 --> 05:39.270
Van.

05:39.280 --> 05:45.910
Agora, atualmente, se eles correm, eles são apenas nós básicos, então eles vão voltar.

05:46.540 --> 05:52.630
O sucesso, que é praticamente inútil para nós neste momento, significa que eles não estão realmente fazendo nada.

05:52.630 --> 05:58.960
Portanto, precisamos criar outra classe para as folhas ou uma folha.

05:58.960 --> 06:00.670
Portanto, vamos voltar à unidade.

06:00.790 --> 06:07.060
Vamos clicar com o botão direito em nossa árvore de comportamento, criar um novo roteiro, vamos chamá-lo de Folha.

06:07.090 --> 06:10.060
Em seguida, abriremos isso no editor.

06:10.060 --> 06:15.190
Agora a Leaf vai herdar do Nodo.

06:16.150 --> 06:20.530
Não vai ter um começo em uma atualização para que possamos nos livrar disso.

06:20.560 --> 06:25.870
Agora, a folha em si, isto vai ser um pouco mais complicado porque as folhas têm que realmente executar

06:25.870 --> 06:31.060
um processo particular, o que significa que vai haver algum método designado para a folha.

06:31.060 --> 06:33.610
Não sabemos qual é esse método.

06:33.610 --> 06:35.380
Pode ser qualquer coisa.

06:35.680 --> 06:43.030
Portanto, neste caso, vai ser para começar a correr aquele destino de agentes definidos.

06:43.570 --> 06:45.670
É isso que queremos que ele faça porque estamos usando uma malha nativa.

06:45.670 --> 06:52.210
Mas se você estiver usando algum outro tipo de IA em seu sistema, você pode querer executar uma máquina de estado

06:52.210 --> 06:56.470
finito ou pode querer executar uma rede neural ou algo assim.

06:56.470 --> 07:03.430
Mas o que quer que esses processos façam, eles devem acabar retornando um de nossos status de nó.

07:03.430 --> 07:08.080
Portanto, ou o sucesso, o fracasso ou a corrida.

07:08.380 --> 07:17.170
Agora o que vamos fazer com estes nós de folha é realmente criar um delegado para que possamos passar por métodos, para que possamos codificar

07:17.170 --> 07:21.370
métodos em outro lugar e depois passar por eles e dizer, Isto é o que queremos

07:21.370 --> 07:23.620
que nossa folha funcione.

07:23.650 --> 07:23.900
Está bem?

07:23.920 --> 07:29.950
Agora a maneira como fazemos isso é criar um delegado público e ele vai retornar um status de nó.

07:29.950 --> 07:35.350
Portanto, vamos apenas colocar status e estes serão chamados de tick.

07:35.830 --> 07:41.110
Portanto, um tick é essencialmente uma rotatividade para sua árvore de comportamento.

07:41.140 --> 07:48.430
Um tique é como uma moldura para a árvore de comportamento, assim como uma moldura acontece quando você executa uma atualização em unidade.

07:48.460 --> 07:48.590
Certo.

07:48.610 --> 07:56.020
Portanto, é apenas uma espécie de folha em torno dessa folha em particular ou ação neste caso, então precisamos

07:56.020 --> 07:58.630
de um ponteiro para montar.

07:58.630 --> 08:06.310
Portanto, o método do processo de tic público e é assim que o fazemos lá.

08:06.370 --> 08:10.480
Então, vamos anular nosso processo.

08:10.480 --> 08:20.770
Então, o processo de anulação pública novamente, nos livramos desta base e, em vez disso, o que vamos retornar

08:20.770 --> 08:28.390
é o método de processo e o método de processo, ele vai retornar o status.

08:28.660 --> 08:34.150
Portanto, isto está realmente funcionando para nós, contanto que este método de processo seja estabelecido aqui.

08:34.150 --> 08:44.470
Portanto, aqui em cima eu poderia apenas colocar se o método de processo não for igual a nulo, podemos devolver isso.

08:44.470 --> 08:50.410
Caso contrário, podemos devolver um ponto de status de falha.

08:50.800 --> 08:52.900
Oh, o que esta Pennie está fazendo.

08:52.930 --> 08:53.620
Verificação de erros.

08:53.620 --> 08:53.980
Sim, eu sei.

08:53.980 --> 08:58.540
É muito raro para mim fazer isso, mas já o fiz por você lá.

08:58.930 --> 08:59.530
Certo.

08:59.530 --> 09:04.060
E isso também irá lembrá-lo se você realmente não tiver estabelecido um método para sua folha.

09:04.600 --> 09:06.010
Pronto, então já fizemos isso.

09:06.010 --> 09:10.120
Como a folha sabe sobre o método do processo?

09:10.120 --> 09:15.550
Bem, nós poderíamos ir no comportamento um comportamento e então realmente atribuí-lo lá dentro.

09:15.550 --> 09:22.360
Poderíamos ter gostado de ir ao método do processo diamante ponto igual a este método em particular ou poderíamos

09:22.360 --> 09:26.560
passá-lo através de uma anulação de nosso construtor.

09:26.560 --> 09:31.570
Portanto, queremos uma folha pública que não tenha praticamente nada nela.

09:31.600 --> 09:33.100
Esse é o nosso vazio.

09:33.250 --> 09:39.610
E depois queremos uma folha pública e vamos passar por um fio para o nome

09:39.610 --> 09:43.420
e depois queremos processar o método pm.

09:45.300 --> 09:46.440
Eu gosto disso.

09:46.440 --> 09:55.320
E vamos então sentar-nos com os nomes igual n e p m.

09:56.610 --> 10:01.470
Método de processo para igualar p m como esse.

10:01.470 --> 10:03.480
Agora, isto não está certo.

10:03.480 --> 10:06.630
Deve ser um carrapato como esse.

10:06.900 --> 10:08.040
Por isso, estamos passando por ela.

10:08.070 --> 10:12.810
Isto é basicamente um ponteiro para nosso método que estamos escrevendo, passando por ele, e depois o estamos

10:12.810 --> 10:13.770
instalando até aqui.

10:13.770 --> 10:20.400
Assim, esse método de processo sabe onde ele está aqui embaixo e o executará realmente para nós e vamos nos livrar daquele ponto-e-vírgula

10:20.400 --> 10:22.410
para que ele não goste dele.

10:22.530 --> 10:25.380
Ok, então agora vamos salvar isto.

10:25.500 --> 10:30.420
Vamos voltar ao nosso ladrão e implementá-lo.

10:30.420 --> 10:36.690
Assim, estes diamantes e furgões agora se transformam em folhas assim.

10:36.690 --> 10:46.170
E agora eles estão querendo ser construídos a partir de folha e folha e eles realmente precisam ter algum tipo de método

10:46.170 --> 10:48.300
de passagem também.

10:48.300 --> 10:54.240
Portanto, vamos em frente e escrever algo realmente rápido que satisfaça isso.

10:54.360 --> 11:01.590
Portanto, aqui embaixo, vamos criar um status de nó público.

11:01.590 --> 11:04.890
Tem que estar no mesmo formato em que o carrapato é construído.

11:04.890 --> 11:08.700
Então vá ao diamante dessa maneira.

11:08.700 --> 11:14.730
E quando vamos ao diamante, na verdade queremos estar basicamente executando isto aqui.

11:14.730 --> 11:19.470
Portanto, vamos tirar isso de lá e vamos colocá-lo aqui dentro.

11:19.980 --> 11:20.430
Está bem?

11:20.580 --> 11:23.640
E então temos que devolver algo.

11:23.640 --> 11:25.650
Portanto, vamos voltar.

11:26.700 --> 11:30.480
E, neste caso, vamos fazer disso um sucesso.

11:30.480 --> 11:37.710
Assim, devolveremos o status de ponto de nó, ponto de sucesso.

11:38.520 --> 11:44.940
Agora note aqui que o retorno do sucesso aqui não tem realmente nada a ver se seu agente realmente

11:44.940 --> 11:47.010
chegou ao destino ou não.

11:47.010 --> 11:50.520
Porque, neste momento, não estou realmente preocupado com isso.

11:50.910 --> 11:53.190
Eu só quero algo que você possa ver ao correr.

11:53.190 --> 11:53.460
Certo.

11:53.460 --> 11:59.220
Em seguida, subindo em sua folha de diamante, vamos passar, vamos para o diamante.

11:59.430 --> 12:07.110
E agora a van também precisa de um método para passar por ela.

12:07.110 --> 12:09.690
Muito bem, então agora é hora de um desafio.

12:09.690 --> 12:20.370
O que eu gostaria que você fizesse é escrever um "go to Van método" e colocá-lo aqui com sua folha e escrevê-lo semelhante ao que nós temos

12:20.370 --> 12:22.440
para ir ao Diamond.

12:22.440 --> 12:24.060
Não complique muito as coisas.

12:24.060 --> 12:26.310
Resolveremos tudo isso um pouco mais tarde.

12:26.310 --> 12:27.960
Nós só queremos algo que vai funcionar.

12:27.960 --> 12:29.400
Portanto, siga este formato aqui.

12:29.400 --> 12:30.120
Pausa o vídeo.

12:30.120 --> 12:33.810
Agora, quando voltarmos, eu lhes mostrarei como fazer isso.

12:35.130 --> 12:35.850
Certo.

12:35.880 --> 12:36.810
Como você foi?

12:36.810 --> 12:43.470
Bem, realmente, tudo o que você precisava fazer era pegar isto, copiá-lo e colocá-lo aqui.

12:43.500 --> 12:47.040
Ligue, vá até a van e depois desça.

12:47.040 --> 12:48.450
E seu destino definido.

12:48.450 --> 12:50.610
Você só quer colocar uma van.

12:50.940 --> 12:56.580
E depois, aqui em cima, em sua folha, vamos para a van.

12:58.680 --> 12:59.100
Muito bem.

12:59.100 --> 13:04.050
Portanto, antes de podermos brincar, temos que dar um pontapé na árvore com um processo, porque ela não está realmente

13:04.050 --> 13:05.430
executando seu processo.

13:05.430 --> 13:11.310
E se entrarmos em nosso código de árvore de comportamento, você verá que ele está pronto para executar a primeira criança aqui em

13:11.310 --> 13:11.850
processo.

13:11.850 --> 13:13.530
Mas não estamos chamando isso.

13:13.530 --> 13:21.660
Portanto, de volta ao nosso código, na verdade, precisamos fazer um processo de pontos de árvore como esse para dar o pontapé inicial.

13:21.660 --> 13:25.650
Agora, olhando novamente através de nossa árvore, aqui está nossa árvore.

13:25.650 --> 13:31.080
Temos então um nó intermediário que é apenas um nó genérico no momento.

13:31.080 --> 13:36.750
Modificaremos isso para outra coisa um pouco mais tarde, mas estamos deixando isso no Nó quatro.

13:36.750 --> 13:42.300
Agora, se entrarmos no Nodo e dermos uma olhada no processo dos nós, você pode ver

13:42.300 --> 13:50.550
que ele vai retornar o sucesso, o que é meio inútil para nós porque queremos que ele vá e realize seus eventos infantis.

13:50.550 --> 13:56.610
Portanto, em vez disso, vou apenas substituir isto aqui pelo mesmo

13:56.610 --> 14:04.410
código que tenho na árvore de comportamento, que vai ser o ponto de criança atual.

14:05.290 --> 14:06.130
Processo.

14:06.160 --> 14:11.710
Agora, isto ainda não é perfeito, mas é o suficiente para realmente colocar parte de nossa árvore em funcionamento.

14:11.710 --> 14:12.940
Portanto, economize isso.

14:12.940 --> 14:21.730
Salve seu comportamento de borracha e, em seguida, vamos lá e aperte o jogo só para que você possa ver algo funcionando no final

14:21.730 --> 14:22.500
aqui.

14:22.510 --> 14:23.440
Muito bem, ótimo.

14:23.440 --> 14:24.090
Lá vamos nós.

14:24.100 --> 14:25.660
Então, ele vai embora.

14:25.810 --> 14:33.400
Ele passou do nível superior da raiz da árvore para o aço para baixo para ir para o diamante.

14:33.520 --> 14:35.650
Agora, ele vai parar por aí.

14:35.650 --> 14:40.630
Ele não vai dar a volta e voltar para a van, porque se você der uma olhada no código, nós

14:40.630 --> 14:45.130
estamos apenas correndo o primeiro filho de qualquer nó em particular.

14:45.160 --> 14:49.840
A van é uma segunda criança de aço, portanto, não está funcionando de fato.

14:50.320 --> 14:56.590
E a forma como temos atualmente nosso código de malha de navegação configurado para ir ao destino também não está realmente

14:56.590 --> 15:00.850
correta, mas você pelo menos tem algo que funciona e que pode ser testado.

15:01.150 --> 15:04.210
Ok, então essa é a nossa ação.

15:04.210 --> 15:12.730
O que vamos fazer quando voltarmos na próxima palestra é consertar o código de malha de navegação e colocar algum

15:12.730 --> 15:17.380
tipo de código adequado para ir ao Diamond e ir ao Van.
