WEBVTT

00:03.770 --> 00:04.760
Bienvenido de nuevo.

00:04.790 --> 00:11.120
En la última conferencia, te dejé con la tarea de imprimir el sencillo árbol de comportamiento que hemos estado

00:11.120 --> 00:12.500
construyendo.

00:12.920 --> 00:21.590
Desgraciadamente, esto no es una tarea sencilla y bien hecho si consigues descifrarlo.

00:21.740 --> 00:25.850
Mejor aún si realmente fue a investigar un poco para saber cómo hacerlo.

00:25.900 --> 00:32.810
Bien, entonces el Árbol de Comportamiento es básicamente un gráfico y hay un montón de algoritmos por ahí que

00:32.810 --> 00:36.780
ya han sido escritos para recorrer un gráfico e imprimirlo.

00:36.800 --> 00:39.190
Puedes hacerlo de dos maneras.

00:39.200 --> 00:44.150
Puedes utilizar la recursión o puedes hacerlo sin recursión.

00:44.150 --> 00:50.600
Ahora voy a hacerlo sin recursividad, sólo para no confundir a la gente que no está al tanto de cómo funciona

00:50.600 --> 00:54.680
la recursividad, porque puede ser un poco alucinante.

00:55.160 --> 00:55.640
Muy bien.

00:55.640 --> 00:58.950
Así que empecemos con nuestro árbol de huellas.

00:58.970 --> 01:07.130
Así que aquí, estoy, en primer lugar, va a poner en una cadena y que la cadena será la impresión del árbol.

01:08.180 --> 01:11.810
Así que voy a almacenar todo en una cadena y luego imprimirlo al final.

01:12.050 --> 01:14.600
Así que eso no equivale a nada en este momento.

01:14.840 --> 01:23.660
Ahora, para recordar dónde estamos en este árbol, voy a crear una pila y la pila va a tener

01:23.660 --> 01:25.610
nodos en ella.

01:26.750 --> 01:33.680
Y llamemos a eso la pila de nodos igual a la nueva pila de nodos.

01:33.770 --> 01:37.190
Y luego ponemos el nodo actual.

01:37.190 --> 01:41.690
Así que el nodo actual en este punto es el propio árbol básico.

01:41.960 --> 01:56.810
Así que vamos a ir nodo, nodo actual es igual a esto y luego vamos a ir nodo pila punto, empuje actual.

01:58.050 --> 01:58.810
Nota.

01:59.490 --> 02:04.320
Bien, entonces tenemos la raíz del árbol en esa pila.

02:04.680 --> 02:13.140
A continuación, básicamente empezamos a hacer un bucle a través de cada nodo que si tiene hijos, queremos ponerlos

02:13.140 --> 02:18.420
en la pila y luego queremos salir de los padres e imprimirlos.

02:18.420 --> 02:31.140
Así que va a parecer esto mientras la pila de nodos no cuenta, no es igual a cero, y no debería la primera vez porque hemos

02:31.140 --> 02:34.650
puesto un nodo aquí arriba.

02:34.920 --> 02:42.120
Así que mientras no es igual al nodo cero, el siguiente nodo es igual al nodo.

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

02:46.340 --> 02:50.990
Así que nos agarramos a la ruta en este punto porque es la única que hay.

02:51.230 --> 02:52.820
Y luego lo imprimimos.

02:52.820 --> 02:55.020
Así que lo añadimos a nuestra cadena de impresión del árbol.

02:55.040 --> 03:04.070
Va a ser igual más igual al siguiente nombre de nodo más un retorno.

03:04.760 --> 03:06.910
Así que podemos bajar a una nueva línea.

03:07.160 --> 03:15.380
Luego vamos por int I y hacemos un bucle alrededor de todos los hijos del que acabamos de sacar y los ponemos

03:15.380 --> 03:16.940
en la pila.

03:17.150 --> 03:17.570
De acuerdo.

03:17.570 --> 03:22.410
Así que en este caso, voy a hacer un bucle hacia atrás a través de los niños.

