WEBVTT

00:11.040 --> 00:14.090
En esta conferencia, veremos el concepto de 'Huida'.

00:14.380 --> 00:19.410
Es una técnica común utilizada en A. YO. por conseguir que un NPC se aleje de una ubicación.

00:19.450 --> 00:24.580
La técnica se puede usar en cualquier tipo de NPC. En este caso, lo aplicaremos a nuestra multitud

00:24.580 --> 00:31.300
en la que hemos estado trabajando. Matemáticamente, huir funciona así ... Un objeto o ubicación se introduce

00:31.300 --> 00:32.570
en un entorno.

00:32.940 --> 00:38.740
El NPC determina dónde está el objeto en relación con su propia posición. Luego calculan una nueva ubicación de objetivo

00:38.740 --> 00:41.560
que está lejos del objeto.

00:41.650 --> 00:45.410
En este caso, utilizaremos la dirección exactamente opuesta.

00:45.430 --> 00:51.280
Esto se puede calcular usando el vector hacia el objeto y quitándolo de la posición de los NPC.

00:52.150 --> 00:53.800
Con la nueva ubicación del objetivo,

00:53.800 --> 00:59.020
el agente puede darse la vuelta y comenzar a dirigirse hacia él, y así ser alejado del objeto en cuestión. Otros factores que podemos

00:59.250 --> 01:05.020
considerar son el "radio de influencia del objeto" y el "período de enfriamiento". El radio determina qué tan cerca debe

01:05.020 --> 01:10.990
estar un PNJ de un objeto para verse afectado por él y el tiempo de reutilización es

01:10.990 --> 01:18.820
cuánto tiempo huye el PNJ, antes de volver al comportamiento normal. Para implementar la huida en la multitud actual de tu

01:18.820 --> 01:25.180
ciudad y llegar al punto en el que estoy ahora, deberás agregar un cilindro y hacer una prefabricación.

01:25.180 --> 01:34.280
Entonces, lo que he hecho es ir a la Jerarquía y hacer clic con el botón derecho> Objeto 3D> Cilindro 'y no cambié

01:34.280 --> 01:41.760
el tamaño del mismo, pero lo que hice fue hacer un material verde y conectarlo a ese cilindro.

01:41.780 --> 01:49.730
Luego tomé ese cilindro de la Jerarquía y lo arrastré y lo solté en los Activos y eso creará una

01:50.210 --> 01:55.980
prefabricación de ese cilindro para usted. Solo eliminaré mi segunda versión.

01:56.060 --> 02:02.670
Ahora este cilindro no hace más que marcar la ubicación donde vamos a hacer clic.

02:02.750 --> 02:10.490
Por lo tanto, necesitamos un código para colocar el cilindro en NavMesh, donde hacemos clic con el mouse.

02:10.610 --> 02:20.330
Así que creemos un nuevo código C # y llamemos a eso 'DropCylinder', luego abrámoslo y

02:20.390 --> 02:22.270
agregaremos este código.

02:22.340 --> 02:27.420
Entonces, antes que nada, tenemos un objeto de juego expuesto al público que llamamos 'obstáculo'.

02:27.440 --> 02:31.350
Aquí es donde pasaremos por nuestra prefabricada del cilindro.

02:31.430 --> 02:38.650
Luego vamos a mantener una serie de todos los agentes que están en la escena y,

02:38.900 --> 02:46.870
por lo tanto, en el Inicio, recopilaremos todos esos agentes al encontrar los objetos del juego que tienen

02:46.870 --> 02:48.500
la etiqueta 'agente'.

02:48.580 --> 02:56.090
Esto significa que tendrá que crear la etiqueta 'agente' y agregarla a sus personajes.

02:56.110 --> 03:05.590
Entonces tengo mis personajes. Los puse en 'Multitud' y los dupliqué. Creé algunos de ellos. No tenga demasiados porque

03:05.800 --> 03:10.900
cuanto más tenga, más lento se ejecutará, pero desea

03:11.170 --> 03:12.570
lo suficiente.

03:12.580 --> 03:18.550
Ahora, bajo esta 'Multitud', si solo hace clic en todos ellos, puede agregar una etiqueta de 'agente'.

03:18.550 --> 03:25.840
Así que creé una nueva etiqueta llamada 'agente', con una 'a' minúscula y solo la configuré para todos los personajes que están

03:25.840 --> 03:27.100
en la multitud.

03:27.280 --> 03:33.040
Entonces, volvamos al código y esos agentes estarán sentados en esta matriz de 'agentes' y eso significa

