WEBVTT

00:09.780 --> 00:12.180
En esta conferencia, examinaremos 'Flocado'.

00:12.270 --> 00:15.060
El flocado tiene que ser uno de mis favoritos A. YO. técnicas

00:15.070 --> 00:21.220
Implica reglas simples que generan comportamientos complejos que son fascinantes. El agrupamiento se puede utilizar para generar de manera

00:21.220 --> 00:26.680
procesal el movimiento de grupos de individuos a los que les gusta permanecer juntos, mientras avanzan

00:26.680 --> 00:28.190
hacia un objetivo común.

00:28.210 --> 00:33.850
Me viene a la mente el vuelo de las aves, pero esta técnica se puede utilizar prácticamente en cualquier lugar

00:33.850 --> 00:38.660
donde tenga un grupo que necesite comportamientos de movimiento complejos que no desee programar a mano.

00:38.710 --> 00:46.930
En este taller, crearemos peces de flocado (o escolarización). Para seguir, descargue el paquete de 'AIfish' Unity

00:46.930 --> 00:49.500
que viene con esta conferencia.

00:49.510 --> 00:54.570
Abra un nuevo proyecto de Unity para 3D y traiga ese paquete.

00:54.640 --> 01:03.740
Cuando lo agregue a los Activos, encontrará que hay un pez verde, un pez rosa y una escena llamada Natación. Si abre la escena de Natación en sí, obtendrá

01:03.750 --> 01:06.250
el pez verde solo

01:06.250 --> 01:11.880
con la cámara configurada apuntando hacia él y si presiona Reproducir,

01:12.070 --> 01:17.730
encontrará que ese pez verde tiene una animación de natación adjunta.

01:21.610 --> 01:25.950
Ahora, para crear una bandada, necesita más de 1 pez en este

01:25.960 --> 01:29.290
caso porque la bandada es una actividad grupal.

01:29.380 --> 01:32.240
Así que vamos a crear un administrador

01:32.500 --> 01:38.660
de flocado y en la jerarquía, simplemente haga clic derecho allí y agregue un vacío y llámelo FlockManager.

01:38.680 --> 01:45.070
Esto no es diferente a los otros Gerentes que hemos tenido antes para otros agentes, donde queríamos

01:45.100 --> 01:51.160
crear múltiples versiones de ellos para que podamos enviar mensajes y realizar un seguimiento de ellos.

01:51.190 --> 01:56.920
En este caso, los peces necesitan conocerse unos a otros, por lo que FlockManager creará un

01:56.920 --> 02:05.530
montón de peces y luego podrá informar a todas las personas sobre los otros peces en la parvada (o en la escuela, supongo, pero yo

02:05.530 --> 02:06.940
Lo llamo rebaño).

02:07.060 --> 02:14.060
Bien, entonces tenemos nuestro FlockManager, que es un 'vacío'. Cree un script C # y llámelo FlockManager

02:16.310 --> 02:20.090
y luego ese script se adjuntará a nuestro FlockManager.

02:20.950 --> 02:27.390
Ahora vamos a abrir ese script y agregar este código. El código es bastante simple.

02:27.400 --> 02:35.950
Crea una variedad de peces, crea instancias de todos esos objetos de peces y los coloca en una

02:36.010 --> 02:40.810
ubicación aleatoria alrededor de la ubicación de su FlockManager.

02:40.810 --> 02:41.020
Correcto.

02:41.020 --> 02:48.510
Entonces, antes que nada, necesitará una variable pública, FishPrefab expuesta y pasamos nuestra prefabricada de peces aquí (que puede ser su pez

02:48.520 --> 02:55.140
verde o el pez rosado o cualquier otra cosa). También puede hacer esto con cubos, no hará ninguna

02:55.150 --> 02:56.610
diferencia y luego

02:56.740 --> 03:03.220
un número público que hemos establecido en 20 (pero esto le permitirá cambiar la cantidad de peces que

03:03.220 --> 03:07.270
tiene en una parvada en particular, a través de el inspector).

03:07.600 --> 03:12.240
Luego crearemos nuestra gama de allFish y, a medida

03:12.370 --> 03:17.690
que los instanciamos, entrarán en este allFish y luego tendremos un

03:17.710 --> 03:19.480
Vector3 llamado swimLimits.

