WEBVTT

00:03.770 --> 00:04.760
Bem-vindo de volta.

00:04.790 --> 00:11.120
Na última palestra, deixei a vocês a tarefa de imprimir a árvore de comportamento simples que estivemos

00:11.120 --> 00:12.500
construindo.

00:12.920 --> 00:21.590
Infelizmente, esta não é realmente uma tarefa simples e bem feita para você se você conseguir tirá-la de lá.

00:21.740 --> 00:25.850
Melhor ainda se você realmente foi e fez um pouco de pesquisa para descobrir como fazer isso.

00:25.900 --> 00:32.810
Ok, então Behavior Tree é basicamente um gráfico e há muitos algoritmos por aí que já foram

00:32.810 --> 00:36.780
escritos para atravessar um gráfico e imprimi-lo.

00:36.800 --> 00:39.190
Agora você pode fazer isso de duas maneiras.

00:39.200 --> 00:44.150
Você pode usar a recorrência ou pode fazê-lo sem recorrência.

00:44.150 --> 00:50.600
Agora vou fazê-lo sem recorrência, só para não confundir as pessoas que não estão em todos os lugares que a recorrência

00:50.600 --> 00:54.680
funciona, porque pode ser um pouco de curvatura da mente.

00:55.160 --> 00:55.640
Muito bem.

00:55.640 --> 00:58.950
Comecemos, então, com nossa árvore de impressão.

00:58.970 --> 01:07.130
Portanto, aqui dentro, vou, antes de mais nada, colocar um cordel e esse cordel será a impressão em árvore.

01:08.180 --> 01:11.810
Por isso, vou guardar tudo em um fio e depois imprimi-lo logo no final.

01:12.050 --> 01:14.600
Portanto, isso não equivale a nada neste momento.

01:14.840 --> 01:23.660
Agora, para lembrar onde estamos nesta árvore, vou criar uma pilha e a pilha vai

01:23.660 --> 01:25.610
ter nós nela.

01:26.750 --> 01:33.680
E vamos chamar que a pilha de nós é igual à nova pilha de nós.

01:33.770 --> 01:37.190
E então colocamos o nó atual lá dentro.

01:37.190 --> 01:41.690
Portanto, o nó atual neste ponto é a própria árvore básica.

01:41.960 --> 01:56.810
Então, vamos fazer nó, o nó atual é igual a isto e depois vamos empilhar o ponto do nó, empurrar a corrente.

01:58.050 --> 01:58.810
Nota.

01:59.490 --> 02:04.320
Certo, então temos a raiz da árvore naquela pilha.

02:04.680 --> 02:13.140
Em seguida, basicamente começamos a fazer um looping por cada nó que, se ele tiver filhos, queremos colocá-los

02:13.140 --> 02:18.420
na pilha e depois queremos sair dos pais e imprimi-los.

02:18.420 --> 02:31.140
Portanto, vai ficar assim enquanto a pilha de nós não conta, não é igual a zero, e não deve ser a primeira vez porque

02:31.140 --> 02:34.650
colocamos um nó aqui em cima.

02:34.920 --> 02:42.120
Portanto, embora não seja igual a zero nó, o próximo nó é igual a nó.

02:44.000 --> 02:45.980
Stick Dot Pop.

02:46.340 --> 02:50.990
Portanto, agarramos a rota neste ponto porque essa é a única ali dentro.

02:51.230 --> 02:52.820
E então imprimimos isso.

02:52.820 --> 02:55.020
Por isso, adicionamos à nossa árvore de impressão um fio.

02:55.040 --> 03:04.070
Vai ser igual a mais igual ao nome do próximo nó mais um retorno.

03:04.760 --> 03:06.910
Assim, podemos descer para uma nova linha.

03:07.160 --> 03:15.380
Em seguida, vamos para o int I e damos a volta a todos os filhos daquele que acabamos de soltar e os colocamos

03:15.380 --> 03:16.940
na pilha.