03:33.070 --> 03:38.740
que cuando soltamos el objeto, podemos enviar un mensaje a todos ellos diciendo que ese objeto

03:38.830 --> 03:40.720
está allí. Es como

03:40.720 --> 03:48.850
el Agent Manager que hemos tenido en conferencias anteriores. Ahora en la actualización es donde se probará el botón

03:48.850 --> 03:57.250
del mouse para ver si está presionado y luego haremos un RaycastHit en el mundo desde la posición de la pantalla

03:57.250 --> 04:01.090
usando la posición del mouse en la cámara principal.

04:01.090 --> 04:05.700
Eso significa asegurarse de que su cámara esté etiquetada

04:05.700 --> 04:07.250
como 'MainCamera'.

04:07.430 --> 04:09.420
Así que recuerda dónde está eso ... vaya a

04:09.440 --> 04:14.660
la cámara y la etiqueta debe ser 'MainCamera' aquí para que lo tome.

04:14.660 --> 04:21.110
Ahora, estamos haciendo nuestro Raycast de física al mundo, descubriendo dónde impacta ... donde golpea, vamos a instanciar una

04:21.110 --> 04:24.200
copia de nuestro cilindro.

04:24.200 --> 04:30.300
Así que ese es el obstáculo, lo colocaremos en la ubicación del golpe y luego utilizaremos la

04:30.320 --> 04:34.090
rotación predeterminada del prefabricado porque realmente no es tan importante.

04:34.430 --> 04:40.040
Luego tenemos una declaración 'foreach' que solo recorrerá todos los agentes en la

04:40.460 --> 04:47.840
escena y llamará a un método sobre ellos (que aún no hemos escrito), pero se llamará 'DetectNewObstacle'

04:47.840 --> 04:53.990
y nosotros ' Le pasaré el hitInfo. punto, que es la ubicación de donde estamos colocando el cilindro.

04:53.990 --> 05:00.830
Entonces, esto básicamente le dice a nuestro agente que hay un obstáculo que se está colocando y ahora es

05:00.830 --> 05:07.520
su trabajo huir de él. Así que guarda eso ... le dará un pequeño error porque aún no hemos

05:07.580 --> 05:08.570
escrito este DetectNewObstacle,

05:08.590 --> 05:10.410
pero eso es lo que haremos a continuación.

05:10.550 --> 05:17.930
Abra el script de AIControl y este es el script que debería haber adjuntado a cada agente en

05:18.020 --> 05:19.280
la escena,

05:19.280 --> 05:24.020
por lo que siempre es una buena idea crear uno y

05:24.020 --> 05:30.740
luego duplicarlo para que no tenga que agregarlo. Mi código de AIControl es un poco diferente de lo que dejé

05:30.740 --> 05:34.490
en la última conferencia, así que lo revisaré rápidamente y le mostraré los cambios.

05:34.490 --> 05:41.660
En primer lugar, he creado este 'speedMult' en la parte superior aquí. Estaba incrustado en el código más abajo, como una variable local,

05:41.660 --> 05:42.340
pero ahora

05:42.380 --> 05:45.740
lo vamos a usar en un par de lugares diferentes.

05:45.770 --> 05:51.140
Entonces, el objetivo ahora es tener 2 tipos diferentes de animaciones y 2 tipos diferentes de velocidad. Caminamos y también correremos,

05:51.140 --> 05:51.960
de

05:52.160 --> 05:57.830
modo que cuando se caiga el obstáculo y el personaje

05:57.830 --> 06:00.530
huya, entonces queremos que huyan.

06:00.620 --> 06:02.270
Así que pon eso en la parte superior. Luego,

06:02.300 --> 06:12.140
he creado una función llamada 'ResetAgent' porque iba a restablecer la velocidad del agente aquí y allá, dependiendo de si estás huyendo o

06:12.140 --> 06:16.850
si estás deambulando y, por lo tanto, es bueno tener todo

06:16.850 --> 06:22.080
de esto en un solo lugar para que sea fácil cambiar y actualizar.

06:22.100 --> 06:30.640
Ahora aquí puede ver en ResetAgent, cuando suceda, establecerá el multiplicador de velocidad en un valor aleatorio.

06:30.800 --> 06:36.160
Antes, estaba haciendo esto y la función de Inicio para que el agente siempre tuviera la misma velocidad.

06:36.170 --> 06:39.170
Ahora va a cambiar la velocidad

06:39.380 --> 06:42.430
del agente cada vez que se reinicie.

06:42.440 --> 06:48.560
Esa es una buena manera de hacer que sus personajes sean un poco más aleatorios en sus movimientos

