WEBVTT

00:02.640 --> 00:08.340
Antes de empezar a escribir nuestro código, recordemos qué es lo que queremos construir.

00:08.340 --> 00:11.690
Y eso es básicamente esta estructura de árbol aquí.

00:11.700 --> 00:19.260
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

00:19.260 --> 00:26.880
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.

00:26.880 --> 00:30.300
Y las líneas muestran cuáles están conectadas con cuáles.

00:30.300 --> 00:38.730
Ahora, si recuerdas, las que están justo en la parte inferior son las acciones o cosas reales que sucederán

00:38.730 --> 00:44.880
y que harán que tu personaje haga su comportamiento que verás en la pantalla.

00:44.910 --> 00:47.520
Los otros lo unen todo.

00:47.520 --> 00:52.650
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

00:52.650 --> 00:53.640
más adelante.

00:53.820 --> 00:58.980
Luego tenemos nuestra secuencia y nuestros selectores, que también escribiremos un poco más adelante.

00:58.980 --> 01:07.980
Pero todos ellos son básicamente nodos y, por tanto, un nodo será nuestra clase base que implementaremos.

01:08.370 --> 01:17.610
Y cuando empecemos a escribirlo, te sorprenderá absolutamente lo sencillo que es el código y, sin embargo,

01:17.610 --> 01:20.460
lo potente que resulta.

01:21.270 --> 01:25.890
Bien, entonces sigamos adelante y escribamos nuestra clase Node.

01:25.890 --> 01:29.040
Ahora, pondré todo mi script en una nueva carpeta.

01:29.220 --> 01:35.010
Ya hay una carpeta del árbol B que encontrarás cuando hayas traído ese proyecto, pero que tiene la misión

01:35.010 --> 01:36.990
NAV, así que no queremos usarla.

01:36.990 --> 01:40.470
Así que vamos a bajar fuera de todo.

01:40.470 --> 01:42.150
Así que no lo creo dentro de otra cosa.

01:42.150 --> 01:50.010
Y llamemos a este árbol de comportamiento, o podrías llamarlo script si quieres ponerlo ahí, abramos

01:50.010 --> 01:50.790
esto.

01:50.790 --> 01:51.180
De acuerdo.

01:51.240 --> 01:56.970
Así que aquí, vamos a crear un nuevo archivo C-sharp y vamos a llamarlo Nodo.

01:56.970 --> 01:59.610
Entonces querrás abrirlo en tu editor.

01:59.610 --> 02:04.530
Ahora, como una clase muy básica, no va a ser un comportamiento mono.

02:04.530 --> 02:09.120
De hecho, todas estas clases no funcionarán en el comportamiento mono.

02:09.120 --> 02:12.870
Así que tenemos que diseñarlos de forma que se actualicen solos.

02:12.870 --> 02:20.400
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

02:20.400 --> 02:26.430
mirará hacia abajo para encontrar la primera hoja disponible que se debe ejecutar y luego ejecutar

02:26.430 --> 02:27.150
eso.

02:27.150 --> 02:30.090
Así que vamos a deshacernos de Start y también a actualizar.

02:30.090 --> 02:37.500
Ahora, cualquier hoja particular o cualquier nodo puede tener uno de los tres estados.

02:37.500 --> 02:43.800
Puede tener que fue exitoso cuando intentaste ejecutarlo, que falló cuando intentaste ejecutarlo,

02:43.800 --> 02:50.220
o que puede estar en estado de ejecución, lo que significa que todavía se está ejecutando.

02:50.220 --> 02:50.570
De acuerdo.

02:50.640 --> 03:00.960
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

03:00.990 --> 03:10.380
y luego el fracaso, y luego necesitamos un valor para almacenar que en realidad para que podamos registrar

03:10.380 --> 03:13.020
lo que hemos logrado.

03:13.020 --> 03:18.000
Así que el estado público y luego vamos a llamar a ese estado.

03:18.630 --> 03:19.080
De acuerdo.

03:19.080 --> 03:24.780
Ahora cada nodo puede tener posiblemente nodos hijos.

03:24.780 --> 03:24.980
De acuerdo.

03:25.050 --> 03:32.640
Así que si es el nodo raíz, tiene los nodos inmediatamente debajo de él como sus hijos, el selector y

03:32.640 --> 03:38.190
los nodos de secuencia, tienen acciones y condiciones como sus hijos.

03:38.190 --> 03:41.550
Así que básicamente cada nodo puede tener un conjunto de hijos.

03:41.550 --> 03:45.840
Por supuesto, los nodos hoja van a tener un conjunto vacío de hijos, pero eso está bien.

03:45.840 --> 03:47.100
Vamos a guardarlos aquí.

