En la conferencia anterior, hemos reunido nuestras acciones y hemos hecho que nuestro personaje se mueva ahora para
ejecutar un plan.
Por lo tanto, tenemos que añadir en los nodos de la secuencia.
Hasta ahora tenemos un nodo de ir a la puerta y otro de ir a la furgoneta, pero en realidad no se desarrollan en secuencia.
Y eso es lo que quieres como plan y quieres que tu agente los ejecute uno por uno.
Ahora bien, si en algún momento de la secuencia una de esas acciones falla, entonces no tiene sentido continuar con
la secuencia.
Por lo tanto, hay que tenerlo en cuenta a la hora de programar el nodo de la secuencia.
Así que básicamente lo que viene a ser es que un nodo de secuencia es como una lógica, y si todos sus hijos tienen éxito, entonces
el nodo de secuencia realmente devuelve éxito a su padre.
Si alguno de los hijos falla uno o más de ellos, entonces el propio nodo de la secuencia falla e informa de un
fallo hacia arriba en el árbol a su padre.
Muy bien, entonces vamos a crear un nodo de secuencia en nuestro código de árbol de comportamiento.
Vamos a crear otro archivo de C-sharp.
Este se va a llamar secuencia y abrirlo en su editor.
Sí.
Una vez más, esto va a ser un nodo, no un comportamiento de los mineros.
Y podemos deshacernos de su contenido.
Ahora, lo primero que haremos es crear un constructor público.
Así que la secuencia y tendremos que pasar por el nombre para ello.
Y ahora escribiremos su proceso.
Así que va a ser un nodo de anulación pública punto proceso de estado y en realidad no necesitan ese nodo en allí, pero eso no importa
realmente.
De acuerdo.
Así que esto va a devolver el punto de estado en ejecución como un defecto.
Ahora, antes de eso, básicamente va a hacer un bucle a través de todos sus hijos y ejecutar su método de proceso.
Pero no puedes tener un bucle aquí.
Recuerda que es como una actualización en unity, así que tienes que ponerlo en marcha y luego ver si sigue funcionando
la próxima vez que este proceso se ejecute de nuevo.
De acuerdo.
Así que, en primer lugar, lo que vamos a hacer es coger el estado de ejecución del primer hijo.
Así que el estado.
La condición de niño equivale a los niños.
El hijo actual.
Ahora, si recuerdas cuando creamos nuestro nodo por primera vez, hicimos ese hijo actual entero.
Y eso es sólo para saber qué niño está corriendo actualmente.
Así que inicialmente se pone a cero.
Así que volvemos a nuestro nodo y echamos un vistazo.
Está aquí arriba.
Así que la primera vez que se ejecuta que en allí, va a recoger ese primer hijo que está
en esa matriz de los procesadores o los procesadores de los niños.
De acuerdo.
Ahora bien, si el estado de este hijo es igual al punto de estado en ejecución, eso significa que ese hijo sigue en ejecución, en cuyo caso
sólo vamos a devolver el punto de estado en ejecución K, no vamos a ir a ejecutar nada más.
No vamos a establecer el proceso para hacer otro hijo porque actualmente estamos
en medio de algo.
De acuerdo.
Así que esto podría ser, por ejemplo, ir a Diamante.
Es posible que el agente todavía esté haciendo su camino hacia allí, lo que significa que ese nodo en particular
no ha devuelto un valor todavía, no ha tenido éxito o ha fallado.
Sigue funcionando solo.
De acuerdo.
Ahora, si no se está ejecutando, si el estado del hijo es igual al estado dot failure, entonces vamos a devolver el estado del hijo, básicamente diciendo
que, de acuerdo, este nodo de la secuencia ha informado de un fracaso.
Hemos terminado.
No vamos a hacer más niños porque no podemos continuar.
Uno de los estados de nuestros hijos o las acciones de nuestros hijos ha fallado.
Vale, si no puedes ir al diamante, entonces no tiene sentido seguir intentando robar el diamante,
etc.
Bien, entonces una vez que hemos pasado eso, si no hemos fallado, eso significa que ahora debemos tener éxito con ese niño en particular
porque no está corriendo y no ha fallado.
Así que el niño actual más queremos ir la próxima vez que entramos aquí al siguiente niño y realmente procesarlo.
Así que vamos a decir si el hijo actual es mayor o igual que la cuenta de puntos de los hijos.
Por lo tanto, si hemos llegado al final de nuestra lista, entonces el niño actual lo siente es igual a cero.
Vamos a reajustar eso para la próxima vez.
Podríamos ejecutar esta secuencia y vamos a devolver el punto de estado de éxito para que básicamente hemos bucle a través de todos
los niños y ninguno de ellos han informado de un fallo, lo que significa que tenemos éxito.
Hemos llegado al final de la secuencia.
Así que digamos, vale, lo hemos hecho, hemos terminado.
Genial.
Ese es su nodo de secuencia.
Simple, simple, simple.
Pero es sólo conseguir su cabeza alrededor de cómo esto está funcionando realmente.
Y es que es un bucle, pero no es un bucle en un solo bucle for aquí.
Muy bien.
Así que ahora vamos a poner esto en marcha, guardar eso y vamos a volver a nuestro comportamiento ladrón porque aquí es donde tenemos
que configurar todo esto.
Así que tenemos nuestro ir al diamante y nuestro ir a la furgoneta, lo que significa que nuestros agentes van a ir al diamante y luego
volver a la furgoneta, o eso es al menos lo que queremos.
Ahora, sé que en la ilustración al principio de esta conferencia, yo tenía ir a la puerta en allí también y añadirá
que un poco más tarde.
Por ahora, queremos que esto sea sencillo.
Ahora ya estamos añadiendo esas dos cosas a nuestro nodo steal, pero aún así ahora se va a convertir en una secuencia.
Así que lo cambiaremos de nuestro nodo básico a una secuencia y lo cambiaremos aquí a una secuencia.
Ahora se le añaden estos, y eso está bien.
Se van añadiendo en el orden en que quieres que se procesen.
Ahora, cuando iniciamos, ejecutamos el proceso treetop que ejecuta el árbol una vez que no sigue ejecutando el árbol, pero
necesitamos seguir ejecutando el árbol de la misma manera que unity sigue ejecutando su actualización, que
está aquí abajo y vacía en este momento.
Así que en lugar de ejecutar nuestro árbol aquí en START, en realidad queremos ejecutarlo en update.
Y para ejecutarlo en la actualización, necesitamos saber lo que devuelve cada vez.
Así que voy a ir hasta la parte superior aquí y en realidad poner en una otra variable por lo que será ningún estado
de punto, que en realidad será el estado del árbol es igual al nodo estado de punto que se ejecuta como un defecto allí.
Y entonces lo que vamos a hacer es sacar este proceso de árbol de inicio.
Así que dejemos eso de lado.
Llévalo a nuestra actualización justo aquí y luego solo prueba.
Si el estado verdadero es igual a ningún punto en ejecución, entonces vamos a procesar el árbol.
Ahora, cuando lo hagamos, también tenemos que asegurarnos de actualizar cuál es el estado del árbol para que éste deje de ejecutarse
de nuevo.
De lo contrario, se hará un bucle y se continuará ejecutando la acción concreta que se esté intentando realizar.
Así que vamos a poner el estado del árbol es igual al proceso de comercio.
Bien, guardaremos eso y ahora estamos listos para probarlo.
Así que vamos a volver a la unidad y vamos a pulsar el play y debemos ver esos comportamientos tienen
lugar donde vamos a ir al diamante.
Así que la malla de navegación está ahora en control en cuanto a la elaboración de la ruta, vamos al diamante y luego hemos llegado
al diamante.
Así que eso ha devuelto el éxito allí.
Y ahora podemos volver a la furgoneta.
Y como ese árbol tiene éxito, nos detendremos ahí y no continuará.
Si sacas ese estado del árbol es igual a tu proceso de actualización, en realidad verás que esto rebotará
y hará un bucle a través de ese comportamiento.
Muy bien.
Así que tenemos que correr ahora si usted necesita para depurar esto en absoluto, porque es un poco ir por la fe, supongo,
con la forma en que hemos codificado para usted como usted va a través de este, lo que podría
hacer es en sus procesos, poner algunos registros de depuración para ver qué proceso se está ejecutando realmente.
Porque recuerda que nos tomamos la molestia de enviar un nombre a cada nodo.
¿De acuerdo?
Así que aquí se puede poner como un registro de depuración de procesamiento de los niños, el nombre actual de punto de niño aquí.
Así que eso te permitiría hacer un seguimiento.
Y también se puede imprimir el estado en que se encuentra.
Así que en todos sus procesos, dondequiera que estén en la hoja, hacer algunos registros de depuración y entonces
usted puede ver lo que está pasando, ver que está procesando y donde sus problemas pueden ser.
Muy bien.
Ahora es el momento de un reto.
Si recuerdas al principio, teníamos un pequeño árbol de comportamiento que
tenía una puerta entre empezar aquí, ir a una puerta, ir al diamante y luego volver a la furgoneta.
Lo que me gustaría que hicieras es montar esta pequeña secuencia en la que ahora, en primer lugar, vamos a la puerta,
vamos al diamante, y luego vamos a la furgoneta.
Ahora, cuando digo que vayas a la puerta, en realidad quiero que vayas a esta puerta de aquí.
Así que quiero que su agente vaya a esa puerta, vaya al diamante, y luego vaya a la furgoneta.
O, de hecho, incluso se podría decir que vaya a la puerta, vaya al diamante, vaya a la puerta y vaya a la furgoneta.
Así que mira si puedes poner eso.
Ponga el vídeo en pausa ahora.
Adelante, hazlo.
Cuando volvamos, te mostraré cómo hacerlo.
Bienvenido de nuevo.
¿Cómo le fue con ese desafío?
Ahora bien, es posible que hayas encontrado un pequeño contratiempo con esto mientras lo hacías, y ya hablaré de ello
cuando me pase a mí.
En primer lugar, esta puerta de aquí, si la encontramos en la escena, se llama puerta trasera.
Así que eso es todo.
Y ese es el que queremos.
Así que dentro de nuestro código de comportamiento del ladrón, tenemos que hacer espacio para pasar eso.
Así que vamos a volver a la parte superior aquí y vamos a poner el objeto de juego público de vuelta como eso, y luego tenemos que crear
una hoja para esa cosa en particular.
Así que queremos una hoja aquí.
Vamos a tomar eso y voy a copiarlo y ponerlo aquí.
Así que ve a la puerta y llamémosla puerta trasera.
Sólo para ser específicos aquí, ir a Backdoor y luego vamos a poner ir a backdoor aquí y ir a backdoor como nuestro
método que luego tenemos que crear.
Así que vamos a bajar aquí y tenemos que ir a Diamond.
Así que vamos a hacer una copia de eso, ir a la puerta trasera y luego nuestro ir a la ubicación será.
Puerta trasera doc transformada en posición.
El resto estará bien.
Volvamos aquí arriba y añadamos la puerta trasera en nuestra secuencia.
Así que en realidad queremos que sea el primero, ¿no?
Así que vamos a subir aquí y poner punto de acero ir a añadir niño, ir a Backdoor, ir a Diamond y luego queremos volver a la puerta trasera
para salir y luego ir a la furgoneta.
Así que guardemos eso, volvamos a la unidad y pulsemos el play y veamos lo que obtenemos.
Por supuesto, después de ir al código de la goma y pasar a través de ese objeto de puerta trasera a nuestro script.
Así que ahí está, pulsa el play y ahora veamos cómo se desarrolla.
Así que inmediatamente lo primero que habrás notado es que parece que va a la puerta
principal, pero no es así.
Está tomando un atajo hacia la puerta trasera a través de la puerta principal.
Ahora bien, esto se debe a la malla naval.
Es encontrar un camino más corto a través de ese hueco en la puerta principal.
Así, pero al menos fue allí.
Supongo que ahora se ha ido por la puerta de atrás, ahora va a volver al diamante.
Y una vez que lo haga, volverá a la puerta de atrás.
Y entonces voy a suponer aquí que va a hacer un atajo a través de esa puerta principal.
Oh, ahora ha calculado de forma diferente y vuelve a la furgoneta.
Obviamente.
Seguro que fue así.
Tan genial.
Ahora, la cuestión es que ha ido a la puerta de atrás porque aparentemente la puerta principal está cerrada y no puede
pasar por ahí, pero en este caso sí.
Ahora bien, eso es, como he dicho, una cuestión de malla naval, y lo resolveremos en los próximos vídeos.
De acuerdo.
Así que eso son secuencias.
Cuando volvamos en la próxima conferencia, vamos a ver los selectores.