WEBVTT

00:03.160 --> 00:09.730
En la clase anterior hemos configurado los fundamentos de nuestro árbol de comportamiento y hemos impreso los nodos reales

00:09.730 --> 00:11.560
y la estructura en la que vienen.

00:11.590 --> 00:15.120
Ahora los nodos de la parte inferior son los nodos hoja.

00:15.130 --> 00:21.010
Son los que van a hacer el trabajo y hacer que nuestro agente, que es nuestro ladrón en este caso, se mueva

00:21.010 --> 00:25.330
realmente por el mapa, lo que está simulando que realmente hace algo.

00:25.330 --> 00:31.450
Así que el primer conjunto de comportamientos que tenemos es ir a Diamond y luego volver a la furgoneta.

00:31.600 --> 00:32.050
De acuerdo.

00:32.050 --> 00:38.500
Así que lo primero es lo primero, nuestro pequeño agente aquí abajo, nuestro ladrón, si haces clic en él

00:38.500 --> 00:44.830
en la jerarquía y echas un vistazo en el inspector, verás que ya tiene un agente de malla naval allí.

00:44.830 --> 00:49.780
Así que tenemos que conseguir ese agente de malla naval dentro de la secuencia de comandos.

00:49.900 --> 00:57.580
También necesitamos saber en ese guión la ubicación del diamante, que está en esta parte de la galería

00:57.580 --> 01:01.150
y también la furgoneta que está por aquí.

01:01.330 --> 01:04.270
Y esos dos objetos están en la jerarquía, por supuesto.

01:04.270 --> 01:08.860
Así que también los tenemos, y podemos pasarlos al guión para el ladrón.

01:08.860 --> 01:13.600
Así que vamos a entrar ahí y a la parte superior aquí.

01:13.600 --> 01:15.310
Vamos a pasarlos.

01:15.310 --> 01:20.830
Así que queremos un objeto de juego público y ese será nuestro diamante.

01:21.940 --> 01:24.610
Y luego queremos un objeto de juego público.

01:26.450 --> 01:27.380
Furgoneta.

01:27.680 --> 01:31.160
Ahora también queremos crear nuestro agente de malla naval aquí.

01:31.160 --> 01:37.250
Así que arriba vamos a usar el motor de la unidad punto I.

01:38.180 --> 01:42.590
Y luego aquí abajo podemos crear nuestro agente.

01:42.590 --> 01:46.340
Así que es un agente de malla naval.

01:46.910 --> 01:57.530
Y para conseguir el asimiento de eso apenas abajo en el comienzo, iremos el agente igual este punto consigue el agente de la malla de la

01:57.860 --> 01:59.960
marina del componente.

02:01.160 --> 02:05.870
Bien, ahora podemos dirigirlo hacia el diamante.

02:05.870 --> 02:15.410
Así que si ponemos abajo en el inicio aquí, por ejemplo, el destino del conjunto de agentes y pasar por la posición transformada de

02:15.680 --> 02:22.550
diamante, que luego se moverá allí, independientemente de lo que el árbol está haciendo.

02:22.550 --> 02:25.610
Esto es sólo una prueba de nuestro agente configurado con nuestra malla de navegación.

02:25.610 --> 02:30.110
Así que guarda eso y entraremos en la unidad.

02:30.260 --> 02:32.060
Selecciona la goma.

02:32.090 --> 02:36.020
Ahora vas a encontrar a Diamond y Van expuestos en ese guión.

02:36.020 --> 02:41.510
Y así puedes agarrar el diamante, que en realidad está unido a este objeto llamado plinto.

02:41.660 --> 02:44.660
Y vamos a arrastrar y soltar eso en el diamante.

02:44.660 --> 02:50.540
Y la furgoneta en sí está aquí arriba, furgoneta de huida y arrastrar y soltar eso allí.

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

02:50.840 --> 02:58.220
Ahora, cuando pulsamos el play, ese agente establecido como destino va a hacer que se mueva a lo largo de nuestra malla de navegación.

02:58.220 --> 03:04.730
Va a pasar por el hueco más cercano que actualmente es esa puerta porque en realidad es sólo un objeto