03:47.100 --> 03:52.110
Así que voy a crear una lista pública para almacenar esos en cuatro nodos.

03:52.110 --> 04:05.700
Así que una lista de nodos, los niños, y vamos a hacer que la igualdad de nuevo nodo de la lista así.

04:05.970 --> 04:06.510
De acuerdo.

04:06.510 --> 04:16.920
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,

04:16.920 --> 04:23.160
como si estuviera leyendo uno tras otro, especialmente si estás en una secuencia,

04:23.160 --> 04:29.520
por ejemplo, y tienes tres cosas que quieres hacer en secuencia.

04:29.520 --> 04:34.380
Es conveniente que los pongas en la lista en el orden en que se ejecutarán.

04:34.500 --> 04:40.920
Y luego necesitas que el nodo lleve la cuenta de cuál está ejecutando en cada momento.

04:40.920 --> 04:48.090
Así que crearemos un int público y lo llamaremos el hijo actual y lo pondremos a cero.

04:48.330 --> 04:54.270
Así que justo al principio va a estar mirando su primer aviso de hijo de uno.

04:54.270 --> 04:56.640
Va a correr primero.

04:57.210 --> 04:57.720
De acuerdo.

04:57.720 --> 05:01.890
Ahora, para hacer su propia vida de depuración un poco más fácil, vamos a.

05:02.000 --> 05:04.820
También hay que dar un nombre a cada nota.

05:04.910 --> 05:09.410
Y esto es sólo para que podamos imprimirlo y ver cómo es nuestro árbol.

05:09.590 --> 05:14.270
Así que el nombre de la cadena pública así.

05:14.270 --> 05:17.090
Entonces vamos a crear un constructor.

05:17.090 --> 05:29.810
Así que public node y pondremos string y aquí pondremos name equals y y también haremos un constructor

05:29.810 --> 05:36.710
sin nada dentro porque a C-sharp le gusta hacer eso.

05:36.710 --> 05:43.520
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.

05:43.520 --> 05:50.060
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

05:50.060 --> 05:51.320
nuestro hijo.

05:51.320 --> 06:02.540
Así que public void add child, vamos a pasarle un nodo n y luego dentro de aquí simplemente iremos

06:02.870 --> 06:07.220
children dot add y le añadiremos n.

06:07.220 --> 06:11.300
Así que el primero que pongas en la lista será el primero de la lista.

06:11.300 --> 06:13.220
Así que ese será el niño cero.

06:13.250 --> 06:16.940
Y luego tendrás al niño uno, al niño dos a medida que avanzas en la lista.

06:16.940 --> 06:22.640
Y por lo tanto tienes que ponerlos en la lista en el orden que aparecen o que quieres que

06:22.640 --> 06:25.820
se ejecuten dentro de tu comportamiento.

06:25.820 --> 06:28.370
ÁRBOL bien, así que tenemos eso.

06:28.370 --> 06:30.290
Ahora vamos a guardarlo.

06:30.830 --> 06:32.720
Volvamos a la unidad.

06:32.720 --> 06:37.580
No tenemos nada que ejecutar en este momento, pero queremos llegar a un punto en el que podamos

06:37.580 --> 06:38.540
crear un árbol.

06:38.660 --> 06:43.730
Vamos a crear un script para nuestro árbol de comportamiento.

06:43.730 --> 06:48.950
Llamemos a esto árbol de comportamiento.

06:48.950 --> 06:52.820
Ahora estoy usando la ortografía australiana de comportamiento.

06:52.970 --> 06:54.560
Depende de usted cuál utilice.

06:54.560 --> 06:56.480
Abramos eso en nuestro editor.

06:56.480 --> 07:01.460
Y una vez más, nos desharemos del comportamiento mono, pero en realidad diremos que nuestro

07:01.460 --> 07:08.120
á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

07:08.120 --> 07:08.780
hijos.

07:08.780 --> 07:09.830
Están en sus propios hijos.

07:09.830 --> 07:15.620
Así que árbol de comportamiento público.

07:15.830 --> 07:22.520
Ahora, por supuesto, ni siquiera necesitas esta clase en particular porque podrías simplemente crear un nodo

07:22.520 --> 07:24.410
y llamarlo raíz y luego usarlo.

07:24.410 --> 07:30.140
Pero sólo para una especie de integridad aquí, sólo voy a asegurarse de que distinguir un árbol de comportamiento

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

07:32.060 --> 07:35.780
Así que vamos a llamar a este nombre árbol igual.

07:35.780 --> 07:43.460
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

07:43.460 --> 07:45.890
de PC para lo que debe hacer.