03:19.480 --> 03:27.210
Este es el rango de ubicaciones dentro de las cuales se puede generar el pez.

03:27.220 --> 03:35.020
Así que esto es como una caja que está alrededor de su administrador de bandadas y es 5x5x5, lo que lo

03:35.020 --> 03:38.340
hace 10x10x10 porque este es un valor de

03:38.650 --> 03:44.790
radio y luego usaremos swimLimits para generar la ubicación de nuestros peces dentro de esa caja.

03:44.800 --> 03:48.060
Entonces todo esto está sucediendo en Inicio.

03:48.160 --> 03:55.130
En primer lugar, creamos todos los peces y hacemos la matriz lo suficientemente grande como para contenerlos.

03:55.180 --> 04:01.540
Luego está el ciclo 'for', que gira alrededor de ese número de veces y cada vez

04:01.540 --> 04:11.650
crea una posición para colocar el pez y esta posición se basa en la posición del administrador de la parvada más un valor aleatorio de

04:11.680 --> 04:18.160
Vector3 que está alrededor de esos límites de natación (así entre 'minus swimLimits' y 'swimLimits positivos')

04:18.160 --> 04:21.260
que le proporcionarán el rango de posiciones.

04:21.280 --> 04:26.980
Ahora, si desea que sea una caja de posiciones más grande, entonces simplemente aumentaría estos valores aquí

04:26.980 --> 04:30.810
o podría hacerlos más pequeños si desea un grupo muy unido.

04:30.910 --> 04:37.660
Luego, una vez que tenemos esta posición que hemos calculado, colocamos el pescado (lo instanciamos desde

04:38.140 --> 04:43.930
nuestro prefabricado) en la posición que acabamos de calcular, usando una rotación neutral.

04:43.930 --> 04:47.180
También puede establecer esto en la rotación

04:47.290 --> 04:51.790
prefabricada de peces si los tiene apuntando en una dirección particular,

04:52.090 --> 04:55.520
realmente no importa y eso llenará esta matriz.

04:55.600 --> 05:04.090
Entonces, si guarda eso, vuelva a Unity, seleccione su FlockManager y desea configurar el prefabricado de peces.

05:04.390 --> 05:09.100
El pez prefabricado no es este pez verde que está en la escena.

05:09.130 --> 05:09.450
Okay.

05:09.460 --> 05:12.530
Ese es el que se usó para hacer el prefabricado inicial.

05:12.550 --> 05:20.200
De hecho, simplemente elimínelo, para que no se confunda con él y luego tome su prefabricado de

05:20.200 --> 05:26.440
peces (que está en sus Activos) y arrástrelo y suéltelo en el FlockManager.

05:26.680 --> 05:31.270
Vamos a crear 20 peces y llenará esta matriz aquí.

05:31.270 --> 05:35.910
Así que presiona Play y encontrarás tus 20 peces (y si me

05:36.200 --> 05:41.850
alejo, los verás) dentro de los límites de los límites de natación que hemos creado.

05:41.850 --> 05:51.700
Ahora, si quieres más pescado que eso, digamos que querías 50 peces ... 50 aquí y presiona Play y obtendrás 50 peces.

05:51.700 --> 05:57.690
Puedes verlos, todos han aparecido en la Jerarquía y todos están en el Inspector debajo de la matriz

05:57.730 --> 05:58.210
allFish

05:58.240 --> 06:03.670
y así cada pez puede encontrar a todos los demás peces que están en su rebaño.

06:06.220 --> 06:13.130
Ok, es hora de que el pez se mueva. Para comenzar, vamos a configurar algunos valores de velocidad para

06:13.130 --> 06:19.070
el pez y lo haremos en el FlockManager. Por lo tanto, haremos del FlockManager un lugar donde

06:19.070 --> 06:23.930
podamos establecer todas las diferentes variables para los peces particulares que pertenecen a esa bandada y

06:23.930 --> 06:28.010
luego puede tener múltiples bandadas para diferentes tipos de peces en su escena.

06:28.010 --> 06:33.860
Así que volví a usar el script FlockManager. Lo que vas a hacer es agregar algunos valores públicos

06:34.220 --> 06:35.790
como los que tengo aquí.

