WEBVTT

00:02.520 --> 00:10.890
Na palestra anterior, nós montamos nossas ações e colocamos nosso caráter em movimento agora, a fim de executar

00:10.890 --> 00:12.180
um plano.

00:12.210 --> 00:16.800
Como tal, precisamos adicionar em seqüência nós.

00:17.010 --> 00:24.570
Até agora, temos como ir até a porta e ir até o nó da van, mas na verdade eles não funcionam em seqüência.

00:24.570 --> 00:30.780
E é isso que você quer como seu plano e quer que seu agente os administre um a um.

00:30.780 --> 00:39.150
Agora, se em algum momento durante a seqüência uma dessas ações falhar, então não há sentido em continuar com

00:39.150 --> 00:40.440
a seqüência.

00:40.680 --> 00:45.660
Portanto, você tem que levar isso em consideração quando estiver realmente programando o nó de seqüência.

00:45.660 --> 00:57.030
Então, basicamente, o que acontece é que um nó de seqüência é como um nó lógico, e se todos os seus filhos são bem sucedidos,

00:57.090 --> 01:03.510
então o nó de seqüência realmente retorna com sucesso a seus pais.

01:03.810 --> 01:11.250
Se alguma das crianças falhar em uma ou mais delas, então o próprio nó seqüencial falha e ele relata

01:11.250 --> 01:14.280
uma falha na árvore a seus pais.

01:15.540 --> 01:20.940
Muito bem, então vamos criar um nó de seqüência em nosso código de árvore de comportamento.

01:20.940 --> 01:23.430
Vamos criar outro arquivo C-sharp.

01:23.430 --> 01:28.920
Esta será chamada de seqüência e abrirá isso em seu editor.

01:28.920 --> 01:29.250
Certo.

01:29.250 --> 01:32.160
Mais uma vez, isto vai ser um nó, não um comportamento de mineiro.

01:32.160 --> 01:35.580
E podemos nos livrar do conteúdo disso.

01:36.090 --> 01:39.540
Agora, a primeira coisa que faremos é apenas criar uma construtora pública.

01:39.540 --> 01:45.030
Então seqüencie e teremos que passar pelo nome para isso.

01:45.030 --> 01:48.090
E agora vamos escrever seu processo.

01:48.360 --> 02:00.600
Portanto, será um processo de status de ponto de sobreposição pública e, na verdade, não precisa daquele nó ali dentro, mas isso não

02:00.600 --> 02:02.160
importa muito.

02:02.160 --> 02:02.640
Certo.

02:02.640 --> 02:12.480
Portanto, isto vai retornar o ponto de status de funcionamento como padrão.

02:12.900 --> 02:24.240
Agora, antes disso, ela vai basicamente percorrer todas as suas crianças e executar seu método de processo.

02:24.450 --> 02:26.940
Mas você não pode ter um loop aqui dentro.

02:27.180 --> 02:35.460
Lembre-se, é como uma atualização em unidade, então você tem como que colocá-lo em funcionamento e depois ver se ainda está funcionando

02:35.460 --> 02:39.720
da próxima vez que este processo aparecer e funcionar novamente.

02:39.750 --> 02:40.020
Certo.

02:40.050 --> 02:46.860
Portanto, antes de mais nada, o que vamos fazer é agarrar o status de administrar a primeira criança.

02:46.860 --> 02:47.820
Portanto, status.

02:48.750 --> 02:53.640
O status de criança é igual a criança.

02:55.240 --> 02:56.680
Criança atual.

02:56.680 --> 03:02.800
Agora, se você se lembra de quando criamos nosso nó pela primeira vez, nós fizemos aquele inteiro infantil atual.

03:03.670 --> 03:06.820
E isso é apenas manter um registro de qual criança está correndo atualmente.

03:06.820 --> 03:08.620
Portanto, está inicialmente fixado em zero.

03:08.620 --> 03:10.780
Então, voltamos ao nosso nó e damos uma olhada.

03:10.960 --> 03:12.310
É aqui em cima.

03:12.310 --> 03:18.040
Portanto, a primeira vez que executarmos isso lá dentro, ela vai pegar aquela primeira criança

03:18.040 --> 03:22.960
que está naquela matriz de processadores ou os processadores de crianças.

03:23.110 --> 03:23.440
Está bem.

03:23.440 --> 03:34.390
Agora, se este status de criança é igual a status ponto correndo, isso significa que aquela criança ainda está correndo, e nesse

03:34.390 --> 03:41.530
caso vamos apenas devolver o status ponto correndo K, não vamos correr mais nada.

03:41.530 --> 03:46.840
Não vamos definir o processo para fazer outra criança porque estamos atualmente no meio de já estar

03:46.840 --> 03:48.420
fazendo alguma coisa.

03:48.430 --> 03:48.590
Certo.

