Antes de empezar a escribir nuestro código, recordemos qué es lo que queremos construir.
Y eso es básicamente esta estructura de árbol aquí.
Así que nuestro árbol de comportamiento se compone de un montón de nodos, y un árbol de comportamiento es sólo un gráfico
en el que cada caja, supongo que es un nodo que tiene alguna acción o condición o lo que sea asociado con él.
Y las líneas muestran cuáles están conectadas con cuáles.
Ahora, si recuerdas, las que están justo en la parte inferior son las acciones o cosas reales que sucederán
y que harán que tu personaje haga su comportamiento que verás en la pantalla.
Los otros lo unen todo.
Así que hay dos tipos de nodos de hoja es una acción y una condición, y vamos a llegar a esos un poco
más adelante.
Luego tenemos nuestra secuencia y nuestros selectores, que también escribiremos un poco más adelante.
Pero todos ellos son básicamente nodos y, por tanto, un nodo será nuestra clase base que implementaremos.
Y cuando empecemos a escribirlo, te sorprenderá absolutamente lo sencillo que es el código y, sin embargo,
lo potente que resulta.
Bien, entonces sigamos adelante y escribamos nuestra clase Node.
Ahora, pondré todo mi script en una nueva carpeta.
Ya hay una carpeta del árbol B que encontrarás cuando hayas traído ese proyecto, pero que tiene la misión
NAV, así que no queremos usarla.
Así que vamos a bajar fuera de todo.
Así que no lo creo dentro de otra cosa.
Y llamemos a este árbol de comportamiento, o podrías llamarlo script si quieres ponerlo ahí, abramos
esto.
De acuerdo.
Así que aquí, vamos a crear un nuevo archivo C-sharp y vamos a llamarlo Nodo.
Entonces querrás abrirlo en tu editor.
Ahora, como una clase muy básica, no va a ser un comportamiento mono.
De hecho, todas estas clases no funcionarán en el comportamiento mono.
Así que tenemos que diseñarlos de forma que se actualicen solos.
Pero como está en una estructura de árbol, se va a ejecutar desde el nodo raíz superior del árbol, y luego toda la estructura
mirará hacia abajo para encontrar la primera hoja disponible que se debe ejecutar y luego ejecutar
eso.
Así que vamos a deshacernos de Start y también a actualizar.
Ahora, cualquier hoja particular o cualquier nodo puede tener uno de los tres estados.
Puede tener que fue exitoso cuando intentaste ejecutarlo, que falló cuando intentaste ejecutarlo,
o que puede estar en estado de ejecución, lo que significa que todavía se está ejecutando.
De acuerdo.
Así que vamos a crear un enum público para eso y lo llamaremos estado y tenemos tres, así que exitoso o éxito en ejecución
y luego el fracaso, y luego necesitamos un valor para almacenar que en realidad para que podamos registrar
lo que hemos logrado.
Así que el estado público y luego vamos a llamar a ese estado.
De acuerdo.
Ahora cada nodo puede tener posiblemente nodos hijos.
De acuerdo.
Así que si es el nodo raíz, tiene los nodos inmediatamente debajo de él como sus hijos, el selector y
los nodos de secuencia, tienen acciones y condiciones como sus hijos.
Así que básicamente cada nodo puede tener un conjunto de hijos.
Por supuesto, los nodos hoja van a tener un conjunto vacío de hijos, pero eso está bien.
Vamos a guardarlos aquí.
Así que voy a crear una lista pública para almacenar esos en cuatro nodos.
Así que una lista de nodos, los niños, y vamos a hacer que la igualdad de nuevo nodo de la lista así.
De acuerdo.
Ahora cada vez que el nodo tiene que averiguar el estado de cualquiera de sus hijos, va a recorrerlos básicamente de izquierda a derecha,
como si estuviera leyendo uno tras otro, especialmente si estás en una secuencia,
por ejemplo, y tienes tres cosas que quieres hacer en secuencia.
Es conveniente que los pongas en la lista en el orden en que se ejecutarán.
Y luego necesitas que el nodo lleve la cuenta de cuál está ejecutando en cada momento.
Así que crearemos un int público y lo llamaremos el hijo actual y lo pondremos a cero.
Así que justo al principio va a estar mirando su primer aviso de hijo de uno.
Va a correr primero.
De acuerdo.
Ahora, para hacer su propia vida de depuración un poco más fácil, vamos a.
También hay que dar un nombre a cada nota.
Y esto es sólo para que podamos imprimirlo y ver cómo es nuestro árbol.
Así que el nombre de la cadena pública así.
Entonces vamos a crear un constructor.
Así que public node y pondremos string y aquí pondremos name equals y y también haremos un constructor
sin nada dentro porque a C-sharp le gusta hacer eso.
Ahora, en este caso, usted va a terminar con el nombre es prácticamente vacío, pero vamos a utilizar este aquí en su lugar.
Ahora, la otra cosa que quiero hacer antes de terminar con esto por ahora es añadir un método público para añadir
nuestro hijo.
Así que public void add child, vamos a pasarle un nodo n y luego dentro de aquí simplemente iremos
children dot add y le añadiremos n.
Así que el primero que pongas en la lista será el primero de la lista.
Así que ese será el niño cero.
Y luego tendrás al niño uno, al niño dos a medida que avanzas en la lista.
Y por lo tanto tienes que ponerlos en la lista en el orden que aparecen o que quieres que
se ejecuten dentro de tu comportamiento.
ÁRBOL bien, así que tenemos eso.
Ahora vamos a guardarlo.
Volvamos a la unidad.
No tenemos nada que ejecutar en este momento, pero queremos llegar a un punto en el que podamos
crear un árbol.
Vamos a crear un script para nuestro árbol de comportamiento.
Llamemos a esto árbol de comportamiento.
Ahora estoy usando la ortografía australiana de comportamiento.
Depende de usted cuál utilice.
Abramos eso en nuestro editor.
Y una vez más, nos desharemos del comportamiento mono, pero en realidad diremos que nuestro
árbol de comportamiento es básicamente un nodo porque es el nodo raíz y tiene hijos debajo de él, que luego tienen sus propios
hijos.
Están en sus propios hijos.
Así que árbol de comportamiento público.
Ahora, por supuesto, ni siquiera necesitas esta clase en particular porque podrías simplemente crear un nodo
y llamarlo raíz y luego usarlo.
Pero sólo para una especie de integridad aquí, sólo voy a asegurarse de que distinguir un árbol de comportamiento
o algo diferente.
Así que vamos a llamar a este nombre árbol igual.
Y, por supuesto, usted podría pasar a través de un tipo particular de comportamiento si usted quería una especie de guardia y el comportamiento
de PC para lo que debe hacer.
Podría tener un árbol de comportamiento particular y luego podría tener otro árbol de comportamiento.
Así que esta clase podría ampliarse en el futuro para leer un árbol de comportamiento
que se ha escrito como una especie de archivo JSON o XML o incluso sólo texto para cargar en los comportamientos reales.
No lo haremos aquí, pero es el tipo de cosas que podrías hacer con esto.
Y luego vamos a poner en el árbol de comportamiento público y vamos a pasar a través de una cadena en y establecer el nombre
aquí.
De acuerdo.
Así que guardemos eso.
Ahora volvamos a Unity y crearemos otro script.
Y este será el guión que pondremos en nuestro ladrón, nuestro objeto ladrón.
Así que vamos a crear un script en C-sharp y vamos a llamar a este comportamiento ladrón.
Abre eso.
Y esta vez lo mantendremos como un comportamiento, porque esto realmente va a ir a nuestro agente
y se va a ejecutar.
Así que aquí arriba, lo primero que haremos es crear un árbol de comportamiento para que podamos ir árbol de comportamiento,
vamos a llamarlo árbol.
Y luego en el inicio, vamos a construir un árbol muy, muy simple.
Así que árbol es igual al nuevo comportamiento árbol, y dejaré que se llame árbol en este momento.
Entonces creamos un nodo y el nodo debajo de eso va a ser acero, y eso va a ser igual al nuevo nodo acero,
algo que llamaremos.
Y entonces lo que conlleva robar algo es, bueno, podemos robar el diamante, por ejemplo.
Así que vamos a crear un nodo para ir al diamante y vamos a igualar nuevo nodo, ir al diamante, y luego otro nodo ir a Van, que
es el pequeño camión que está en la escena allí.
Así que vamos a hacer que nuestro agente se mueva hacia donde está el diamante y luego volver a la furgoneta.
Así que eso va a ser igual a un nuevo nodo.
Ir a la furgoneta.
Ahora, ¿cómo construimos este árbol?
Tenemos que hacerlo a la inversa para que nuestro acero no añada niño primero.
Vamos a añadir, ir a diamante y luego de acero Dot, añadir niño, ir a la furgoneta y luego tenemos nuestro árbol.
Punto añadir niño para el acero.
Así que en este punto, nuestro árbol debe parecer muy simple y como lo hace en la pantalla aquí.
¿Cómo sabemos que esto es correcto?
Sí.
Bueno, voy a guardar esto.
Voy a volver a nuestro árbol de comportamiento y crear un pequeño método de árbol de impresión aquí para que
podamos ver algo en la consola.
Sí.
Así que será un árbol de impresión público y vacío.
Y luego dentro de aquí.
Bueno, no pensaste que te lo iba a poner tan fácil, ¿verdad?
Esto va a ser un desafío para que usted pueda llegar con el código que va a ir en este árbol de impresión.
Ahora querrás usar los registros de depuración porque queremos que esto se imprima en la consola en cualquier momento que lo llamemos
desde dentro del código de comportamiento de la goma o donde sea.
Así que todo lo que tienes que hacer es averiguar cómo vas a recorrer el árbol en el
orden correcto y mostrarlo en la consola.
Inténtalo.
Cuando volvamos en el próximo video, completaremos este código y continuaremos escribiendo el código que realmente
hará que nuestro pequeño agente de goma se mueva en la pantalla.