03:22.430 --> 03:27.380
La razón es que, si miras hacia adelante a través de los hijos, en realidad los imprime en

03:27.380 --> 03:30.920
orden inverso debido a la forma en que está saliendo de la pila.

03:31.190 --> 03:35.300
Así que voy a empezar por el extremo superior de la lista de niños.

03:35.300 --> 03:43.100
Así que el siguiente nodo punto hijos, punto, cuenta menos uno.

03:43.220 --> 03:48.050
I es entonces mayor o igual a cero.

03:48.050 --> 03:56.060
Así que, aunque no hemos contado con todos los niños menos con los que añadiremos a nuestra pila.

03:56.060 --> 04:01.220
Así que la pila de nodos dot push siguiente.

04:01.580 --> 04:02.750
Punto de nodo.

04:04.400 --> 04:05.420
Los niños.

04:06.020 --> 04:06.890
I.

04:09.100 --> 04:09.580
De acuerdo.

04:09.670 --> 04:17.560
Entonces cuando hayamos hecho eso podemos ir a depurar el registro y vamos a imprimir el árbol.

04:18.520 --> 04:23.550
Imprime el valor así y eso imprimirá nuestro árbol.

04:23.560 --> 04:24.190
Así que.

04:24.220 --> 04:25.690
¿Cómo te fue?

04:25.930 --> 04:30.040
Supongo que si tienes algo que funciona, sabes que está funcionando así que bien hecho.

04:30.610 --> 04:33.280
Esta es la forma en que lo estoy haciendo.

04:33.520 --> 04:36.460
Si tienes un método diferente que te funcione, compártelo.

04:36.460 --> 04:42.080
Si lo has hecho con recursión, compártelo también para que otros puedan aprender de tu código.

04:42.130 --> 04:43.570
Bien, voy a guardar eso.

04:43.570 --> 04:52.630
Ahora, de vuelta en mi comportamiento de la goma, en realidad he añadido en una especie de nodos adicionales ficticios aquí sólo para que tengan algo más

04:52.630 --> 04:56.340
interesante para imprimir y voy a eliminar un poco más tarde.

04:56.350 --> 04:58.960
Así que tenemos nuestro material de robo aquí arriba.

04:59.200 --> 05:07.120
También he añadido un nodo ocho que tendrá dos hijos de ir a la pizzería y comprar pizza, y por lo tanto los estoy añadiendo

05:07.120 --> 05:12.670
aquí abajo de la misma manera que hicimos para el acero en la parte superior.

05:12.670 --> 05:14.410
Por supuesto, no es necesario ponerlas.

05:14.410 --> 05:17.260
Sólo me gusta ver un poco más de datos cuando imprimo esto.

05:17.440 --> 05:17.860
De acuerdo.

05:17.860 --> 05:25.360
Así que en la parte inferior del inicio, podemos entonces ir árbol, punto, imprimir árbol para ejecutar ese método que acabamos de crear.

05:25.360 --> 05:26.290
Guárdalo.

05:26.290 --> 05:29.140
Ahora volvamos a la unidad entonces.

05:29.140 --> 05:33.270
¿Quieres añadir el script de comportamiento de la goma al ladrón?

05:33.280 --> 05:35.320
Como puedes ver, ya lo he hecho aquí.

05:35.590 --> 05:38.800
Y vamos a pulsar el play y echar un vistazo.

05:39.130 --> 05:42.070
Bien, ahora toca en la consola.

05:42.070 --> 05:43.780
No verás todo el árbol.

05:43.780 --> 05:45.640
Sólo vas a ver el nivel superior del árbol.

05:45.640 --> 05:50.770
Pero si haces clic aquí abajo en la consola actual, verás tu árbol.

05:50.770 --> 05:52.960
Así que hay árbol todavía algo.

05:52.960 --> 05:56.170
Así que ese es el primer hijo del árbol.

