Antes de começarmos a escrever nosso código, vamos apenas nos lembrar o que pretendemos construir.
E isso é basicamente esta estrutura em árvore aqui.
Portanto, nossa árvore de comportamento é composta de um monte de nós, e uma árvore de comportamento é apenas um
gráfico onde cada caixa, eu acho que é um nó que tem alguma ação ou condição ou qualquer coisa associada a ela.
E as linhas mostram quais estão conectadas a quais.
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
com que seu personagem faça seu comportamento que você verá na tela.
Os outros ligam tudo isso entre si.
Portanto, há dois tipos de nós de folha é uma ação e uma condição, e chegaremos a eles um pouco
mais tarde.
Depois temos nossa seqüência e nossos selecionadores, que também escreverão um pouco mais tarde.
Mas todos estes são basicamente nós e por isso um nó será nossa classe base que implementaremos.
E quando começarmos a escrever isto, você ficará absolutamente surpreso com a simplicidade do código e, ainda assim,
com o quão poderoso ele se torna.
Muito bem, então vamos prosseguir e escrever nossa classe de Nodo.
Agora, vou colocar todo o meu roteiro em uma nova pasta.
Já existe uma pasta de árvore B que você encontrará quando tiver trazido aquele projeto, mas que tem a missão de
NAV, por isso não queremos usar isso.
Portanto, vamos descer fora de tudo.
Portanto, não o crio dentro de outra coisa.
E vamos chamar esta árvore de comportamento, ou você poderia chamá-la de script se quiser colocá-la lá dentro, vamos abrir
isto.
Certo.
Portanto, aqui, vamos criar um novo arquivo em C afiado e vamos chamá-lo de Nodo.
Então, você quer abrir isso em seu editor.
Agora, como uma classe muito básica, não vai ser um comportamento mono.
Na verdade, todas essas aulas não funcionarão com comportamento mono.
Portanto, temos de projetá-las de forma que elas se atualizem.
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
para baixo para encontrar a primeira folha disponível que deve ser corrida e, em seguida, correr aquela.
Portanto, vamos nos livrar do Start e também atualizar.
Agora qualquer folha em particular ou qualquer nó pode realmente ter um dos três status.
Pode ter tido sucesso quando você tentou executá-lo, que falhou quando você tentou executá-lo,
ou que pode estar em estado de funcionamento, o que significa que ainda está sendo executado.
Está bem.
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
e depois fracassados, e então precisamos de um valor para realmente armazenar isso para que possamos registrar
qual deles conseguimos.
Portanto, status de público e depois chamaremos isso de status.
Certo.
Agora cada nó pode possivelmente ter nós de crianças.
Certo.
Portanto, se é o nó raiz, tem os nós imediatamente abaixo dele como seus filhos, o seletor
e os nós de seqüência, eles têm ações e condições como crianças.
Assim, basicamente cada nó pode ter um conjunto de crianças.
É claro que os nós da folha vão ter um conjunto vazio de crianças, mas tudo bem.
Vamos simplesmente armazená-las aqui.
Por isso, vou criar uma lista pública para armazenar aqueles em quatro nós.
Portanto, uma lista de nós, crianças, e nós faremos esse novo nó de lista igual a esse.
Certo.
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,
como se estivesse lendo um após o outro, especialmente se você estiver em uma seqüência,
por exemplo, e tiver três coisas que você quer fazer em seqüência.
Você quer que eles sejam colocados na lista para que possam funcionar.
E então você precisa do nó para realmente acompanhar qual deles está funcionando a qualquer momento em particular.
Assim, criaremos uma intensão pública e chamaremos isso de criança atual e colocaremos isso a zero.
Por isso, logo no início, ele vai estar olhando para o primeiro aviso de uma criança.
Vai correr primeiro.
Está bem.
Agora, para tornar sua própria vida de depuração um pouco mais fácil, nós vamos.
Dê também um nome a cada nota.
E isto só para que possamos imprimir e ver como é nossa árvore.
Assim, um nome público de cadeia como esse.
Então, vamos criar um construtor.
Então, nós colocaremos um nó público e um fio e aqui colocaremos um nome igual e também faremos um construtor
sem nada nele, porque o C afiado gosta de fazer isso.
Agora, neste caso, você acabará com o nome praticamente vazio, mas usaremos este aqui em seu lugar.
Agora, a outra coisa que quero fazer antes de terminarmos com isto, por enquanto, é acrescentar um método público para adicionar
nosso filho.
Então o vazio público acrescenta criança, vamos passar um nódulo e então dentro daqui vamos apenas adicionar
n a criança ponto e vamos adicionar n a ele.
Portanto, o primeiro que você colocar na lista estará no topo da lista.
Portanto, isso será criança zero.
E então você terá criança um, criança dois ao passar por essa lista.
E, portanto, você tem que colocá-los na lista para que apareçam ou que você queira que sejam
executados dentro de seu comportamento.
TREE ok, então nós temos isso.
Vamos agora salvá-lo.
Vamos voltar à unidade.
Não temos nada para correr neste ponto, mas queremos levá-lo a um ponto em que possamos realmente
criar uma árvore.
Vamos criar um roteiro para nossa árvore de comportamento.
Então, vamos chamar isso de árvore de comportamento.
Agora estou usando a ortografia de comportamento australiana.
Cabe a você decidir qual deles você usa.
Vamos abrir isso em nosso editor.
E mais uma vez, vamos nos livrar do comportamento mono, mas na verdade vamos dizer que nossa
á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
filhos.
Eles estão em seus próprios filhos.
Portanto, árvore de comportamento público.
Agora, é claro, você não precisa nem mesmo desta classe em particular porque você poderia simplesmente criar um nó e chamá-lo
de raiz e depois usá-lo.
Mas só por uma questão de completude aqui, vou me certificar de distinguir uma árvore de comportamento
ou algo diferente.
Portanto, vamos chamar este nome de árvore.
E é claro que você poderia passar por um determinado tipo de comportamento se quisesse uma espécie de guarda e comportamento
de PC para o que ele deveria fazer.
Poderia ter uma árvore de comportamento particular e então você poderia ter outra árvore de comportamento.
Portanto, esta classe aqui poderia ser expandida no futuro para ser lida em uma espécie de árvore
de comportamento que você escreveu como algum tipo de arquivo JSON ou arquivo XML ou até mesmo apenas texto para carregar nos comportamentos reais.
Não vamos fazer isso aqui, mas é o tipo de coisa que você poderia fazer com isto.
E depois vamos colocar em árvore de comportamento público e vamos passar por um fio e colocar o nome aqui.
Certo.
Portanto, vamos salvar isso.
Agora vamos voltar à Unidade e vamos criar outro roteiro.
E este será o roteiro que realmente colocamos em nosso ladrão, nosso objeto ladrão.
Então vamos criar um roteiro afiado e vamos chamar isso de comportamento de ladrão.
Abra isso.
E desta vez vamos mantê-lo como um comportamento, porque na verdade isto vai continuar para o nosso
agente e vai correr.
Portanto, aqui em cima, a primeira coisa que faremos é realmente criar uma árvore de comportamento para que possamos ir árvore de comportamento,
vamos chamá-la de árvore.
E então, no início, vamos construir uma árvore muito, muito simples.
Portanto, árvore é igual a árvore de comportamento novo, e neste momento vou deixar que ela seja chamada de árvore.
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
que vamos chamar de aço.
E então o que implica em roubar algo é, bem, podemos roubar o diamante, por exemplo.
Então criaremos um nó para ir ao diamante e igualaremos um novo nó, iremos ao diamante e depois outro nó irá ao Van,
que é o pequeno caminhão que está na cena lá.
Então, vamos fazer com que nosso agente se mude para onde está o diamante e depois voltar para a van.
Então, isso vai igualar o novo nó.
Vá para van.
Agora, como construímos esta árvore?
Temos que fazer isso ao contrário para que nosso aço não acrescente criança primeiro.
Vamos adicionar, ir ao diamante e depois ao Steel Dot, adicionar criança, ir ao furgão e depois pegar nossa árvore.
Ponto para adicionar criança para o aço.
Portanto, neste ponto, nossa árvore deve parecer muito simples e como faz na tela aqui.
Como sabemos que isto é correto?
Certo.
Bem, eu vou apenas salvar isto.
Vou voltar à nossa árvore de comportamento e criar aqui um pequeno método de árvore de impressão para que
possamos ver algo no console.
Certo.
Portanto, essa será uma árvore de impressão vazia ao público.
E depois dentro daqui.
Bem, você não achava que eu ia facilitar as coisas para você, não é mesmo?
Isto vai ser um desafio para você para chegar ao código que vai nesta árvore de impressão.
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
do código de comportamento da borracha ou em qualquer lugar.
Então tudo o que você tem que fazer é descobrir como você vai atravessar a árvore
na ordem certa e exibi-la no console?
Dê uma olhada nisso.
Quando voltarmos no próximo vídeo, completaremos este código e continuaremos a escrever o código que realmente
fará com que nosso pequeno agente de borracha se mova na tela.