06:35.840 --> 06:42.590
En primer lugar, en el Inspector, acabo de agregar una pequeña línea de 'Encabezado', que la separa y hace que sea

06:42.590 --> 06:44.950
fácil de encontrar cuando intentas configurarlos.

06:44.960 --> 06:51.280
Entonces tengo un 'Rango' aquí, entre 0. 0f y 5. 0f que le dará

06:51.380 --> 07:01.580
un control deslizante en el Inspector y luego public minSpeed y public maxSpeed, con los mismos valores para el rango.

07:01.960 --> 07:08.790
Una vez que haya agregado esas 5 líneas, simplemente guárdelo, vuelva a Unity y haga clic en Flock Manager

07:08.840 --> 07:16.100
y encontrará en el Inspector que ahora tenemos esas configuraciones. Tenemos 'Configuración de pescado', Velocidad mínima y máxima (que luego

07:16.190 --> 07:22.100
puede cambiar con los controles deslizantes a su gusto y también podrá hacerlo en tiempo real

07:22.100 --> 07:29.150
y pasar esos valores de velocidad al pescado) . Para los peces, ahora crearemos un

07:29.150 --> 07:33.380
nuevo archivo C # y lo llamaremos 'Flock'.

07:33.440 --> 07:39.800
Este es el código que pasa al prefabricado de peces, así que arrastre y suelte eso en su pez verde y mientras estemos

07:40.020 --> 07:43.150
aquí, lo arrastraremos y soltaremos también en el pez rosa.

07:43.220 --> 07:50.000
Simplemente seleccione el pez verde en los Activos y verifique en el Inspector para asegurarse de que el script

07:50.000 --> 07:51.230
esté realmente adjunto.

07:51.230 --> 07:58.670
Ahora ábralo y lo primero que necesitaremos es un enlace a nuestro

07:59.120 --> 08:08.710
administrador, por lo que crearemos un 'FlockManager myManager público' y luego necesitaremos un flotador para la velocidad.

08:08.740 --> 08:17.530
Ahora en el Inicio, vamos a establecer la velocidad para que sea igual a Aleatorio. Rango entre la configuración de velocidad mínima del administrador y la configuración de

08:17.620 --> 08:20.710
velocidad máxima del administrador. En la actualización, pondremos

08:20.740 --> 08:28.130
una declaración de traducción para impulsar al pez hacia adelante a lo largo de su eje hacia adelante o su eje Z.

08:28.150 --> 08:32.340
Observe que el valor de 'velocidad' va al eje Z.

08:32.340 --> 08:35.710
Si su pez se enfrenta en una dirección diferente ...

08:35.710 --> 08:46.680
así que si solo regreso a mi pez y agarro un pez, entonces el eje azul aquí está mirando hacia adelante y ese es

08:46.680 --> 08:48.950
el que lo empujará.

08:49.080 --> 08:54.060
Si su pez tiene un eje diferente, entonces tendrá que ajustar su código para empujarlo a lo largo

08:54.060 --> 08:55.180
de ese eje.

08:55.210 --> 09:03.430
Ok, entonces borraremos ese pez y volveremos al código y lo guardaremos, luego en su script

09:03.430 --> 09:12.900
FlockManager, si lo abrimos, después de haber creado un pez dentro de ese ciclo for, desea configurar es

09:13.220 --> 09:17.690
FlockManager (o myManager) para este FlockManager en particular.

09:17.700 --> 09:26.060
Agregue este código y ahora ambos archivos (Flock y FlockManager) se vincularán entre sí.

09:26.290 --> 09:31.790
De vuelta en el Editor, presione Reproducir y verá los resultados del código.

09:31.790 --> 09:34.350
Entonces tienes tus peces que ahora están avanzando.

09:34.370 --> 09:37.090
Tienen velocidades aleatorias sobre ellos.

09:37.640 --> 09:40.910
Por supuesto, van a salir de escena muy rápidamente.

09:40.910 --> 09:47.310
Puede ver que se mueven a diferentes velocidades (si puede acercarse). Sí.

09:47.460 --> 09:50.500
Entonces todos tienen diferentes velocidades, pero

09:50.550 --> 09:59.350
todos se mueven a lo largo de su eje Z. Ok, ahora es el momento de agregar nuestras 'reglas de flocado'.

09:59.490 --> 10:01.970
Mencioné las reglas de agrupación al comienzo de esta

