WEBVTT

00:02.640 --> 00:08.340
Antes de começarmos a escrever nosso código, vamos apenas nos lembrar o que pretendemos construir.

00:08.340 --> 00:11.690
E isso é basicamente esta estrutura em árvore aqui.

00:11.700 --> 00:19.260
Portanto, nossa árvore de comportamento é composta de um monte de nós, e uma árvore de comportamento é apenas um

00:19.260 --> 00:26.880
gráfico onde cada caixa, eu acho que é um nó que tem alguma ação ou condição ou qualquer coisa associada a ela.

00:26.880 --> 00:30.300
E as linhas mostram quais estão conectadas a quais.

00:30.300 --> 00:38.730
Agora, se você se lembra, as que estão bem no fundo são as ações ou coisas reais que acontecerão e que farão

00:38.730 --> 00:44.880
com que seu personagem faça seu comportamento que você verá na tela.

00:44.910 --> 00:47.520
Os outros ligam tudo isso entre si.

00:47.520 --> 00:52.650
Portanto, há dois tipos de nós de folha é uma ação e uma condição, e chegaremos a eles um pouco

00:52.650 --> 00:53.640
mais tarde.

00:53.820 --> 00:58.980
Depois temos nossa seqüência e nossos selecionadores, que também escreverão um pouco mais tarde.

00:58.980 --> 01:07.980
Mas todos estes são basicamente nós e por isso um nó será nossa classe base que implementaremos.

01:08.370 --> 01:17.610
E quando começarmos a escrever isto, você ficará absolutamente surpreso com a simplicidade do código e, ainda assim,

01:17.610 --> 01:20.460
com o quão poderoso ele se torna.

01:21.270 --> 01:25.890
Muito bem, então vamos prosseguir e escrever nossa classe de Nodo.

01:25.890 --> 01:29.040
Agora, vou colocar todo o meu roteiro em uma nova pasta.

01:29.220 --> 01:35.010
Já existe uma pasta de árvore B que você encontrará quando tiver trazido aquele projeto, mas que tem a missão de

01:35.010 --> 01:36.990
NAV, por isso não queremos usar isso.

01:36.990 --> 01:40.470
Portanto, vamos descer fora de tudo.

01:40.470 --> 01:42.150
Portanto, não o crio dentro de outra coisa.

01:42.150 --> 01:50.010
E vamos chamar esta árvore de comportamento, ou você poderia chamá-la de script se quiser colocá-la lá dentro, vamos abrir

01:50.010 --> 01:50.790
isto.

01:50.790 --> 01:51.180
Certo.

01:51.240 --> 01:56.970
Portanto, aqui, vamos criar um novo arquivo em C afiado e vamos chamá-lo de Nodo.

01:56.970 --> 01:59.610
Então, você quer abrir isso em seu editor.

01:59.610 --> 02:04.530
Agora, como uma classe muito básica, não vai ser um comportamento mono.

02:04.530 --> 02:09.120
Na verdade, todas essas aulas não funcionarão com comportamento mono.

02:09.120 --> 02:12.870
Portanto, temos de projetá-las de forma que elas se atualizem.

02:12.870 --> 02:20.400
Mas como está em uma estrutura de árvore, ela vai correr a partir do nó raiz superior da árvore, e então toda a estrutura vai olhar

02:20.400 --> 02:27.150
para baixo para encontrar a primeira folha disponível que deve ser corrida e, em seguida, correr aquela.

02:27.150 --> 02:30.090
Portanto, vamos nos livrar do Start e também atualizar.

02:30.090 --> 02:37.500
Agora qualquer folha em particular ou qualquer nó pode realmente ter um dos três status.

02:37.500 --> 02:43.800
Pode ter tido sucesso quando você tentou executá-lo, que falhou quando você tentou executá-lo,

02:43.800 --> 02:50.220
ou que pode estar em estado de funcionamento, o que significa que ainda está sendo executado.