05:56.170 --> 06:01.810
Y luego tienes que ir a Diamond, ir a Van, luego tienes que comer algo e ir a la

06:01.810 --> 06:03.940
pizzería y comprar pizza.

06:04.390 --> 06:04.810
Genial.

06:04.810 --> 06:07.240
Así que todo está en el orden correcto.

06:07.270 --> 06:14.680
Ahora, lo que estaría muy bien es que pudiéramos hacer una sangría para mostrar cuáles son hijos de cuáles.

06:14.830 --> 06:24.100
Así que con un poco de código complicado, si vuelvo a entrar ahí, voy a añadir una pequeña estructura muy simple y descarada

06:24.100 --> 06:26.380
justo aquí arriba.

06:26.380 --> 06:37.330
Así que vamos a crear una estructura o nivel de nodo y esta estructura va a mantener el nodo y el nivel que el nodo

06:37.330 --> 06:39.310
está en el árbol.

06:39.310 --> 06:41.500
Así que la raíz es el nivel cero.

06:41.530 --> 06:43.510
El siguiente nodo hacia abajo sería el nivel uno.

06:43.510 --> 06:45.550
Sus hijos serán de nivel 2.

06:45.940 --> 06:49.720
Y luego cualquiera al mismo nivel que uno, todos serán unos.

06:49.720 --> 06:52.810
Y luego sus hijos tienen dos y tres años de edad en todo el camino.

06:52.810 --> 07:04.810
Así que aquí queremos tener un nivel int público y un nodo público para almacenar el nodo.

07:04.810 --> 07:05.150
¿De acuerdo?

07:05.170 --> 07:10.510
Así que una vez que hemos hecho eso, sólo tenemos que modificar nuestro árbol de impresión.

07:10.510 --> 07:15.340
Así que esta pila ahora va a tener nivel de nodo en su lugar.

07:15.340 --> 07:24.010
Así que aquí voy a poner el nivel de nodo por aquí será el nivel de nodo.

07:25.090 --> 07:30.430
Entonces, cuando empujamos la primera cosa en esa pila, ya no es un nodo.

07:30.430 --> 07:32.230
Tiene que ser un nivel de nodo.

07:32.230 --> 07:34.870
Así que dentro de aquí pondremos lo nuevo.

07:37.460 --> 07:47.630
No hay nivel y porque es una estructura, podemos ir como este nivel es igual al nodo actual y luego saber que no necesita es igual

07:47.660 --> 07:51.070
al nivel que será cero en este punto.

07:51.080 --> 07:51.920
Coma.

07:52.580 --> 07:58.490
El nodo es igual al nodo actual y al final hay unos corchetes.

07:58.490 --> 08:05.300
Así que fíjate en cómo se declara y se crea esa estructura y se empuja a través de ella.

08:05.480 --> 08:06.050
De acuerdo.

08:06.050 --> 08:12.950
Entonces tenemos dentro de nuestro bucle while que queremos hacer lo mismo es correcto.

08:12.950 --> 08:13.250
O esto.

08:13.250 --> 08:17.090
Ahora, lo que se va a sacar en este punto va a ser un nivel de nodo.

08:18.470 --> 08:28.460
Y entonces lo que estamos imprimiendo aquí es el siguiente nodo, punto nodo, punto nombre, y queremos usar el

08:28.460 --> 08:29.120
nivel.

08:29.120 --> 08:31.130
Ahora vamos a utilizar el nivel no impreso.

08:31.130 --> 08:35.540
Se podría imprimir lo que es el nivel sería cero uno, dos, tres, lo que sea, pero en realidad

08:35.540 --> 08:39.470
vamos a utilizar el número del nivel para poner algunos guiones.

08:39.740 --> 08:49.460
Así que vamos a poner nueva cadena y luego dentro de aquí una comilla simple, un guión, una comilla simple, y luego

08:49.460 --> 08:53.660
una coma, siguiente nodo nivel de punto.

08:54.050 --> 08:57.920
Y eso será un plus.

