WEBVTT

00:11.320 --> 00:15.070
Hasta ahora hemos visto algunos árboles de comportamiento secuencial bastante simples.

00:15.070 --> 00:23.290
Ahora vamos a agregar una condición que pruebe si algo es 'verdadero' o 'falso' antes de que el Árbol

00:23.290 --> 00:24.960
de comportamiento continúe

00:25.030 --> 00:30.940
ejecutándose y, por lo tanto, agregaremos un 'Nodo de decisión' dentro del código.

00:30.940 --> 00:34.260
Vamos a hacer eso dentro de nuestro ataque,

00:34.270 --> 00:39.520
pero antes que nada, necesitamos escribir nuestro método que tomará la decisión por nosotros.

00:39.520 --> 00:46.030
Actualmente estamos atacando todo el tiempo. Realmente solo quieres que el bot ataque si realmente puede

00:46.030 --> 00:47.110
ver al jugador

00:47.110 --> 00:52.080
y en este caso, cuando comienzas, no puede porque el jugador está detrás de una pared.

00:52.150 --> 00:57.440
Además, si el jugador está fuera de un rango visible, tampoco querrás que ataque.

00:57.580 --> 01:05.920
Ahora, si recuerdas en la parte superior de este programa, hay un visibleRange y un shotRange configurado,

01:06.220 --> 01:15.550
por lo que este visibleRange (que es 80) determinará si el jugador está dentro de las 80 unidades del

01:15.550 --> 01:21.670
bot, entonces puede verlo . También probará al mismo tiempo si no hay un muro entre

01:21.670 --> 01:28.180
el jugador y el bot, lo cual es una buena situación enemiga porque quieres que el bot sea consciente de que hay infraestructura a su alrededor.

01:28.180 --> 01:36.700
Entonces, como el último método aquí debajo del Fuego, agregaré uno nuevo que usaremos en nuestro código de

01:36.730 --> 01:38.170
Árbol de comportamiento.

01:38.170 --> 01:40.350
Entonces se llama SeePlayer.

01:40.630 --> 01:41.710
Es un booleano,

01:41.710 --> 01:48.220
así que es como lo habíamos hecho antes, pero esta vez en realidad lo vamos a usar como una prueba lógica en

01:48.250 --> 01:49.480
el Árbol de comportamiento.

01:49.480 --> 01:57.280
Entonces, lo que está haciendo es calcular el vector desde el bot hasta

01:57.280 --> 01:59.370
el reproductor y

01:59.530 --> 02:03.500
luego también vamos a tener un RaycastHit.

02:03.940 --> 02:12.520
Así que emitiremos rayos a lo largo de ese vector de distancia para ver si golpeamos algo y si golpeamos algo (que en este caso es un

02:12.610 --> 02:17.800
muro), entonces obviamente no podemos ver al jugador porque hay un muro en el camino, así

02:17.800 --> 02:18.480
que Tengo

02:18.480 --> 02:22.130
un pequeño bool establecido aquí, diciendo 'seeWall = false' para empezar.

02:22.180 --> 02:28.900
También estoy haciendo una depuración. DrawRay en el entorno, para que podamos ver dónde se

02:28.900 --> 02:30.600
proyecta ese vector de distancia.

02:30.610 --> 02:35.840
Esto es realmente bueno si estás tratando de depurar visualmente lo que está sucediendo y dónde están tus vectores.

02:35.980 --> 02:38.520
Yo siempre uso esto.

02:38.740 --> 02:46.180
Ahora va a proyectar un rayo, haz la física. Raycast como lo hemos hecho antes y luego ver si

02:46.420 --> 02:48.770
hemos tocado algo llamado 'muro'.

02:48.970 --> 02:53.140
Si es así, seeWall será igual a 'verdadero'.

02:53.260 --> 02:59.490
Ahora, solo por un momento en Unity, si vas al Mapa y lo dejas caer, hay todos estos muros y cada uno ha

02:59.650 --> 03:06.160
sido etiquetado con 'muro' y así es como funciona la Física. Raycast va a funcionar.

03:06.250 --> 03:14.420
Ahora asegúrese de que su rayo que está proyectando realmente atraviese la pared (o cualquier objeto que esté tratando de

03:14.440 --> 03:17.400
detectar como un obstáculo) y es por eso

03:17.500 --> 03:20.880
que esta depuración. DrawRay es una gran idea.

03:21.880 --> 03:31.870
Después de hacer eso, también estoy imprimiendo el valor de seeWall en algún código de depuración para el árbol de comportamiento en sí mismo para que pueda verlo

03:31.870 --> 03:37.210
cuando trabaja a través de los diferentes nodos y lo que están haciendo, lo que