03:17.150 --> 03:17.570
Certo.

03:17.570 --> 03:22.410
Portanto, neste caso, vou fazer um looping para trás através das crianças.

03:22.430 --> 03:27.380
A razão é que, se você olhar para a frente através das crianças, na verdade as imprime em

03:27.380 --> 03:30.920
ordem inversa, devido à forma como está saltando da pilha.

03:31.190 --> 03:35.300
Portanto, vou começar na parte superior da lista de crianças.

03:35.300 --> 03:43.100
Então, próximo nó ponto crianças, ponto, conte menos um.

03:43.220 --> 03:48.050
I é então maior ou igual a zero.

03:48.050 --> 03:56.060
Assim, embora não tenhamos contabilizado todas as crianças menos eu as adicionarei ao nosso monte.

03:56.060 --> 04:01.220
Então, empilhe os pontos de empilhamento do nó a seguir.

04:01.580 --> 04:02.750
Ponto do nó.

04:04.400 --> 04:05.420
Crianças.

04:06.020 --> 04:06.890
I.

04:09.100 --> 04:09.580
Certo.

04:09.670 --> 04:17.560
Depois, quando tivermos feito isso, podemos fazer a depuração do tronco e vamos imprimir a árvore.

04:18.520 --> 04:23.550
Imprima um valor assim e isso imprimirá nossa árvore.

04:23.560 --> 04:24.190
Portanto.

04:24.220 --> 04:25.690
Como você foi?

04:25.930 --> 04:30.040
Acho que se você tem algo funcionando, você sabe que está funcionando tão bem feito.

04:30.610 --> 04:33.280
É assim que eu estou fazendo.

04:33.520 --> 04:36.460
Se você tem um método diferente que funciona para você, então, por favor, compartilhe-o.

04:36.460 --> 04:42.080
Se você fez isso com recorrência, então compartilhe isso também, para que outros possam aprender com seu código.

04:42.130 --> 04:43.570
Ok, então eu vou salvar isso.

04:43.570 --> 04:52.630
Agora, de volta ao meu comportamento de borracha, eu realmente acrescentei aqui algum tipo de nós extras falsos para que eles tenham algo mais interessante

04:52.630 --> 04:56.340
para imprimir e eu os apagarei um pouco mais tarde.

04:56.350 --> 04:58.960
Por isso, temos aqui nossas coisas roubadas.

04:59.200 --> 05:07.120
Eu também acrescentei em um nó de oito que terá dois filhos de ir à pizzaria e comprar pizza, e por isso estou apenas

05:07.120 --> 05:12.670
acrescentando-os aqui embaixo da mesma forma que fizemos para o aço no topo.

05:12.670 --> 05:14.410
É claro que não é preciso colocá-los ali.

05:14.410 --> 05:17.260
Eu só gosto de ver um pouco mais de dados quando imprimo isto.

05:17.440 --> 05:17.860
Certo.

05:17.860 --> 05:25.360
Assim, na parte inferior do início, podemos então ir árvore, ponto, imprimir árvore para executar o método que acabamos de criar.

05:25.360 --> 05:26.290
Guarde-o.

05:26.290 --> 05:29.140
Agora vamos então voltar à unidade.

05:29.140 --> 05:33.270
Você quer adicionar o roteiro do comportamento da borracha ao ladrão?

05:33.280 --> 05:35.320
Como podem ver, eu já fiz aqui.

05:35.590 --> 05:38.800
E nós vamos fazer um jogo de imprensa e dar uma olhada.

05:39.130 --> 05:42.070
Muito bem, então jogue agora no console.

05:42.070 --> 05:43.780
Você não vai ver a árvore inteira.

05:43.780 --> 05:45.640
Você só vai ver o nível superior da árvore.

05:45.640 --> 05:50.770
Mas se você clicar aqui embaixo, no console real, você verá sua árvore.

05:50.770 --> 05:52.960
Portanto, ainda há alguma coisa na árvore.