09:00.020 --> 09:02.510
Por el nombre.

09:02.990 --> 09:08.990
Así que lo que sea este número aquí, imprimirá esta cantidad de guiones.

09:08.990 --> 09:15.890
Así que si estás en el nivel cinco, por ejemplo, habrá cinco guiones ahora en el bucle for, será punto

09:15.890 --> 09:20.930
de nodo siguiente, punto de nodo, recuento de puntos de niños.

09:21.050 --> 09:27.200
Y entonces lo que estamos empujando de nuevo aquí abajo es esto básicamente.

09:27.620 --> 09:36.950
Así que queremos un nuevo nivel de nodo, el nivel de soporte es igual.

09:36.950 --> 09:38.750
Ahora, ¿a qué va a equivaler en este momento?

09:38.750 --> 09:47.600
Bueno, si hemos ido a los hijos, va a ser igual al siguiente nodo aquí fue el nivel más uno, porque este es el

09:47.600 --> 09:52.220
que es el padre que estamos recibiendo los niños de.

09:52.220 --> 10:01.430
Así que si copiamos eso y lo ponemos aquí y luego ponemos más uno y luego pondremos una coma y esto

10:01.430 --> 10:04.130
será nodo igual a eso.

10:04.130 --> 10:14.330
Y no olvides el corchete al final y esto será el siguiente nodo punto, nodo punto hijos.

10:14.570 --> 10:18.440
Bien, así es como podemos hacerlo con esta estructura.

10:18.440 --> 10:20.540
Y, por supuesto, puedes poner esa estructura en la parte superior de tu código.

10:20.540 --> 10:26.030
Lo pongo ahí para que lo puedas ver en la misma pantalla que el resto del caso.

10:26.030 --> 10:27.380
Así que guárdalo.

10:27.650 --> 10:30.470
Volvamos a entrar aquí.

10:30.830 --> 10:39.440
Ahora, cuando pulsamos el play y bajamos a echar un vistazo a nuestro árbol, echa un vistazo a la preciosa estructura que tenemos.

10:39.440 --> 10:39.650
¿De acuerdo?

10:39.650 --> 10:42.200
Así que tenemos nuestro árbol en la parte superior.

10:42.200 --> 10:45.770
Entonces tenemos una carrera para nuestro primer nivel de acero algo.

10:45.770 --> 10:50.150
Y si bajas a comer algo, puedes ver que eso también tiene una sola raya.

10:50.150 --> 10:56.750
Y los hijos de cada uno de estos van a Diamante, van a Van son ahora sangrados por dos.

10:56.750 --> 11:01.550
Si quieres exagerar, puedes poner más de un guión que se repita.

11:02.600 --> 11:12.440
Ahora que tenemos esto, podemos utilizarlo en cualquier momento para comprobar que nuestro árbol es correcto en todo momento.

11:12.440 --> 11:19.400
Así que es sólo una pequeña manera de depurar que, así como aprender un algoritmo para recorrer a través de su árbol de

11:19.490 --> 11:20.720
comportamiento.

11:20.930 --> 11:21.350
De acuerdo.

11:21.350 --> 11:25.370
Así que déjame volver al código aquí en caso de que hayas estado siguiendo.

11:25.370 --> 11:26.000
Exactamente.

11:26.000 --> 11:34.340
Voy a volver a mi goma y en realidad voy a deshacerme de mi consumo de la pizza porque en realidad no es realmente

11:34.340 --> 11:37.400
relevante en este momento.

11:37.400 --> 11:41.930
Y si quieres dejar ese árbol de huellas ahí, pues mejor, porque

11:41.930 --> 11:45.890
si te has tomado la molestia de crearlo y te va a servir.

11:46.070 --> 11:46.550
Muy bien.

11:46.550 --> 11:48.530
Así que eso es imprimir tu árbol.

11:48.530 --> 11:55.580
En el próximo vídeo, volveremos a ver las acciones y cómo hacer que nuestro personaje

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