03:37.210 --> 03:39.070
también es bastante útil.

03:39.190 --> 03:43.750
Luego, finalmente, para determinar si podemos ver al jugador

03:43.750 --> 03:51.820
o no, la prueba es: si la magnitud de esa distancia del vector de dirección entre los dos jugadores

03:51.820 --> 04:03.050
es menor que el rango visible Y no hay muro en el camino. Esta vez, no nos preocupa si el bot está orientado en la dirección

04:03.110 --> 04:04.700
correcta o no.

04:04.700 --> 04:09.620
Así que imaginemos que tiene un pequeño sistema de radar a bordo y no necesita

04:09.620 --> 04:17.420
mirar en una dirección para saber si el jugador está cerca. Ahora, si el jugador está en ese radio y no

04:17.420 --> 04:23.590
hay un muro en el camino, entonces vamos a devolver "verdadero" que sí vemos al

04:23.930 --> 04:27.390
jugador, de lo contrario, devolveremos un "falso".

04:27.410 --> 04:31.650
Entonces este es el método para nuestro nuevo nodo.

04:31.700 --> 04:36.020
Ok, entonces guardaremos eso y luego entraremos en el script de Ataque y lo que

04:36.080 --> 04:43.070
haremos será agregar un nuevo nodo en nuestro árbol sobre la 'secuencia'. Así que aquí arriba,

04:44.310 --> 04:52.090
ahora voy a agregar esto. Entonces, el código es 'while SeePlayer' Ahora este

04:52.140 --> 05:00.750
nodo 'while' es un nodo de prueba especial y le permitirá ejecutar algo que sea un valor verdadero o falso

05:00.750 --> 05:02.260
e incluso invertirlo

05:02.490 --> 05:06.660
para verificar (no tiene que ser cierto ejecutar, también puede

05:06.720 --> 05:11.060
ser falso) y no detendrá la ejecución de su árbol.

05:11.170 --> 05:20.220
De acuerdo, incluso podría poner, por ejemplo, 'mientras no SeePlayer' si desea cambiar la lógica y lo haremos un poco más

05:20.220 --> 05:23.380
tarde, pero no en este caso aquí.

05:23.460 --> 05:27.780
Ahora este nodo 'while' solo puede tener 1 hijo.

05:27.950 --> 05:34.730
Por lo tanto, debemos asegurarnos de haber sangrado todo esto de esa manera, de lo contrario, el sistema Behavior Tree

05:34.730 --> 05:36.430
se quejará al respecto.

05:36.440 --> 05:44.890
Entonces, la secuencia de disparos solo sucederá si el método SeePlayer nos da una 'verdadera' aquí.

05:44.890 --> 05:47.810
Así que guardemos eso y probémoslo.

05:47.810 --> 05:55.220
Entonces, de vuelta en Unity, haga clic en el Droid para verificar que el guión esté bien y obtendrá un texto rosado donde todo

05:55.220 --> 05:57.660
está bien con el guión de ataque.

05:57.680 --> 06:00.680
Ok, presionemos Play y echemos un vistazo a lo que obtenemos.

06:00.710 --> 06:10.940
Entonces, en el árbol de comportamiento, mientras SeePlayer está sentado allí, wall = True, puedes ver eso allí.

06:10.940 --> 06:17.780
También puedes ver en la escena que el rayo de depuración atraviesa y golpea la pared, lo que está causando

06:17.780 --> 06:23.750
el 'muro = Verdadero' aquí y nos está haciendo para que no podamos ver al jugador.

06:23.750 --> 06:25.510
Muevamos el reproductor a

06:26.660 --> 06:37.870
la vista, así que si doy la vuelta a la esquina y listo. Tan pronto como veo y estoy dentro del alcance visual, el Droid comienza

06:37.990 --> 06:41.510
a disparar y si me doy la

06:41.530 --> 06:47.950
vuelta y regreso nuevamente, se detendrá tan pronto como haya un muro en el camino.

06:50.790 --> 06:57.840
Si atravieso este muro porque no estoy limitado como jugador por

06:58.230 --> 07:05.670
NavMesh, ya no puede verme. Si regreso, lo hará y, debido al código anterior, también se volverá hacia

07:05.670 --> 07:08.950
el jugador, para disparar y se puede ver que el

07:09.110 --> 07:15.980
Árbol de Comportamiento funciona bastante bien con ese poco de lógica. Entonces estás comenzando a ver el poder de los

07:15.980 --> 07:22.910
árboles de comportamiento, que puedes crear un montón de métodos que hacen una sola acción para tu jugador