07:45.890 --> 07:49.190
Podría tener un árbol de comportamiento particular y luego podría tener otro árbol de comportamiento.

07:49.190 --> 07:55.100
Así que esta clase podría ampliarse en el futuro para leer un árbol de comportamiento

07:55.100 --> 08:04.190
que se ha escrito como una especie de archivo JSON o XML o incluso sólo texto para cargar en los comportamientos reales.

08:04.310 --> 08:08.270
No lo haremos aquí, pero es el tipo de cosas que podrías hacer con esto.

08:08.270 --> 08:19.850
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

08:19.850 --> 08:20.480
aquí.

08:23.010 --> 08:23.500
De acuerdo.

08:23.520 --> 08:24.760
Así que guardemos eso.

08:24.780 --> 08:29.400
Ahora volvamos a Unity y crearemos otro script.

08:29.400 --> 08:34.230
Y este será el guión que pondremos en nuestro ladrón, nuestro objeto ladrón.

08:34.230 --> 08:41.010
Así que vamos a crear un script en C-sharp y vamos a llamar a este comportamiento ladrón.

08:41.550 --> 08:42.660
Abre eso.

08:42.660 --> 08:49.980
Y esta vez lo mantendremos como un comportamiento, porque esto realmente va a ir a nuestro agente

08:49.980 --> 08:51.660
y se va a ejecutar.

08:51.660 --> 08:58.320
Así que aquí arriba, lo primero que haremos es crear un árbol de comportamiento para que podamos ir árbol de comportamiento,

08:58.320 --> 08:59.640
vamos a llamarlo árbol.

09:00.360 --> 09:07.410
Y luego en el inicio, vamos a construir un árbol muy, muy simple.

09:07.650 --> 09:15.450
Así que árbol es igual al nuevo comportamiento árbol, y dejaré que se llame árbol en este momento.

09:15.450 --> 09:25.110
Entonces creamos un nodo y el nodo debajo de eso va a ser acero, y eso va a ser igual al nuevo nodo acero,

09:25.620 --> 09:28.620
algo que llamaremos.

09:29.700 --> 09:36.900
Y entonces lo que conlleva robar algo es, bueno, podemos robar el diamante, por ejemplo.

09:36.900 --> 09:51.780
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

09:51.780 --> 09:58.200
es el pequeño camión que está en la escena allí.

09:58.200 --> 10:02.850
Así que vamos a hacer que nuestro agente se mueva hacia donde está el diamante y luego volver a la furgoneta.

10:02.850 --> 10:05.580
Así que eso va a ser igual a un nuevo nodo.

10:06.240 --> 10:08.880
Ir a la furgoneta.

10:10.530 --> 10:12.810
Ahora, ¿cómo construimos este árbol?

10:12.840 --> 10:21.130
Tenemos que hacerlo a la inversa para que nuestro acero no añada niño primero.

10:21.150 --> 10:34.140
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.

10:34.380 --> 10:37.470
Punto añadir niño para el acero.

10:38.670 --> 10:46.380
Así que en este punto, nuestro árbol debe parecer muy simple y como lo hace en la pantalla aquí.

10:46.920 --> 10:49.050
¿Cómo sabemos que esto es correcto?

10:49.080 --> 10:49.380
Sí.

10:49.380 --> 10:50.790
Bueno, voy a guardar esto.

10:50.820 --> 10:57.420
Voy a volver a nuestro árbol de comportamiento y crear un pequeño método de árbol de impresión aquí para que

10:57.420 --> 10:59.520
podamos ver algo en la consola.

10:59.800 --> 11:00.090
Sí.

11:00.090 --> 11:05.310
Así que será un árbol de impresión público y vacío.

11:06.840 --> 11:09.390
Y luego dentro de aquí.

11:09.720 --> 11:13.440
Bueno, no pensaste que te lo iba a poner tan fácil, ¿verdad?

11:13.470 --> 11:17.770
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.

11:17.790 --> 11:25.740
Ahora querrás usar los registros de depuración porque queremos que esto se imprima en la consola en cualquier momento que lo llamemos

11:25.740 --> 11:29.700
desde dentro del código de comportamiento de la goma o donde sea.

11:29.700 --> 11:36.420
Así que todo lo que tienes que hacer es averiguar cómo vas a recorrer el árbol en el

11:36.420 --> 11:40.050
orden correcto y mostrarlo en la consola.

11:40.410 --> 11:41.510
Inténtalo.

11:41.520 --> 11:49.710
Cuando volvamos en el próximo video, completaremos este código y continuaremos escribiendo el código que realmente

11:49.710 --> 11:54.570
hará que nuestro pequeño agente de goma se mueva en la pantalla.