02:50.220 --> 02:50.570
Está bem.

02:50.640 --> 03:00.960
Portanto, vamos criar um enumero público para isso e vamos chamá-lo de status e temos três tão bem sucedidos ou bem sucedidos

03:00.990 --> 03:10.380
e depois fracassados, e então precisamos de um valor para realmente armazenar isso para que possamos registrar

03:10.380 --> 03:13.020
qual deles conseguimos.

03:13.020 --> 03:18.000
Portanto, status de público e depois chamaremos isso de status.

03:18.630 --> 03:19.080
Certo.

03:19.080 --> 03:24.780
Agora cada nó pode possivelmente ter nós de crianças.

03:24.780 --> 03:24.980
Certo.

03:25.050 --> 03:32.640
Portanto, se é o nó raiz, tem os nós imediatamente abaixo dele como seus filhos, o seletor

03:32.640 --> 03:38.190
e os nós de seqüência, eles têm ações e condições como crianças.

03:38.190 --> 03:41.550
Assim, basicamente cada nó pode ter um conjunto de crianças.

03:41.550 --> 03:45.840
É claro que os nós da folha vão ter um conjunto vazio de crianças, mas tudo bem.

03:45.840 --> 03:47.100
Vamos simplesmente armazená-las aqui.

03:47.100 --> 03:52.110
Por isso, vou criar uma lista pública para armazenar aqueles em quatro nós.

03:52.110 --> 04:05.700
Portanto, uma lista de nós, crianças, e nós faremos esse novo nó de lista igual a esse.

04:05.970 --> 04:06.510
Certo.

04:06.510 --> 04:16.920
Agora toda vez que o nó tem que descobrir o status de qualquer um de seus filhos, ele vai passar por eles basicamente da esquerda para a direita,

04:16.920 --> 04:23.160
como se estivesse lendo um após o outro, especialmente se você estiver em uma seqüência,

04:23.160 --> 04:29.520
por exemplo, e tiver três coisas que você quer fazer em seqüência.

04:29.520 --> 04:34.380
Você quer que eles sejam colocados na lista para que possam funcionar.

04:34.500 --> 04:40.920
E então você precisa do nó para realmente acompanhar qual deles está funcionando a qualquer momento em particular.

04:40.920 --> 04:48.090
Assim, criaremos uma intensão pública e chamaremos isso de criança atual e colocaremos isso a zero.

04:48.330 --> 04:54.270
Por isso, logo no início, ele vai estar olhando para o primeiro aviso de uma criança.

04:54.270 --> 04:56.640
Vai correr primeiro.

04:57.210 --> 04:57.720
Está bem.

04:57.720 --> 05:01.890
Agora, para tornar sua própria vida de depuração um pouco mais fácil, nós vamos.

05:02.000 --> 05:04.820
Dê também um nome a cada nota.

05:04.910 --> 05:09.410
E isto só para que possamos imprimir e ver como é nossa árvore.

05:09.590 --> 05:14.270
Assim, um nome público de cadeia como esse.

05:14.270 --> 05:17.090
Então, vamos criar um construtor.

05:17.090 --> 05:29.810
Então, nós colocaremos um nó público e um fio e aqui colocaremos um nome igual e também faremos um construtor

05:29.810 --> 05:36.710
sem nada nele, porque o C afiado gosta de fazer isso.

05:36.710 --> 05:43.520
Agora, neste caso, você acabará com o nome praticamente vazio, mas usaremos este aqui em seu lugar.

05:43.520 --> 05:50.060
Agora, a outra coisa que quero fazer antes de terminarmos com isto, por enquanto, é acrescentar um método público para adicionar

05:50.060 --> 05:51.320
nosso filho.

05:51.320 --> 06:02.540
Então o vazio público acrescenta criança, vamos passar um nódulo e então dentro daqui vamos apenas adicionar