10:01.980 --> 10:04.210
sección, pero repasemos de nuevo en detalle.

10:04.290 --> 10:10.860
Ellos son: moverse hacia la posición promedio del grupo; Alinee con el encabezado promedio del grupo y evite

10:10.860 --> 10:13.200
aglomerar a otros miembros del grupo.

10:15.150 --> 10:20.010
Avanzar hacia la posición promedio del grupo implica tomar todas las posiciones de los miembros

10:20.100 --> 10:23.190
individuales, sumarlas y dividirlas por el número del grupo.

10:23.190 --> 10:29.190
Luego podemos averiguar dónde está un individuo, en relación con la ubicación promedio y hacer que

10:29.190 --> 10:32.310
se vuelvan hacia él. Para alinearnos con el encabezado

10:32.310 --> 10:37.220
promedio del grupo, sumamos todos los encabezados de los individuos y los dividimos por el tamaño del grupo.

10:37.230 --> 10:44.230
Esto proporciona un vector promedio para que las personas intenten alinear su movimiento. Para evitar vecinos, un individuo debe ser consciente

10:44.260 --> 10:46.780
de dónde están los

10:46.820 --> 10:49.360
vecinos y luego apartarse de ellos.

10:50.440 --> 10:55.780
Luego, para calcular un nuevo rumbo, un individuo agregará el vector para moverse hacia el centro de

10:55.780 --> 11:01.530
un grupo, el vector para alinearse con el rumbo de los grupos y el vector para alejarse de un vecino.

11:04.720 --> 11:10.810
Antes de comenzar a editar el código de Flock, solo agregaremos algunos valores más al FlockManager (los que

11:10.810 --> 11:16.180
puede cambiar en tiempo de ejecución, para que pueda ver diferentes comportamientos en el pez)

11:16.690 --> 11:22.090
y estas configuraciones para los comportamientos serán disponible para todos los peces en esa bandada

11:22.120 --> 11:23.170
en particular.

11:23.200 --> 11:32.350
Así que estoy agregando aquí otro rango para algo llamado vecinoDistance y otro rango para la velocidad

11:32.350 --> 11:33.550
de rotación.

11:33.550 --> 11:40.660
Entonces, una vez que los peces comiencen a obtener lugares hacia los que necesitan moverse, tendrán que dar la vuelta

11:40.660 --> 11:46.720
en algún momento y usaremos un slerp para eso y eso necesita una velocidad de rotación, así

11:46.720 --> 11:48.250
que agregué que ahí.

11:48.260 --> 11:57.580
Ahora, la otra cosa con este vecinoDistance es que puedes tener una bandada de algo y todo en esa bandada podría

11:57.580 --> 12:00.740
considerarse tu vecino o solo querrás

12:01.560 --> 12:09.600
considerar a los pocos más cercanos (dentro de un metro de ti) como tu vecino real, así que

12:09.660 --> 12:16.890
por lo tanto, puede modificar eso y obtiene diferentes comportamientos de todo el grupo cuando

12:17.310 --> 12:24.320
solo consideran a los que están a su alrededor como vecinos en lugar de todos.

12:24.360 --> 12:28.490
Ahora para los cambios en el rebaño. Ve a tu rebaño. código cs.

12:28.650 --> 12:36.710
Vamos a crear un nuevo método llamado 'ApplyRules' y ese método se llamará aquí para que

12:36.750 --> 12:42.270
no haya otros cambios en la parte superior, solo dentro de

12:42.270 --> 12:45.510
la Actualización y luego agreguemos ApplyRules.

12:45.510 --> 12:52.830
Ahora, este ApplyRules está haciendo esas 3 reglas de las que acabamos de hablar, con los diferentes cálculos vectoriales.

12:52.830 --> 13:02.200
En primer lugar, está creando un soporte, para apoderarse de todos los peces en la bandada actual.

13:02.220 --> 13:08.060
Entonces estos son los peces que queremos probar y encontrar la posición promedio, el rumbo promedio, etc. y son los peces que serán

13:08.070 --> 13:13.620
considerados tus vecinos (o al menos son el conjunto completo y los vecinos serán

13:13.620 --> 13:17.240
parte de ese conjunto, como verás en un minuto).