06:48.560 --> 06:53.290
para que no siempre estén a la misma velocidad para el mismo personaje.

06:53.420 --> 06:57.700
Ahora, ahora tenemos la velocidad del agente establecida aquí.

06:57.800 --> 07:05.220
Recuerde que es 2 por defecto en los caracteres, multiplicado por el valor de speedMult.

07:05.270 --> 07:09.470
Entonces eso solo se asegura de que esté configurado en 2

07:09.710 --> 07:12.780
y también estoy configurando la velocidad angular.

07:12.890 --> 07:18.620
Si echas un vistazo a la velocidad angular predeterminada en el NavMesh Agent en uno

07:18.620 --> 07:21.320
de tus personajes, verás que es 120.

07:21.320 --> 07:25.880
La velocidad angular es qué tan rápido se dará la vuelta el personaje.

07:25.880 --> 07:31.050
Ahora lo que quiero es aumentar eso cuando el personaje tiene que huir.

07:31.100 --> 07:36.020
Entonces, quieres que vean algo de lo que tienes que huir y que giren muy rápido, así

07:36.020 --> 07:41.480
que eso significa que debes aumentar la velocidad angular y eso también significa que cuando vuelvan a caminar, debes

07:41.480 --> 07:43.010
volver a bajarlo .

07:43.010 --> 07:47.600
Así que lo vuelvo a poner aquí a 120. En ResetAgent, cuando se

07:47.630 --> 07:56.540
restablece, establecerá el valor de speedMult que está en el sistema de animación en speedMult y volverá a

07:56.540 --> 07:57.440
configurar

07:57.440 --> 08:06.890
la animación de caminata y luego haré un ResetPath aquí que borra la ruta actual que tiene el agente

08:07.010 --> 08:13.910
calcula y básicamente lo vuelve a establecer en 0 para que pueda estar

08:14.270 --> 08:18.670
listo para generar otra ruta en el sistema NavMesh.

08:18.680 --> 08:24.800
Ahora, la función de Inicio ... lo que hace es más o menos lo que teníamos antes.

08:24.800 --> 08:28.420
Entonces, toma todas las ubicaciones de objetivos en el

08:28.550 --> 08:33.920
mundo, los agentes NavMesh, establece el destino en un valor aleatorio (este código

08:34.140 --> 08:39.410
es exactamente el mismo código que antes, lo haré más grande para

08:39.410 --> 08:47.150
que pueda verlo), ubicación aleatoria fuera de la matriz goalLocations, agarra el animador que está en el personaje y

08:47.150 --> 08:55.210
luego también establece el desplazamiento de la caminata (para que no todos caminen en el tiempo entre sí) a un

08:55.470 --> 09:02.630
valor entre aquí y luego ejecutamos el ResetAgent (que continuará y establecerá todos estos valores que están

09:02.780 --> 09:04.580
aquí para nosotros).

09:04.730 --> 09:12.900
Ahora en la Actualización, es lo mismo que teníamos antes, excepto que estamos haciendo un Agente de reinicio antes

09:12.900 --> 09:15.490
de establecer el próximo destino.

09:15.540 --> 09:22.110
Lo que eso significará es que si estamos corriendo hacia una ubicación porque estamos huyendo de

09:22.110 --> 09:27.480
ella, entonces, una vez que la hayamos alcanzado, volveremos a caminar y tomaremos

09:27.480 --> 09:34.350
otra ubicación de objetivo y seguiremos deambulando. alrededor. Las nuevas cosas que agregaremos para este código para facilitar la huida ...

09:34.410 --> 09:44.510
En primer lugar, necesitamos un flotador, que será el 'detecciónRadio' y esa es la distancia desde 'donde se deja caer

09:44.510 --> 09:52.100
el objeto' hasta 'qué tan lejos deben estar los agentes cercanos para poder escucharlo'.

09:52.100 --> 09:58.280
Ahora si tiene eso bastante grande, entonces todos los agentes en el área responderán. Si es más pequeño, solo responderán los que

09:58.370 --> 10:03.770
se encuentren en el 'dentro de 5', lo cual es bueno porque puedes tener una

10:03.770 --> 10:09.170
pequeña distracción fugaz o puedes tener algo que es bastante grande como una distracción fugaz.

10:09.170 --> 10:13.380
Luego, también necesitamos un flotador para el 'fleeRadius' y esto

10:13.430 --> 10:20.480
es qué tan lejos quieres que los personajes huyan del objeto antes de que lo olviden y comiencen

10:20.480 --> 10:24.290
a regresar y buscar una nueva ubicación de objetivo.