06:02.870 --> 06:07.220
n a criança ponto e vamos adicionar n a ele.

06:07.220 --> 06:11.300
Portanto, o primeiro que você colocar na lista estará no topo da lista.

06:11.300 --> 06:13.220
Portanto, isso será criança zero.

06:13.250 --> 06:16.940
E então você terá criança um, criança dois ao passar por essa lista.

06:16.940 --> 06:22.640
E, portanto, você tem que colocá-los na lista para que apareçam ou que você queira que sejam

06:22.640 --> 06:25.820
executados dentro de seu comportamento.

06:25.820 --> 06:28.370
TREE ok, então nós temos isso.

06:28.370 --> 06:30.290
Vamos agora salvá-lo.

06:30.830 --> 06:32.720
Vamos voltar à unidade.

06:32.720 --> 06:37.580
Não temos nada para correr neste ponto, mas queremos levá-lo a um ponto em que possamos realmente

06:37.580 --> 06:38.540
criar uma árvore.

06:38.660 --> 06:43.730
Vamos criar um roteiro para nossa árvore de comportamento.

06:43.730 --> 06:48.950
Então, vamos chamar isso de árvore de comportamento.

06:48.950 --> 06:52.820
Agora estou usando a ortografia de comportamento australiana.

06:52.970 --> 06:54.560
Cabe a você decidir qual deles você usa.

06:54.560 --> 06:56.480
Vamos abrir isso em nosso editor.

06:56.480 --> 07:01.460
E mais uma vez, vamos nos livrar do comportamento mono, mas na verdade vamos dizer que nossa

07:01.460 --> 07:08.120
árvore de comportamento é basicamente um nó porque é o nó raiz e tem crianças por baixo dele, que então têm seus próprios

07:08.120 --> 07:08.780
filhos.

07:08.780 --> 07:09.830
Eles estão em seus próprios filhos.

07:09.830 --> 07:15.620
Portanto, árvore de comportamento público.

07:15.830 --> 07:22.520
Agora, é claro, você não precisa nem mesmo desta classe em particular porque você poderia simplesmente criar um nó e chamá-lo

07:22.520 --> 07:24.410
de raiz e depois usá-lo.

07:24.410 --> 07:30.140
Mas só por uma questão de completude aqui, vou me certificar de distinguir uma árvore de comportamento

07:30.140 --> 07:32.060
ou algo diferente.

07:32.060 --> 07:35.780
Portanto, vamos chamar este nome de árvore.

07:35.780 --> 07:43.460
E é claro que você poderia passar por um determinado tipo de comportamento se quisesse uma espécie de guarda e comportamento

07:43.460 --> 07:45.890
de PC para o que ele deveria fazer.

07:45.890 --> 07:49.190
Poderia ter uma árvore de comportamento particular e então você poderia ter outra árvore de comportamento.

07:49.190 --> 07:55.100
Portanto, esta classe aqui poderia ser expandida no futuro para ser lida em uma espécie de árvore

07:55.100 --> 08:04.190
de comportamento que você escreveu como algum tipo de arquivo JSON ou arquivo XML ou até mesmo apenas texto para carregar nos comportamentos reais.

08:04.310 --> 08:08.270
Não vamos fazer isso aqui, mas é o tipo de coisa que você poderia fazer com isto.

08:08.270 --> 08:20.480
E depois vamos colocar em árvore de comportamento público e vamos passar por um fio e colocar o nome aqui.

08:23.010 --> 08:23.500
Certo.

08:23.520 --> 08:24.760
Portanto, vamos salvar isso.

08:24.780 --> 08:29.400
Agora vamos voltar à Unidade e vamos criar outro roteiro.

08:29.400 --> 08:34.230
E este será o roteiro que realmente colocamos em nosso ladrão, nosso objeto ladrão.

08:34.230 --> 08:41.010
Então vamos criar um roteiro afiado e vamos chamar isso de comportamento de ladrão.