13:17.260 --> 13:23.850
Ahora estamos calculando el centro promedio de los grupos, así que vamos a almacenar eso en 'vcentre'. Entonces también estamos

13:24.090 --> 13:28.350
calculando el vector de evitación promedio.

13:28.350 --> 13:32.090
Por lo tanto, no solo queremos evitar a un vecino,

13:32.190 --> 13:33.840
sino a TODOS, y

13:33.840 --> 13:35.870
eso también es un promedio.

13:35.880 --> 13:40.080
Por lo tanto, debe calcular todos los vectores de evitación y luego promediarlos.

13:40.080 --> 13:42.030
Entonces, inicialmente están configurados en 0.

13:42.330 --> 13:44.510
Luego tenemos este flotador

13:44.520 --> 13:51.960
llamado 'gSpeed' y esta es una velocidad global del grupo (una velocidad promedio en la que se

13:51.960 --> 13:56.490
mueve el grupo) y también la usaremos en nuestros cálculos.

13:56.520 --> 14:00.690
Luego tenemos un flotador 'nDistance', que es nuestra distancia vecina.

14:00.750 --> 14:06.870
Así que vamos a tener que preguntar a cada pez qué tan lejos están y

14:06.870 --> 14:10.480
luego calcular si consideramos que están lo suficientemente

14:10.570 --> 14:21.100
cerca como para estar en nuestro grupo y así tenemos este contador 'groupSize' aquí, que contará cuántos de los los peces en el rebaño están en

14:21.100 --> 14:29.890
nuestro grupo, por lo que el grupo es como esta pequeña sección del rebaño que está dentro de ese valor de distancia

14:30.060 --> 14:30.760
vecino.

14:31.750 --> 14:38.560
Ahora, con estos valores inicializados a 0, esencialmente, vamos a recorrer todos los peces

14:39.010 --> 14:40.850
en la parvada.

14:40.930 --> 14:42.600
Entonces usamos un bucle foreach.

14:42.610 --> 14:47.390
Luego vamos a preguntar si el pez actual (que va a ser este objeto

14:47.410 --> 14:48.870
del juego aquí: ir) siempre

14:49.000 --> 14:56.080
que no sea igual al pez que ejecuta este código en este momento, entonces haremos el proceso porque no necesita encontrar

14:56.080 --> 15:00.280
el promedio de usted mismo, no tiene que calcular la distancia a

15:00.280 --> 15:01.000
sí

15:01.000 --> 15:06.640
mismo, por lo que esto solo asegura que no calculemos los datos del pez por sí mismo.

15:06.640 --> 15:12.760
Luego calculamos la distancia del vecino, así que recuerda que estamos girando alrededor de este ciclo for,

15:13.420 --> 15:21.640
seleccionando cada pez y luego calculamos la distancia con un Vector3. Distancia entre el objeto del juego en nuestra

15:21.640 --> 15:29.800
posición de matrices y nuestra posición en el mundo y luego preguntamos si esa distancia es 'menor o

15:29.800 --> 15:36.820
igual que' la distancia vecina, lo que lo convierte en un pez de interés (uno que

15:36.820 --> 15:45.990
vamos a considere parte de nuestro grupo muy unido) y luego agregaremos la posición de ese pez en particular al 'vcentre'.

15:46.060 --> 15:49.820
vcentre será nuestra posición promedio de nuestro grupo, por lo

15:50.110 --> 15:54.680
tanto, tenemos que dar vueltas y agregar todas las posiciones juntas y luego

15:55.030 --> 15:57.370
dividirlas por el tamaño del grupo.

15:57.430 --> 16:02.050
Entonces, al mismo tiempo que lo agregamos, también aumentamos el tamaño del grupo en 1.

16:02.080 --> 16:06.990
Entonces, después de que este ciclo haya pasado, podemos calcular el promedio.

16:07.120 --> 16:14.680
A continuación, tenemos una instrucción if para probar que nuestro vecinoDistance sea menor que un valor mucho menor, que he

16:14.680 --> 16:17.870
codificado aquí como 1. 0 y, de

16:17.980 --> 16:25.270
hecho, podríamos poner esto en el FlockManager como otro valor de distancia, pero así es lo

16:25.630 --> 16:32.090
cerca que podemos estar de otro pez antes de considerar la posibilidad de evitarlo.