07:22.940 --> 07:30.560
y luego puedes unirlos en el árbol de comportamiento, lo que hace que sea mucho más fácil para alguien quien

07:30.560 --> 07:33.700
no está realmente familiarizado con el código pero

07:33.710 --> 07:41.330
también hace su A. YO. bastante potente donde puedes mezclar y combinar diferentes comportamientos. Solo por intereses, volvamos

07:41.330 --> 07:50.330
a Atacar y cambiemos ese código en la parte superior con la declaración while para que sea un 'no' y revertamos esa lógica,

07:50.330 --> 07:56.150
de modo que cuando NO veamos al jugador, vamos a atacar al jugador, lo

07:56.150 --> 08:04.060
que no tiene sentido lógico, pero lo que eso significa es que, si bien no estás a la vista del

08:04.070 --> 08:07.320
robot con tu personaje, disparará en tu dirección.

08:07.430 --> 08:09.110
Así que solo guarda eso. Mientras estoy

08:09.110 --> 08:13.130
aquí, también debería mencionar esta declaración while debido a la programación

08:13.520 --> 08:20.450
habitual, pensarás que mientras que la declaración significa 'bucle'. En el caso de Behavior Trees, no significa bucle.

08:20.450 --> 08:22.190
Entonces esto NO es un bucle.

08:22.230 --> 08:24.700
En todo caso, es una declaración if, si

08:24.710 --> 08:28.860
quieres pensar en ella como algo, por lo que no hará que esto se

08:29.210 --> 08:37.030
repita dentro de aquí y simplemente se llame 'while'. Bien, así que guarda eso. Volvamos y echemos un vistazo a cómo eso afecta nuestro Árbol de Comportamiento.

08:37.040 --> 08:43.610
Entonces, presionemos Reproducir y esperaríamos que nos disparen de inmediato porque no podemos ver al

08:43.610 --> 08:44.300
jugador.

08:44.480 --> 08:50.030
Ahora, si me muevo hacia el rango, entonces no nos dispararán y, de hecho, toda la

08:50.300 --> 08:55.300
secuencia deja de ejecutarse, por lo que ni siquiera vamos a girar y mirar

08:55.640 --> 09:02.290
al jugador porque este bit aquí no se está cumpliendo, en la medida en que poder ver al jugador.

09:02.490 --> 09:02.700
Correcto.

09:02.700 --> 09:07.800
Así es como también puedes agregar algo de lógica.

09:07.800 --> 09:16.440
Ahora no tiene que usar el 'while not' en este caso porque SeePlayer podría ser parte de la secuencia.

09:16.830 --> 09:27.360
Si coloca SeePlayer en la secuencia (volvamos a aquí y saquemos eso de allí y

09:27.360 --> 09:28.480
póngalo

09:30.320 --> 09:35.070
aquí), entonces está legítimamente permitido fallar ...

09:38.340 --> 09:45.330
y como se trata de una secuencia, el resto no se ejecutará de todos modos, así que guardemos y echemos

09:45.330 --> 09:46.090
un vistazo.

09:47.030 --> 09:48.990
Comprueba que está recargado aquí.

09:49.190 --> 09:56.460
Ahora tenemos una secuencia. Si presionamos Reproducir ... ok, no podemos ver al jugador.

09:56.460 --> 10:03.120
Entonces, la secuencia se ha detenido con el SeePlayer e intentemos acercarnos para ver qué sucede ...

10:03.840 --> 10:06.870
disparará el SeePlayer y luego

10:07.110 --> 10:10.220
el resto se ejecutará como antes.

10:10.350 --> 10:17.010
Entonces, en este caso, la instrucción while no nos está ayudando con el SeePlayer porque tiene que ser cierto

10:17.040 --> 10:19.920
para que se ejecute el resto del código.

10:19.920 --> 10:26.670
Entonces, en este caso, lo que hemos hecho es girar el árbol sobre su cabeza en la medida en que

10:26.700 --> 10:34.200
este SeePlayer ahora es un Nodo Hoja, mientras que antes era un Nodo Decorador porque tenía niños debajo y le permitía tomar

10:34.200 --> 10:40.680
una decisión y la decisión en ese caso toma su decisión cuando se desea invertir el valor que

10:40.680 --> 10:41.760
sale de ella.

10:41.760 --> 10:48.980
Por lo tanto, "mientras no" va a ser mucho más común en este caso en particular, pero depende de lo que

10:48.990 --> 10:49.800
intente hacer.

10:49.950 --> 10:51.710
Entonces esa es

10:51.720 --> 10:58.900
la secuencia y también agregar esa lógica. En el siguiente video, veremos los Nodos Selectores.