03:48.640 --> 03:52.030
Assim, isto pode ser, por exemplo, ir para Diamond.

03:52.210 --> 03:58.450
O agente ainda pode estar caminhando para lá, o que significa que aquele nó em particular ainda

03:58.450 --> 04:02.290
não retornou um valor, não teve sucesso ou falhou.

04:02.290 --> 04:04.300
Ainda está funcionando por conta própria.

04:04.750 --> 04:05.000
Certo.

04:05.050 --> 04:18.700
Agora, se não estiver funcionando, se o status de criança for igual a falha de status de ponto, então vamos retornar o status de criança, basicamente

04:18.700 --> 04:25.120
dizendo que, está bem, este nó de seqüência relatou agora uma falha.

04:25.120 --> 04:25.780
Estamos terminados.

04:25.780 --> 04:28.810
Não estamos fazendo mais crianças porque não podemos continuar.

04:28.810 --> 04:34.990
Uma de nossas crianças declara ou nossas ações infantis falharam.

04:35.200 --> 04:40.150
Certo, se você não pode ir ao diamante, então não adianta continuar tentando roubar o diamante,

04:40.150 --> 04:40.840
etc.

04:41.050 --> 04:47.470
Certo, então uma vez que passamos por isso, se não falhamos, isso significa que agora devemos ter sucesso com aquela criança em particular

04:47.470 --> 04:50.140
porque ela não está correndo e não está falhando.

04:50.140 --> 04:59.650
Portanto, a criança mais atual queremos ir na próxima vez que entrarmos aqui para a próxima criança e realmente processá-la.

04:59.650 --> 05:08.560
Portanto, vamos dizer se a criança atual é maior ou igual ao número de pontos das crianças.

05:08.560 --> 05:17.590
Portanto, se realmente chegamos ao final de nossa lista, então a criança atual arrependida é igual a zero.

05:17.590 --> 05:19.780
Vamos reinicializar isso para a próxima vez.

05:19.780 --> 05:29.650
Podemos executar esta seqüência e vamos retornar o status de ponto de sucesso, de modo que, basicamente, já percorremos todas

05:29.650 --> 05:37.210
as crianças e nenhuma delas relatou um fracasso, o que significa que somos bem sucedidos.

05:37.210 --> 05:38.740
Conseguimos chegar ao final da seqüência.

05:38.740 --> 05:41.770
Portanto, digamos que, está bem, conseguimos, estamos acabados.

05:41.860 --> 05:42.520
Ótimo.

05:42.790 --> 05:45.070
Esse é o seu nó de seqüência.

05:45.070 --> 05:46.930
Simples, simples, simples.

05:46.930 --> 05:50.410
Mas é apenas para dar a volta à cabeça como isto está realmente funcionando.

05:50.410 --> 05:55.510
E é um looping, mas não é um looping em um único por loop aqui dentro.

05:55.930 --> 05:56.590
Muito bem.

05:56.590 --> 06:05.500
Por isso, agora vamos começar com isso, economize isso e voltaremos ao nosso comportamento de ladrão, porque é aqui que precisamos

06:05.500 --> 06:07.330
montar tudo isso.

06:07.330 --> 06:13.300
Portanto, temos nossa ida ao diamante e nossa ida ao Van, o que significa que nossos agentes vão ao diamante e depois

06:13.300 --> 06:16.210
voltam para o Van, ou pelo menos é isso que queremos.

06:16.240 --> 06:22.360
Agora, eu sei na ilustração no início desta palestra, eu também tinha ido até a porta e vou acrescentar

06:22.360 --> 06:23.920
isso um pouco mais tarde.

06:23.920 --> 06:26.050
Só queremos manter isto simples por enquanto.

06:26.110 --> 06:35.530
Agora já estamos acrescentando essas duas coisas ao nosso nó de roubo, mas ainda assim, agora vai se tornar uma seqüência.

06:35.530 --> 06:45.430
Portanto, vamos mudar de nosso nó básico para uma seqüência e vamos mudá-la aqui para uma seqüência.

06:46.900 --> 06:49.210
Agora estão sendo adicionados a ela, e tudo bem.

06:49.210 --> 06:53.590
Eles estão acrescentando para que você queira que eles sejam processados.

06:54.160 --> 07:02.290
Agora, quando começamos, corremos o processo de copa da árvore uma vez que ela não continua rodando a árvore, mas

07:02.290 --> 07:09.640
precisamos continuar rodando a árvore da mesma forma que a unidade continua rodando sua atualização,

07:09.640 --> 07:12.760
que está aqui embaixo e vazia no momento.

07:12.760 --> 07:20.620
Portanto, em vez de rodar nossa árvore aqui em START, nós realmente queremos rodá-la em atualização.