03:04.730 --> 03:08.600
vacío sin ningún colisionador particular ni nada.

03:08.600 --> 03:10.610
Y se acerca al diamante.

03:10.610 --> 03:13.910
Bien, ya sabemos que la parte de la malla naval está funcionando.

03:13.910 --> 03:18.140
Tenemos que conectar todo eso con una acción real.

03:18.440 --> 03:23.240
Así que una acción tiene un proceso asociado.

03:23.240 --> 03:28.010
Volvamos a nuestro código para el nodo y recordemos lo que está pasando.

03:28.010 --> 03:35.420
Hemos configurado este estado de manera que cada nodo va a devolver éxito si ha terminado y se ha ejecutado con éxito

03:35.420 --> 03:41.570
si todavía se está ejecutando y fracaso si ha terminado de ejecutarse y en realidad ha fallado.

03:41.840 --> 03:46.400
Así que ahora hay tres cosas, ¿de dónde se devuelven realmente?

03:46.400 --> 03:53.420
Pues bien, se devuelven desde el proceso que ocurre dentro de cada nodo y dependiendo del tipo

03:53.420 --> 03:56.300
de nodo dependerá el tipo de proceso.

03:56.300 --> 04:05.750
Así que vamos a bajar aquí y voy a añadir en un nuevo proceso de estado virtual pública y este proceso aquí, que es básicamente

04:05.750 --> 04:10.910
sólo el nivel de nodo, porque vamos a anular todos estos, vamos

04:10.910 --> 04:18.890
a devolver el éxito de punto de estado como un defecto para ese nodo en particular.

04:18.920 --> 04:19.110
De acuerdo.

04:19.190 --> 04:20.630
Así que guarda eso.

04:20.630 --> 04:26.720
Ahora vamos a ir a nuestro árbol de comportamiento y darle un proceso.

04:26.720 --> 04:32.780
Así que en el árbol de comportamiento, vamos a venir aquí y justo por encima

04:33.830 --> 04:43.220
de todas estas cosas del árbol de impresión, vamos a poner en un proceso de estado de anulación pública así.

04:43.220 --> 04:46.550
Ahora, no vamos a devolver lo que hace la base en este caso.

04:46.550 --> 04:54.380
Lo que vamos a devolver en realidad en este árbol es lo que el hijo devuelve, porque recuerde que su árbol

04:54.380 --> 04:59.690
de comportamiento tiene que ejecutar, sus hijos no se ejecuta.

04:59.690 --> 05:02.600
Así que cada nodo, si tiene hijos, ejecuta los hijos.

05:02.600 --> 05:07.310
Y en función de lo que los niños respondan, se convierte en ese estatus.

05:07.310 --> 05:16.310
Así que aquí voy a ejecutar devolver a los niños el punto actual del niño.

05:17.020 --> 05:18.130
Proceso.

05:18.850 --> 05:23.920
Entonces, lo que devuelva, ese será el estado devuelto por el árbol de comportamiento.

05:23.920 --> 05:30.580
Y esto en realidad hace que el árbol de comportamiento a continuación, ejecute el proceso de los objetos de los niños.

05:30.610 --> 05:39.270
Ahora bien, en este caso, nuestros objetos hijos, si volvemos a nuestro ladrón, son ir a diamante e ir a Van.

05:39.280 --> 05:45.910
Ahora, actualmente, si se ejecutan, son sólo nodos básicos, por lo que van a volver.

05:46.540 --> 05:52.630
El éxito, que es bastante inútil para nosotros en este momento, significa que no están haciendo nada.

05:52.630 --> 05:58.960
Así que tenemos que crear otra clase para las hojas o una hoja.

05:58.960 --> 06:00.670
Así que volvamos a la unidad.

06:00.790 --> 06:07.060
Vamos a hacer clic derecho hacia abajo en nuestro árbol de comportamiento, crear un nuevo script, vamos a llamarlo Leaf.

06:07.090 --> 06:10.060
Entonces lo abriremos en el editor.

06:10.060 --> 06:15.190
Ahora Leaf va a heredar de Node.

06:16.150 --> 06:20.530
No va a tener un inicio en una actualización para que podamos deshacernos de eso.