05:52.960 --> 05:56.170
Então este é o primeiro filho da árvore.

05:56.170 --> 06:01.810
E depois você tem sua ida ao Diamond, vai ao Van, depois come alguma coisa e vai

06:01.810 --> 06:03.940
à pizzaria e compra pizza.

06:04.390 --> 06:04.810
Ótimo.

06:04.810 --> 06:07.240
Portanto, tudo está na ordem certa.

06:07.270 --> 06:14.680
Agora, o que seria realmente agradável é se pudéssemos recuar estes para mostrar quais são as crianças de quais.

06:14.830 --> 06:24.100
Portanto, apenas com um pouco de código complicado, se eu voltar para lá, vou acrescentar uma estrutura muito simples

06:24.100 --> 06:26.380
e atrevida aqui em cima.

06:26.380 --> 06:37.330
Portanto, vamos criar uma estrutura ou nível de nó e esta estrutura vai se agarrar ao nó e ao nível em que o nó se encontra

06:37.330 --> 06:39.310
na árvore.

06:39.310 --> 06:41.500
Portanto, a raiz é nível zero.

06:41.530 --> 06:43.510
O próximo nó para baixo seria o nível um.

06:43.510 --> 06:45.550
Suas crianças serão de nível dois.

06:45.940 --> 06:49.720
E então qualquer um no mesmo nível de um, todos eles serão um.

06:49.720 --> 06:52.810
E então seus filhos são dois e três ao longo de todo o percurso.

06:52.810 --> 07:04.810
Portanto, aqui queremos ter um nível de int público e um nó público para armazenar o nó.

07:04.810 --> 07:05.150
Está bem?

07:05.170 --> 07:10.510
Assim, uma vez feito isso, temos apenas que modificar nossa árvore de impressão.

07:10.510 --> 07:15.340
Portanto, esta pilha agora vai ter nível de nó.

07:15.340 --> 07:24.010
Portanto, aqui colocarei o nível do nó aqui será o nível do nó.

07:25.090 --> 07:30.430
Então, quando empurramos a primeira coisa para aquela pilha, não é mais um nó.

07:30.430 --> 07:32.230
Tem que ser um nível de nó.

07:32.230 --> 07:34.870
Portanto, dentro daqui colocará novas.

07:37.460 --> 07:47.630
Sem nível e por ser uma estrutura, podemos realmente ir como este nível é igual ao nó atual e então saber que não precisa ser igual

07:47.660 --> 07:51.070
ao nível que será zero neste ponto.

07:51.080 --> 07:51.920
Vírgula.

07:52.580 --> 07:58.490
O nó é igual ao nó atual e, em seguida, os parênteses de rabisco no final.

07:58.490 --> 08:05.300
Portanto, basta observar como essa estrutura está sendo declarada e criada e empurrada por aqui.

08:05.480 --> 08:06.050
Certo.

08:06.050 --> 08:12.950
Então, temos dentro de nosso laço enquanto queremos fazer a mesma coisa é correto.

08:12.950 --> 08:13.250
Ou isto.

08:13.250 --> 08:17.090
Agora a coisa que está sendo lançada neste ponto vai ser um nível de nó.

08:18.470 --> 08:29.120
E então o que estamos imprimindo aqui é o próximo nó, nó de ponto, nome do ponto, e queremos usar o nível.

08:29.120 --> 08:31.130
Agora vamos usar o nível não impresso.

08:31.130 --> 08:35.540
Você poderia imprimir qual seria o nível zero um, dois, três, o que quer que seja,

08:35.540 --> 08:39.470
mas na verdade usaremos o número do nível para colocar alguns traços.

08:39.740 --> 08:49.460
Assim, colocaremos um novo fio e, dentro dele, uma única citação, um traço, uma única citação e, em seguida,

08:49.460 --> 08:53.660
uma vírgula, próximo nível de ponto do nó.

08:54.050 --> 08:57.920
E isso será uma vantagem.

09:00.020 --> 09:02.510
Ao nome.