07:21.010 --> 07:25.810
E, para poder executá-lo em atualização, precisamos saber o que ele está retornando a cada vez.

07:25.810 --> 07:36.280
Portanto, vou subir o topo aqui e colocar uma outra variável para que não seja o status do

07:37.720 --> 07:49.840
ponto, que na verdade será o status da árvore igual ao ponto de status do nó rodando como padrão ali.

07:49.840 --> 07:54.460
E então o que vamos fazer é tirar este processo de árvore do início.

07:54.620 --> 07:56.480
Portanto, vamos cortar isso de lá.

07:56.510 --> 08:03.650
Traga-o para nossa atualização aqui mesmo e depois apenas teste.

08:03.650 --> 08:17.240
Se o status verdadeiro for igual a nenhum ponto de status em execução, então vamos processar a árvore.

08:17.930 --> 08:24.050
Agora, quando o fizermos, também precisamos ter certeza de atualizar o status da árvore, para que isto a pare de funcionar

08:24.050 --> 08:25.040
novamente.

08:25.040 --> 08:31.840
Caso contrário, ele irá circular e continuará a executar qualquer ação específica que você esteja tentando realizar.

08:31.850 --> 08:36.470
Portanto, colocaremos o status de árvore igual ao processo de comércio.

08:36.470 --> 08:40.970
Certo, então vamos salvar isso e agora estamos prontos para experimentar.

08:40.970 --> 08:47.990
Portanto, vamos voltar à unidade e vamos pressionar o jogo e devemos ver esses comportamentos

08:47.990 --> 08:50.780
acontecerem onde vamos ao diamante.

08:51.170 --> 09:00.170
Assim, a malha de navegação está agora no controle até onde se trabalha no caminho, vamos para o diamante e então alcançamos

09:00.440 --> 09:01.640
o diamante.

09:01.640 --> 09:04.310
Então, na verdade, o sucesso retornou lá.

09:04.310 --> 09:09.650
E agora podemos voltar para a van.

09:09.650 --> 09:16.550
E então, porque aquela árvore é bem sucedida, vamos parar por aí e não vai continuar.

09:16.550 --> 09:22.730
Se você retirar esse status de árvore igual ao seu processo de árvore na atualização, você verá realmente que isso

09:22.730 --> 09:25.790
irá saltar em torno e loop através desse comportamento.

09:26.360 --> 09:26.960
Muito bem.

09:26.960 --> 09:35.270
Portanto, temos isso funcionando agora se você precisar depurar isso, porque é um pouco por fé, eu acho, com a maneira

09:35.270 --> 09:41.450
que nós realmente codificamos para você enquanto você passa por isso, o que você pode gostar

09:41.450 --> 09:50.300
de fazer é em seus processos, colocar alguns logs de depuração para ver qual processo está realmente funcionando.

09:50.300 --> 09:56.240
Porque, lembre-se, tivemos o trabalho de enviar um nome a cada nó.

09:56.330 --> 09:56.690
Está bem?

09:56.690 --> 10:06.080
Portanto, aqui você pode realmente colocar como um registro de depuração de crianças, o nome atual do ponto criança aqui.

10:06.380 --> 10:08.150
Isso lhe permitiria manter-se informado.

10:08.150 --> 10:10.850
E você também pode então imprimir qual é o status.

10:10.970 --> 10:18.380
Assim, em todos os seus processos, onde quer que estejam em folha, faça alguns registros de depuração e então você pode observar

10:18.380 --> 10:24.650
o que está acontecendo, observar qual deles está processando e onde seus problemas podem estar.

10:24.800 --> 10:25.460
Muito bem.

10:25.460 --> 10:27.680
Chegou a hora de um desafio.

10:27.680 --> 10:33.380
Se você se lembra logo no início, tínhamos uma pequena árvore de comportamento

10:33.380 --> 10:40.970
que tinha uma porta entre começar aqui, ir para uma porta, ir para o diamante e depois voltar para a van.

10:41.810 --> 10:51.230
O que eu gostaria que você fizesse é montar esta pequena seqüência onde nós agora, primeiro, vamos até a porta,

10:51.230 --> 10:55.550
vamos até o diamante, e depois vamos até a van.

10:55.550 --> 11:01.970
Agora, quando eu digo para ir até a porta, na verdade quero que você vá até esta porta aqui.

11:02.270 --> 11:09.020
Portanto, quero que seu agente vá até aquela porta, vá até o diamante, e depois vá até a van.

11:09.020 --> 11:15.230
Ou, de fato, você poderia até dizer ir até a porta, ir até o diamante, ir até a porta e ir até Van.

11:15.230 --> 11:16.670
Portanto, veja se você pode colocar isso dentro.

11:16.670 --> 11:17.870
Pausa o vídeo agora.

11:18.170 --> 11:19.370
Vá em frente e faça isso.