06:20.560 --> 06:25.870
Ahora, la hoja en sí, esto va a ser un poco más complicado porque las hojas tienen que ejecutar realmente

06:25.870 --> 06:31.060
un proceso particular, lo que significa que va a haber algún método asignado a la hoja.

06:31.060 --> 06:33.610
No sabemos cuál es ese método.

06:33.610 --> 06:35.380
Podría ser cualquier cosa.

06:35.680 --> 06:43.030
Así que en este caso, va a ser para un comienzo corriendo que los agentes establecidos destino.

06:43.570 --> 06:45.670
Eso es lo que queremos que haga porque estamos usando una malla nativa.

06:45.670 --> 06:52.210
Pero si estás usando algún otro tipo de IA en tu sistema, puede que quieras ejecutar una máquina de estado

06:52.210 --> 06:56.470
finito o puede que quieras ejecutar una red neuronal o algo así.

06:56.470 --> 07:03.430
Pero sea lo que sea que hagan esos procesos, deben terminar devolviendo uno de nuestros estados de nodo.

07:03.430 --> 07:08.080
Así que, o éxito, o fracaso, o a correr.

07:08.380 --> 07:17.170
Ahora lo que vamos a hacer con estos nodos hoja es crear un delegado para que podamos pasar a través de los métodos, por lo que podemos codificar los métodos

07:17.170 --> 07:21.370
en otro lugar y luego pasar a través de ellos y decir, Esto es lo que queremos

07:21.370 --> 07:23.620
que nuestra hoja para ejecutar.

07:23.650 --> 07:23.900
¿De acuerdo?

07:23.920 --> 07:29.950
Ahora la forma en que hacemos eso es crear un delegado público y va a devolver un estado de nodo.

07:29.950 --> 07:35.350
Así que vamos a poner el estado y estos van a ser llamados una garrapata.

07:35.830 --> 07:41.110
Así que una garrapata es esencialmente una rotación para su árbol de comportamiento.

07:41.140 --> 07:48.430
Un tic es como un marco para el árbol de comportamiento, al igual que un marco ocurre cuando se ejecuta la actualización en la unidad.

07:48.460 --> 07:48.590
De acuerdo.

07:48.610 --> 07:56.020
Así que es una especie de, supongo, bucle alrededor de esa hoja o acción en particular en este caso, entonces necesitamos

07:56.020 --> 07:58.630
un puntero para establecer.

07:58.630 --> 08:06.310
Así que el método de proceso de tic público y esa es la forma en que lo hacemos allí.

08:06.370 --> 08:10.480
Entonces vamos a anular nuestro proceso.

08:10.480 --> 08:20.770
Así que public override status process de nuevo, nos deshacemos de esta base y en su lugar lo que vamos

08:20.770 --> 08:28.390
a devolver es el método process y el método process, va a devolver status.

08:28.660 --> 08:34.150
Así que esto es realmente trabajando para nosotros, siempre y cuando se establece con este método de proceso está aquí.

08:34.150 --> 08:44.470
Así que aquí arriba podría poner si el método de proceso no es igual a null, podemos devolver eso.

08:44.470 --> 08:50.410
De lo contrario, podemos devolver un fallo de punto de estado.

08:50.800 --> 08:52.900
Oh, qué está haciendo este Pennie.

08:52.930 --> 08:53.620
Comprobación de errores.

08:53.620 --> 08:53.980
Sí, lo sé.

08:53.980 --> 08:58.540
Es muy raro que lo haga, pero lo he hecho por ti ahí.

08:58.930 --> 08:59.530
De acuerdo.

08:59.530 --> 09:04.060
Y eso también te recordará si no has establecido un método para tu hoja.

09:04.600 --> 09:06.010
Bien, ya lo hemos hecho.

09:06.010 --> 09:10.120
¿Cómo conoce la hoja el método del proceso?

09:10.120 --> 09:15.550
Bueno, podríamos ir en el comportamiento un comportamiento y, a continuación, realmente asignar allí.

09:15.550 --> 09:22.360
Podríamos tener como ir al método de proceso de punto de diamante es igual a este método en particular o podríamos

09:22.360 --> 09:26.560
pasar a través de hacer una anulación de nuestro constructor.