10:24.320 --> 10:27.810
Así que configuremos eso en 10, en este caso.

10:28.040 --> 10:34.630
Bien, ahora con eso, lo que vamos a hacer es crear ese método del que

10:34.760 --> 10:42.530
hablé antes (DetectNewObstacle) que se llama desde la caída de los objetos en el otro script de clic.

10:42.530 --> 10:45.630
Entonces el nuevo método se verá así.

10:45.650 --> 10:51.830
Por lo tanto, será público porque se está llamando desde otro lugar y estamos pasando por

10:51.920 --> 10:55.900
la posición del obstáculo que está cayendo en la escena.

10:55.980 --> 11:03.470
Luego haremos una prueba de distancia de la 'posición del objeto' y la 'posición del agente'.

11:03.470 --> 11:09.480
Ahora, si esto está dentro del radio de detección, entonces el agente reaccionará a él.

11:09.560 --> 11:15.490
Si el agente va a huir, necesita determinar en qué dirección

11:15.490 --> 11:24.290
va a huir, que está lejos de la posición del obstáculo y para determinar eso, es la

11:24.290 --> 11:33.620
posición del agente menos la posición del obstáculo. Observe que luego lo estoy normalizando para que tenga un

11:33.620 --> 11:41.360
vector de longitud de 1 y lo usaré como 1 para multiplicarlo por el fleeRadius, que puede ver aquí.

11:41.480 --> 11:51.830
Entonces, es el fleeDirection para una longitud de fleeRadius, agregado a la posición actual del agente y

11:51.830 --> 11:56.140
ahí será donde está el nuevo objetivo.

11:56.190 --> 12:01.860
Ahora con esa nueva información de objetivos, podemos establecer el destino del

12:01.960 --> 12:07.290
agente, pero de antemano, veremos si podemos llegar a esa ubicación.

12:07.290 --> 12:14.180
Entonces podrías tener un agente. setDestination newgoal pero en este caso, es

12:14.400 --> 12:23.520
posible que pueda calcular una ubicación que esté fuera de NavMesh del agente por completo o que no

12:23.580 --> 12:32.070
sea del todo accesible y eso significa que aún desea que el agente intente llegar a

12:32.070 --> 12:34.530
ella, si es posible.

12:34.530 --> 12:39.220
Así que esta es una forma diferente de elaborar el camino.

12:39.270 --> 12:48.780
Lo que hacemos es crear un objeto de ruta NavMesh y este objeto de ruta se puede calcular con

12:48.780 --> 12:49.770
CalculatePath.

12:49.770 --> 12:57.270
Entonces creamos este valor para la ruta y lo pasamos para calcular la ruta, dada la nueva posición del objetivo.

12:57.270 --> 13:02.780
Ahora este camino mantendrá el camino que el agente va a seguir para llegar

13:02.850 --> 13:09.060
a la meta, pero si solo puede hacer parte del camino o no puede hacerlo, puede probar

13:09.060 --> 13:11.170
el camino. estado.

13:11.370 --> 13:20.700
En este caso, si el camino. el estado no es igual a una ruta no

13:21.180 --> 13:33.270
válida, entonces establecerá el destino al final de la ruta que se calcula. Entonces, la 'ruta' en sí misma termina con una matriz llamada 'esquinas' y esa es una matriz

13:33.390 --> 13:40.000
de todos los puntos de referencia, esencialmente, que el personaje va a seguir a medida que avanza desde donde

13:40.000 --> 13:42.180
está hasta su ubicación objetivo.

13:42.180 --> 13:49.560
Ahora, si no puede llegar hasta la ubicación del objetivo, todavía tendrá esta matriz de esquinas, pero solo le

13:49.560 --> 13:55.890
llevará una parte del camino, lo que significa que si obtiene el último valor en

13:55.890 --> 14:02.640
la matriz de esquinas (que es esto uno aquí), entonces habrá llegado al final de la ruta

14:02.640 --> 14:11.940
que se calculó, incluso si no ha llegado al objetivo exacto. Por lo tanto, hará que el agente se mueva al menos un poco lejos de donde

14:11.940 --> 14:13.140
ha colocado el obstáculo.

14:13.410 --> 14:22.140
En ese punto, configuramos la animación para que se ejecute y luego aceleramos el agente con el agente. velocidad y subimos la velocidad angular bastante alta porque

14:22.140 --> 14:27.210
queremos que el agente gire muy rápido y luego se vaya

14:27.210 --> 14:30.360
en la dirección completamente opuesta.