11:19.370 --> 11:22.010
Quando voltarmos, eu lhe mostrarei como fazê-lo.

11:22.640 --> 11:23.660
Bem-vindo de volta.

11:23.660 --> 11:26.000
Como você enfrentou esse desafio?

11:26.000 --> 11:31.700
Agora, você pode ter encontrado um pequeno soluço com isso, e eu falarei sobre isso quando isso

11:31.700 --> 11:32.870
acontecer comigo.

11:32.900 --> 11:41.870
Primeiro de tudo, esta porta aqui, se a encontrarmos na cena do crime, é chamada de porta dos fundos.

11:42.140 --> 11:43.280
Então é isso aí.

11:43.280 --> 11:44.690
E é esse que queremos.

11:44.690 --> 11:50.870
Portanto, dentro de nosso código de comportamento de ladrão, precisamos criar espaço para passar por ele.

11:50.870 --> 12:03.500
Portanto, vamos voltar ao topo aqui e vamos colocar um objeto de jogo público de volta assim, e então precisamos criar uma folha

12:03.500 --> 12:07.490
para aquela coisa em particular.

12:07.730 --> 12:09.410
Por isso, queremos uma folha aqui.

12:09.410 --> 12:14.360
Vamos pegar isso e eu vou apenas copiá-lo e colocá-lo aqui.

12:14.360 --> 12:19.910
Então vá até a porta e vamos chamá-la de backdoor.

12:19.910 --> 12:34.700
Só para ser específico aqui, vá para Backdoor e então colocaremos aqui Backdoor e vamos para Backdoor como nosso

12:34.700 --> 12:39.770
método que precisamos então criar.

12:39.770 --> 12:43.130
Então vamos até o fundo e temos que ir até Diamond.

12:43.140 --> 12:54.410
Então vamos apenas fazer uma cópia disso, ir para a porta dos fundos e então nossa ida para o local será.

12:54.630 --> 12:57.540
Posição transformada da porta traseira.

12:57.840 --> 12:59.540
O resto vai ficar tudo bem.

12:59.550 --> 13:04.770
Vamos voltar aqui para cima e acrescentar na seqüência "ir para trás".

13:04.770 --> 13:07.110
Então, na verdade queremos que esse seja o primeiro, não é mesmo?

13:07.110 --> 13:23.670
Então vamos subir aqui e colocar um ponto de aço, adicionar criança, ir para a Backdoor, ir para a Diamond e depois queremos voltar para a porta traseira

13:23.670 --> 13:28.410
para sair e depois ir para a van.

13:28.800 --> 13:36.270
Portanto, vamos salvar isso, voltar à unidade e vamos pressionar o jogo e dar uma olhada no que recebemos.

13:36.300 --> 13:42.540
É claro, depois de irmos para o código de borracha e passarmos por aquele objeto da porta traseira para nosso roteiro.

13:42.840 --> 13:47.550
Então lá está o jogo da imprensa e agora vamos dar uma olhada no jogo.

13:47.550 --> 13:53.130
Portanto, imediatamente a primeira coisa que você teria notado é que ele parece estar indo para

13:53.130 --> 13:55.170
a porta da frente, mas não está.

13:55.170 --> 13:59.430
Ele está pegando um atalho para a porta traseira através da porta da frente.

13:59.460 --> 14:03.060
Agora isso é por causa da malha de navegação.

14:03.270 --> 14:06.900
É encontrar um caminho mais curto através dessa abertura na porta da frente.

14:06.900 --> 14:08.310
Então, mas pelo menos ele foi lá.

14:08.310 --> 14:13.710
Acho que agora ele foi para a porta dos fundos, agora ele está voltando para o diamante.

14:14.010 --> 14:18.990
E quando ele fizer isso, vai voltar para a porta dos fundos.

14:19.740 --> 14:26.880
E então vou assumir aqui que ele vai fazer um atalho por aquela porta da frente.

14:27.270 --> 14:30.570
Oh, agora ele calculou de forma diferente e volta para a van.

14:31.860 --> 14:32.370
Obviamente.

14:32.370 --> 14:33.360
Com certeza foi por esse caminho.

14:33.360 --> 14:34.650
Tão bom.

14:34.650 --> 14:41.520
Agora, a questão é que ele foi para a porta dos fundos porque aparentemente a porta da frente está trancada e ele não pode

14:41.520 --> 14:43.890
passar por lá, mas neste caso ele pode.

14:43.890 --> 14:50.370
Agora, isso é, como eu disse, uma questão de malha de navegação, e vamos resolver isso nos próximos vídeos.

14:50.550 --> 14:51.270
Certo.

14:51.270 --> 14:53.250
Então isso são seqüências.

14:53.250 --> 14:59.730
Quando voltarmos na próxima palestra, vamos olhar para os seletores.