09:26.560 --> 09:31.570
Así que queremos una hoja pública que no tenga casi nada.

09:31.600 --> 09:33.100
Ese es nuestro vacío.

09:33.250 --> 09:39.610
Y luego queremos una hoja pública y vamos a pasar por una cadena para el nombre

09:39.610 --> 09:43.420
y luego queremos procesar el método p m.

09:45.300 --> 09:46.440
Eso me gusta.

09:46.440 --> 09:55.320
Y entonces vamos a sentarnos igual n y p m.

09:56.610 --> 10:01.470
Método de proceso para igualar p m así.

10:01.470 --> 10:03.480
Ahora, esto no es correcto.

10:03.480 --> 10:06.630
Tiene que ser una garrapata así.

10:06.900 --> 10:08.040
Así que lo pasamos.

10:08.070 --> 10:12.810
Esto es, básicamente, es un puntero a nuestro método que estamos escribiendo, pasándolo a través de, y luego estamos configurando

10:12.810 --> 10:13.770
hasta aquí.

10:13.770 --> 10:20.400
Para que luego el método de proceso sepa dónde está aquí abajo y lo ejecute realmente por nosotros y deshagámonos de ese

10:20.400 --> 10:22.410
punto y coma para que no le guste.

10:22.530 --> 10:25.380
Bien, ahora guardaremos esto.

10:25.500 --> 10:30.420
Volvamos a nuestro ladrón y pongámoslo en práctica.

10:30.420 --> 10:36.690
Así que estos diamantes y furgonetas ahora se convierten en hojas en lugar de eso.

10:36.690 --> 10:46.170
Y ahora están queriendo ser construidos de hoja y hoja y en realidad necesitan tener algún tipo de método

10:46.170 --> 10:48.300
de paso también.

10:48.300 --> 10:54.240
Así que seguiremos adelante y escribiremos algo realmente rápido que satisfaga eso.

10:54.360 --> 11:01.590
Así que aquí abajo, vamos a crear un estado de nodo público.

11:01.590 --> 11:04.890
Tiene que estar en el mismo formato en el que se construye la garrapata.

11:04.890 --> 11:08.700
Así que vete al diamante así.

11:08.700 --> 11:14.730
Y cuando vamos al diamante, en realidad queremos básicamente estar ejecutando esto aquí.

11:14.730 --> 11:19.470
Así que saquemos eso de ahí y lo pondremos aquí.

11:19.980 --> 11:20.430
¿De acuerdo?

11:20.580 --> 11:23.640
Y luego tenemos que devolver algo.

11:23.640 --> 11:25.650
Así que vamos a volver.

11:26.700 --> 11:30.480
Y en este caso, que sea un éxito.

11:30.480 --> 11:37.710
Así que devolveremos el estado del nodo punto, punto éxito.

11:38.520 --> 11:44.940
Ahora note aquí que el retorno del éxito aquí realmente no tiene nada que ver con si su agente realmente

11:44.940 --> 11:47.010
llegó al destino o no.

11:47.010 --> 11:50.520
Porque en este momento no me preocupa mucho eso.

11:50.910 --> 11:53.190
Sólo quiero algo que se pueda ver al correr.

11:53.190 --> 11:53.460
De acuerdo.

11:53.460 --> 11:59.220
Luego en su hoja de ir al diamante, vamos a pasar a través, ir al diamante.

11:59.430 --> 12:07.110
Y ahora la furgoneta también necesita un método de paso.

12:07.110 --> 12:09.690
Bien, ahora es el momento de un reto.

12:09.690 --> 12:20.370
Lo que me gustaría que hicieras es escribir un método go to Van y configurarlo aquí con tu hoja y escribirlo de forma similar a lo que tenemos

12:20.370 --> 12:22.440
para go to Diamond.

12:22.440 --> 12:24.060
No lo hagas demasiado complicado.

12:24.060 --> 12:26.310
Arreglaremos todo esto un poco más tarde.

12:26.310 --> 12:27.960
Sólo queremos algo que funcione.

12:27.960 --> 12:29.400
Así que sigue este formato aquí.

12:29.400 --> 12:30.120
Poner en pausa el vídeo.