09:02.990 --> 09:08.990
Portanto, qualquer que seja este número aqui, ele imprimirá estes muitos travessões.

09:08.990 --> 09:15.890
Portanto, se você estiver no nível cinco, por exemplo, haverá cinco traços agora em loop, será

09:15.890 --> 09:20.930
o próximo ponto de nó, ponto de nó, contagem de pontos para crianças.

09:21.050 --> 09:27.200
E então o que estamos empurrando novamente para baixo é basicamente isto.

09:27.620 --> 09:36.950
Portanto, queremos um novo nível de nó, nível de parênteses iguais.

09:36.950 --> 09:38.750
Agora, o que vai ser igual neste momento?

09:38.750 --> 09:47.600
Bem, se formos até as crianças, será igual ao próximo nó aqui em cima que for nível mais um, porque este

09:47.600 --> 09:52.220
é o que é o pai do qual estamos recebendo as crianças.

09:52.220 --> 10:01.430
Portanto, se copiarmos isso e colocarmos isso aqui e depois colocarmos mais uma e depois colocaremos uma vírgula

10:01.430 --> 10:04.130
e este será um nó igual a isso.

10:04.130 --> 10:14.330
E não se esqueça do suporte com rabisco na ponta e este será o próximo ponto de nó, ponto de nó crianças.

10:14.570 --> 10:18.440
Então, é assim que podemos fazer com esta estrutura.

10:18.440 --> 10:20.540
E é claro que você pode colocar essa estrutura no topo de seu código.

10:20.540 --> 10:26.030
Estou apenas colocando lá para que você possa realmente vê-lo na mesma tela que o resto deste caso.

10:26.030 --> 10:27.380
Portanto, salve-o.

10:27.650 --> 10:30.470
Vamos voltar para aqui.

10:30.830 --> 10:39.440
Agora, quando pressionamos o play e descemos e damos uma olhada na nossa árvore, dê uma olhada na bela estrutura que temos.

10:39.440 --> 10:39.650
Está bem?

10:39.650 --> 10:42.200
Portanto, temos nossa árvore no topo.

10:42.200 --> 10:45.770
Depois temos um traço para nosso aço de primeiro nível qualquer coisa.

10:45.770 --> 10:50.150
E se você desce para comer alguma coisa, você pode ver que isso também tem um único traço.

10:50.150 --> 10:56.750
E os filhos de cada um deles vão para Diamond, vão para Van são agora indentados por dois.

10:56.750 --> 11:01.550
Se você quiser exagerar, pode colocar mais de um traço que está sendo repetido.

11:02.600 --> 11:12.440
Agora que temos isto, podemos usá-lo a qualquer momento apenas para verificar se sabemos que nossa árvore está correta em todo o processo.

11:12.440 --> 11:19.400
Portanto, é apenas uma maneira agradável de depurar que, além de aprender um algoritmo para atravessar a árvore de seu

11:19.490 --> 11:20.720
comportamento.

11:20.930 --> 11:21.350
Certo.

11:21.350 --> 11:25.370
Portanto, deixe-me apenas voltar ao código aqui, caso você tenha acompanhado.

11:25.370 --> 11:26.000
Exatamente.

11:26.000 --> 11:34.340
Vou voltar para a minha borracha e vou realmente me livrar de comer a pizza porque, na verdade, não é realmente

11:34.340 --> 11:37.400
relevante neste momento.

11:37.400 --> 11:41.930
E se você quiser deixar aquela árvore impressa lá dentro, bem, você também pode,

11:41.930 --> 11:45.890
porque se você se deu ao trabalho de criá-la e ela virá em uso.

11:46.070 --> 11:46.550
Muito bem.

11:46.550 --> 11:48.530
Então isso é imprimir sua árvore.

11:48.530 --> 11:55.580
No próximo vídeo, vamos voltar e começar a olhar as ações e como fazer com que nosso personagem

11:55.580 --> 11:56.810
se mova.