16:32.110 --> 16:40.840
Ahora si, en este caso, la distancia es menor que 1. 0f, entonces se agregará el vector promedio de

16:40.870 --> 16:48.250
evitar y, por lo tanto, tiene su propio valor + el vector alejado de ese pez.

16:48.250 --> 16:53.620
Entonces, el vector alejado de algo (y vimos esto en una simulación de multitudes que

16:53.920 --> 16:58.730
queríamos alejar) era nuestra posición actual menos la posición de la que queremos alejarnos

16:58.960 --> 17:03.150
y eso se suma a medida que avanzamos por aquí también.

17:03.160 --> 17:09.860
Ahora la velocidad global está sumando todas las velocidades de un pez particular de la parvada.

17:09.910 --> 17:16.450
Así que seguimos adelante y agarramos el código Flock que está adjunto al pez que

17:16.450 --> 17:23.620
estamos viendo en este momento y luego tomamos su velocidad y lo agregamos a este valor de gSpeed.

17:23.650 --> 17:29.500
Ahora, cuando el código termina este bucle foreach, hemos pasado por todos

17:29.500 --> 17:38.770
los peces de la parvada y lo hemos examinado. Si se considera que es un vecino cercano, entonces estamos encontrando su posición

17:38.890 --> 17:42.570
y también su vector de evitación y sumando todo eso.

17:42.620 --> 17:47.170
Ah y por supuesto la velocidad. Ahora debajo del bucle

17:47.260 --> 17:55.360
foreach, tenemos una declaración if. La declaración if pregunta si el tamaño del grupo es> 0. Si el pez se mueve y

17:55.750 --> 18:01.920
no hay nadie alrededor y el tamaño del grupo se convierte en 0, no

18:02.260 --> 18:06.250
se aplicarán estas reglas. Simplemente seguirá moviéndose en línea recta.

18:06.280 --> 18:14.230
Entonces, si este pez está influenciado por otro pez (u otro grupo de peces), entonces encontramos el promedio al

18:14.230 --> 18:14.700
centro.

18:14.710 --> 18:20.130
Entonces ese es el vector 'vcentre' que calculamos cuando los sumamos todos

18:20.290 --> 18:28.540
juntos, ahora dividimos por el tamaño del grupo. La velocidad misma del pez se establece en la velocidad global, dividida

18:28.540 --> 18:30.700
por el tamaño del grupo.

18:30.850 --> 18:37.750
Con esa información, podemos determinar en qué dirección debe viajar el pez (o

18:37.750 --> 18:40.840
en qué dirección quiere viajar).

18:40.900 --> 18:51.200
Entonces, su 'dirección' es igual a 'vcentre array' + 'vavoid array', nuestra posición actual.

18:51.200 --> 18:56.730
Ahora, si eso significa que la dirección es 0, ya estamos mirando

18:56.770 --> 18:58.700
en la dirección correcta.

18:58.810 --> 19:02.480
Si no es igual a cero, entonces tenemos

19:02.500 --> 19:09.310
que rotar y entonces hacemos una transformación. rotación y usamos nuestro Slerp que hemos usado antes para otros NPC

19:09.310 --> 19:14.040
y hacemos una pequeña rotación de acuerdo con nuestra velocidad de rotación y lo que esto hará

19:14.170 --> 19:19.860
es girar lentamente el pez hacia la dirección que necesita. No va a girar en la

19:19.870 --> 19:21.830
dirección perfecta y

19:22.000 --> 19:27.970
es este slerp (y slerping un poco a poco) y constantemente actualiza tu

19:27.970 --> 19:36.120
posición y comprueba dónde estás con respecto a todos los otros peces, lo que hace que este flocado

19:36.190 --> 19:43.150
ocurrir, como estás a punto de ver. El tiempo en este video está a punto de agotarse, así que

19:43.150 --> 19:49.030
rápidamente presionaremos Reproducir (asegúrese de que en su FlockManager proporcione una Distancia vecina y una Velocidad de rotación, de lo

19:49.030 --> 19:51.500
contrario no obtendrá ninguna rotación en absoluto

19:51.640 --> 19:54.560
y luego comenzarás a ver que se produce la congregación.

19:54.580 --> 19:57.440
Investigaremos esto más en el próximo video.