12:30.120 --> 12:33.810
Ahora, cuando volvamos, te mostraré cómo hacerlo.

12:35.130 --> 12:35.850
De acuerdo.

12:35.880 --> 12:36.810
¿Cómo te fue?

12:36.810 --> 12:43.470
Bueno, en realidad, lo único que tenías que hacer era coger esto, copiarlo y ponerlo aquí.

12:43.500 --> 12:47.040
Llámalo, ve a la furgoneta y baja.

12:47.040 --> 12:48.450
Y su destino fijado.

12:48.450 --> 12:50.610
Sólo quieres poner furgoneta.

12:50.940 --> 12:56.580
Y luego aquí arriba en su hoja, pondremos ir a la furgoneta.

12:58.680 --> 12:59.100
Muy bien.

12:59.100 --> 13:04.050
Así que antes de que podamos jugar, en realidad tenemos que arrancar el árbol con un proceso de la misma, ya que no es en realidad

13:04.050 --> 13:05.430
la ejecución de su proceso.

13:05.430 --> 13:11.310
Y si entramos en el código de nuestro árbol de comportamiento, verás que está preparado para ejecutar el primer hijo aquí en

13:11.310 --> 13:11.850
proceso.

13:11.850 --> 13:13.530
Pero no lo vamos a llamar.

13:13.530 --> 13:21.660
Así que de vuelta en nuestro código en realidad tenemos que ir proceso de punto de árbol como que para poner en marcha todo el asunto.

13:21.660 --> 13:25.650
Ahora echando otro vistazo a nuestro árbol, aquí está nuestro árbol.

13:25.650 --> 13:31.080
Tenemos entonces un nodo intermedio que de momento es sólo un nodo genérico.

13:31.080 --> 13:36.750
Lo modificaremos a otra cosa un poco más tarde, pero lo dejaremos en el Nodo cuatro.

13:36.750 --> 13:42.300
Ahora, si entramos en Node y echamos un vistazo al proceso de los nodos, puedes ver que

13:42.300 --> 13:50.550
va a devolver éxito, lo cual es un poco inútil para nosotros porque queremos que luego vaya y ejecute los eventos de sus hijos.

13:50.550 --> 13:56.610
Así que en su lugar sólo voy a reemplazar esto aquí con el mismo código

13:56.610 --> 14:04.410
que tengo en el árbol de comportamiento, que va a ser hijos punto actual.

14:05.290 --> 14:06.130
Proceso.

14:06.160 --> 14:11.710
Ahora, esto todavía no es perfecto, pero es suficiente para que parte de nuestro árbol funcione.

14:11.710 --> 14:12.940
Así que guarda eso.

14:12.940 --> 14:21.730
Guarde su comportamiento de la goma, y luego vamos a ir y pulse el botón de reproducción sólo para que pueda ver algo de trabajo al final

14:21.730 --> 14:22.500
aquí.

14:22.510 --> 14:23.440
Vale, genial.

14:23.440 --> 14:24.090
Ya está.

14:24.100 --> 14:25.660
Así que se va.

14:25.810 --> 14:33.400
Ha pasado de la raíz del nivel superior del árbol al acero para ir al diamante.

14:33.520 --> 14:35.650
Ahora, se va a detener allí.

14:35.650 --> 14:40.630
No va a dar la vuelta y volver a la furgoneta, porque si echas un vistazo al código, sólo

14:40.630 --> 14:45.130
estamos ejecutando el primer hijo de cualquier nodo en particular.

14:45.160 --> 14:49.840
La furgoneta es un segundo hijo del acero, por lo que no está en marcha.

14:50.320 --> 14:56.590
Y la forma en que actualmente tenemos nuestro código de malla naval para ir al destino no es realmente correcta

14:56.590 --> 15:00.850
tampoco, pero al menos tienes algo que funciona que puedes probar.

15:01.150 --> 15:04.210
Bien, esa es nuestra acción.

15:04.210 --> 15:12.730
Lo que vamos a hacer cuando volvamos en la próxima conferencia es arreglar el código de la malla de navegación y poner

15:12.730 --> 15:17.380
algún tipo de código adecuado para ir a Diamond e ir a Van.