08:41.550 --> 08:42.660
Abra isso.

08:42.660 --> 08:49.980
E desta vez vamos mantê-lo como um comportamento, porque na verdade isto vai continuar para o nosso

08:49.980 --> 08:51.660
agente e vai correr.

08:51.660 --> 08:58.320
Portanto, aqui em cima, a primeira coisa que faremos é realmente criar uma árvore de comportamento para que possamos ir árvore de comportamento,

08:58.320 --> 08:59.640
vamos chamá-la de árvore.

09:00.360 --> 09:07.410
E então, no início, vamos construir uma árvore muito, muito simples.

09:07.650 --> 09:15.450
Portanto, árvore é igual a árvore de comportamento novo, e neste momento vou deixar que ela seja chamada de árvore.

09:15.450 --> 09:25.110
Então criamos um nó e o nó debaixo dele vai ser aço, e isso vai ser igual ao novo nó de aço, algo

09:25.620 --> 09:28.620
que vamos chamar de aço.

09:29.700 --> 09:36.900
E então o que implica em roubar algo é, bem, podemos roubar o diamante, por exemplo.

09:36.900 --> 09:51.780
Então criaremos um nó para ir ao diamante e igualaremos um novo nó, iremos ao diamante e depois outro nó irá ao Van,

09:51.780 --> 09:58.200
que é o pequeno caminhão que está na cena lá.

09:58.200 --> 10:02.850
Então, vamos fazer com que nosso agente se mude para onde está o diamante e depois voltar para a van.

10:02.850 --> 10:05.580
Então, isso vai igualar o novo nó.

10:06.240 --> 10:08.880
Vá para van.

10:10.530 --> 10:12.810
Agora, como construímos esta árvore?

10:12.840 --> 10:21.130
Temos que fazer isso ao contrário para que nosso aço não acrescente criança primeiro.

10:21.150 --> 10:34.140
Vamos adicionar, ir ao diamante e depois ao Steel Dot, adicionar criança, ir ao furgão e depois pegar nossa árvore.

10:34.380 --> 10:37.470
Ponto para adicionar criança para o aço.

10:38.670 --> 10:46.380
Portanto, neste ponto, nossa árvore deve parecer muito simples e como faz na tela aqui.

10:46.920 --> 10:49.050
Como sabemos que isto é correto?

10:49.080 --> 10:49.380
Certo.

10:49.380 --> 10:50.790
Bem, eu vou apenas salvar isto.

10:50.820 --> 10:57.420
Vou voltar à nossa árvore de comportamento e criar aqui um pequeno método de árvore de impressão para que

10:57.420 --> 10:59.520
possamos ver algo no console.

10:59.800 --> 11:00.090
Certo.

11:00.090 --> 11:05.310
Portanto, essa será uma árvore de impressão vazia ao público.

11:06.840 --> 11:09.390
E depois dentro daqui.

11:09.720 --> 11:13.440
Bem, você não achava que eu ia facilitar as coisas para você, não é mesmo?

11:13.470 --> 11:17.770
Isto vai ser um desafio para você para chegar ao código que vai nesta árvore de impressão.

11:17.790 --> 11:25.740
Agora você vai querer usar os logs de depuração porque queremos que isto seja impresso no console a qualquer momento que chamamos de dentro

11:25.740 --> 11:29.700
do código de comportamento da borracha ou em qualquer lugar.

11:29.700 --> 11:36.420
Então tudo o que você tem que fazer é descobrir como você vai atravessar a árvore

11:36.420 --> 11:40.050
na ordem certa e exibi-la no console?

11:40.410 --> 11:41.510
Dê uma olhada nisso.

11:41.520 --> 11:49.710
Quando voltarmos no próximo vídeo, completaremos este código e continuaremos a escrever o código que realmente

11:49.710 --> 11:54.570
fará com que nosso pequeno agente de borracha se mova na tela.