14:30.780 --> 14:39.710
Muy bien, así que guárdelo y luego volveremos a la Unidad. Lo que tendrá que hacer para probar esto (puede ver que

14:39.720 --> 14:43.370
he eliminado todos los edificios, duplicado mis agentes)

14:43.470 --> 14:49.770
Tengo cuatro objetivos y los acabo de colocar en un cuadrado alrededor del área, por lo

14:49.770 --> 14:55.510
que los agentes cuando presiono Reproducir simplemente voy a deambular aleatoriamente entre esos objetivos.

14:56.820 --> 15:04.380
Ahora para configurar el clic para el cilindro, tenemos nuestro script DropCylinder aquí. Solo voy a agregarlo a la cámara

15:04.560 --> 15:08.040
(arrastrarlo y soltarlo en la cámara).

15:08.040 --> 15:15.990
Solo necesita estar en la escena para que se ejecute y luego ese script DropCylinder requiere nuestro cilindro prefabricado

15:15.990 --> 15:17.750
que creamos antes.

15:17.750 --> 15:27.860
Así que toma eso y déjalo allí. Ahora, cuando presionamos Reproducir, si dejamos caer un cilindro, verá que

15:28.290 --> 15:35.720
los agentes huyen de él y luego regresan porque solo huyen lo más lejos que necesitan

15:35.720 --> 15:40.890
para encontrar su ubicación objetivo y luego simplemente comenzarán a vagar.

15:40.890 --> 15:47.310
de vuelta y buscando otros objetivos. Por lo tanto, todavía se mueven al azar alrededor

15:47.310 --> 15:52.650
de esos 4 objetivos diferentes que se encuentran en estas 4 esquinas donde tienden a agruparse.

15:52.710 --> 16:00.240
Bien, así que si quieres cambiar esto para que todos reaccionen, si volvemos a nuestro AIControl, vamos a la parte

16:00.240 --> 16:05.880
superior aquí y si cambiamos esta detecciónRadius a 20, eso probablemente debería cubrir a

16:05.910 --> 16:09.210
todos en esa escena. Guárdalo

16:09.390 --> 16:17.170
Regrese y presione Reproducir. Cuando dejemos esto aquí, todos huirán.

16:17.240 --> 16:23.990
Ahora todavía no están huyendo muy lejos porque solo tienes ese radio de 10 (o lo que sea que tengamos

16:23.990 --> 16:28.830
allí) y puedes cambiar eso si quieres empujarlos directamente a los bordes de NavMesh.

16:28.910 --> 16:39.200
Ahora es probable que, cuando esté haciendo esto, haya un agente extraño que aparentemente ignorará el obstáculo y

16:39.380 --> 16:49.040
eso será porque en su script AIControl aquí abajo, donde está calculando el camino, puede ser posible

16:49.040 --> 16:59.060
si tiene un muy, muy grande fleeRadius para tratar de calcular un nuevo objetivo que está tan

16:59.060 --> 17:07.400
lejos del NavMesh actual que solo devolverá un camino no válido y realmente no

17:07.640 --> 17:11.210
puede hacer nada al respecto.

17:11.240 --> 17:14.060
Entonces tienes que vivir con eso.

17:14.060 --> 17:21.680
La otra alternativa es que tendrías que programar manualmente como una parte 'más' para esto aquí, el agente

17:21.770 --> 17:28.070
gira y sale en la dirección opuesta, lo que significa que luego pierdes el

17:28.070 --> 17:34.150
control del agente y el agente ya no estará navegando. a través de NavMesh

17:34.190 --> 17:36.710
y eso podría causarle problemas.

17:36.860 --> 17:40.390
Entonces, depende de usted si desea hacer eso o no,

17:40.460 --> 17:44.350
o simplemente está feliz de soportar el hecho de que eso no funciona.

17:44.390 --> 17:52.910
De lo contrario, realmente debe asegurarse de que su fleeRadius estará dentro de NavMesh o al menos no

17:52.910 --> 17:59.220
ridículamente lejos de NavMesh para que no calcule una ruta válida para usted.

18:00.340 --> 18:05.060
Así es como hacer que tus NPC huyan de un espacio.

18:05.070 --> 18:12.520
Esto está utilizando el método NavMesh, pero el cálculo del vector para huir y la nueva ubicación del objetivo es exactamente

18:12.940 --> 18:18.050
la misma si desea implementar esto en su propio sistema de waypoint manual.

18:18.070 --> 18:25.460
Simplemente crearía un nuevo waypoint sobre la marcha y le daría esa nueva posición de objetivo, con ese vector matemático que se

18:25.540 --> 18:28.000
encuentra en este programa en particular.
