WEBVTT

00:07.240 --> 00:14.800
En la conferencia anterior, te dejé con el reto de crear un spawn para engendrar pacientes.

00:14.920 --> 00:20.150
Muy bien, lo que vamos a hacer ahora es escribir eso, y te mostraré mi método.

00:20.170 --> 00:26.110
El tuyo puede ser un poco diferente, pero mientras consiga instanciar a los pacientes y ponerlos en tu

00:26.110 --> 00:28.000
mapa, entonces estamos bien.

00:28.120 --> 00:33.840
Bien, en primer lugar, necesitamos que nuestro paciente sea un prefabricado.

00:33.850 --> 00:40.750
Ahora, si recuerdas, comenzó como un prefabricado, por lo que hemos hecho algunos cambios en nuestro paciente básico.

00:40.760 --> 00:46.270
Así que usted quiere ir y hacer clic en su paciente y luego vamos a arrastrar eso y voy a subir

00:46.270 --> 00:52.210
en el inspector y queremos anular todas estas cosas que hemos hecho a nuestro paciente.

00:52.210 --> 00:58.570
Así que haga clic en aplicar todo para aplicar los de nuevo a la prefabricación.

00:59.020 --> 01:04.630
Bien, ahora vamos a crear una llave en nuestra jerarquía.

01:04.630 --> 01:07.480
Permítanme desplazar todas estas cosas hacia arriba.

01:08.020 --> 01:13.400
Vamos a hacer clic con el botón derecho y crear un vacío de llave.

01:14.080 --> 01:14.310
¿De acuerdo?

01:14.440 --> 01:17.440
Y esa va a ser la posición en la que estará nuestra llave.

01:17.440 --> 01:21.210
Ahora, se encuentra allí, así que vamos a arrastrarlo hacia aquí.

01:21.220 --> 01:27.370
Ahora, si quieres ver dónde está, además de estos ejes, puedes usar el truco que he hecho antes con la zona

01:27.370 --> 01:34.480
de espera y la recepción, que es añadir un renderizador de malla cúbica o un colisionador de caja o algo así para que puedas

01:34.480 --> 01:36.220
verlo realmente.

01:36.250 --> 01:41.710
Ahora tiene que estar fuera del hospital y tiene que estar cerca del suelo.

01:41.710 --> 01:43.030
Ahora el suelo está a cero.

01:43.030 --> 01:46.690
Así que en el inspector voy a echar un vistazo a mi Y para eso.

01:46.690 --> 01:49.540
En realidad voy a ponerlo en, digamos, siete.

01:49.540 --> 01:53.920
No importa si está un poco en el aire, porque van a desovar allí y luego

01:53.920 --> 01:56.650
sólo bajar al suelo y luego se mueven en.

01:56.830 --> 01:57.310
Muy bien.

01:57.310 --> 01:59.380
Así que dejémoslo ahí ahora.

01:59.380 --> 02:01.960
Vamos a crear el código para eso.

02:01.960 --> 02:06.100
Así que crea un script en C-sharp y llámalo Spawn.

02:06.670 --> 02:10.210
Y vamos a abrirlo y editarlo.

02:10.840 --> 02:14.950
Va a requerir, en primer lugar, nuestro objeto de juego.

02:14.950 --> 02:16.030
Así que nuestro prefabricado.

02:16.030 --> 02:21.820
Así que será el objeto de juego público paciente prefabricado.

02:24.860 --> 02:27.740
Y luego cuántos pacientes queremos.

02:27.740 --> 02:31.370
Así que pongamos eso aquí public int num.

02:32.630 --> 02:33.740
Pacientes.

02:35.130 --> 02:42.060
Y luego abajo en el inicio vamos a crear un bucle for para int i igual a cero.

02:42.090 --> 02:47.040
I es menos que el número de pacientes.

02:48.160 --> 02:48.460
Muy bien.

02:48.520 --> 02:48.790
Además.

02:48.790 --> 02:49.570
Además.

02:50.080 --> 02:55.120
Y luego dentro de este bucle, vamos a instanciar a nuestros pacientes.

02:55.310 --> 03:02.470
Bien, entonces queremos instanciar, y vamos a usar nuestro prefabricado de paciente.

03:03.040 --> 03:11.830
Y vamos a ver, queremos ponerlo en esta posición de transformación de la parada, que es su engendro de la posición

03:11.830 --> 03:21.430
y la vuelta en la identidad para, básicamente, una rotación por defecto y deletreamos transformar correctamente.

03:21.430 --> 03:28.300
El problema con esto que estoy pensando ahora es que si hacemos un bucle con todo esto al principio,

03:28.300 --> 03:32.770
vamos a terminar con qué, ¿100 pacientes directamente?

03:32.800 --> 03:34.520
Ahora, eso podría ser lo que quieres.

03:34.540 --> 03:38.170
Prefiero que esto los genere en intervalos particulares.

03:38.170 --> 03:42.160
Así que en lugar de eso voy a bajar aquí y poner vacío.

03:42.880 --> 03:45.370
Vayamos a engendrar paciencia.

03:47.090 --> 03:51.890
Y dentro de aquí moveré este código de instanciación.

03:51.890 --> 03:55.800
Así que control x, pon eso ahí abajo.

03:55.820 --> 04:01.010
Esto hace que nuestros pacientes de NUM y nuestro bucle sean superfluos.

04:01.010 --> 04:06.350
Pero ahora has visto cómo lo harías si quisieras crear un montón de pacientes de una sola

04:06.350 --> 04:06.920
vez.

04:07.010 --> 04:09.440
Y dejémoslo ahí, en realidad.

04:09.440 --> 04:10.910
Y lo haremos de todos modos.

04:11.300 --> 04:12.920
Así que lo haremos entonces.

04:14.540 --> 04:16.730
Vuelve a poner esta instanciación ahí arriba.

04:17.870 --> 04:20.000
Así que todo esto es su lote inicial de paciencia.

04:20.000 --> 04:22.190
Y luego lo que vamos a hacer es invocar.

04:24.200 --> 04:25.640
Paciente de spawn.

04:32.680 --> 04:41.020
Después de, digamos, 5 segundos y dentro de spawn patient, conseguiremos que se invoque a sí mismo.

04:45.180 --> 04:49.530
Así que siguen apareciendo pacientes.

04:50.220 --> 04:56.640
Y ahora aquí vamos a tener un rango aleatorio para el tiempo entre pacientes.

04:56.640 --> 05:03.840
Así que digamos que queremos pacientes cada 2 a 10 segundos que va a hacer.

05:03.840 --> 05:07.590
Así que ahora puedes ver dos formas en las que podrías desovar, ¿verdad?

05:07.590 --> 05:16.650
Así que vamos a guardar esto y vamos a volver a la unidad y queremos obtener nuestra secuencia de comandos spawn y arrastrarlo

05:16.650 --> 05:19.350
a nuestro spawn aquí.

05:19.440 --> 05:26.190
Y luego vamos a asignar nuestro prefab paciente, que está de vuelta en nuestra carpeta prefabs.

05:26.190 --> 05:31.980
Así que si vamos a nuestra carpeta Prefabs, tenemos nuestro paciente allí, podemos arrastrar y soltar en

05:31.980 --> 05:35.130
el prefabricado de paciente y el número de pacientes.

05:35.130 --> 05:41.950
Este es el número inicial que se crea y luego se genera uno cada 5 segundos o lo que se haya establecido.

05:42.000 --> 05:48.750
Así que vamos a crear una cantidad inicial de cinco y luego van a caer del cielo, básicamente, y empezar

05:48.750 --> 05:50.550
a llegar al hospital.

05:50.550 --> 05:56.250
Ahora, este pequeño tipo aquí que ya está en el hospital, puedes borrarlo o simplemente apagarlo si quieres

05:56.250 --> 05:58.980
usarlo para probar cosas un poco más tarde.

05:59.220 --> 05:59.700
De acuerdo.

05:59.700 --> 06:04.290
Así que pulsemos el play y veamos lo que tenemos aquí.

06:04.290 --> 06:10.320
Así que están nuestros cinco que son inicialmente engendrados y todos vienen al hospital y entonces

06:10.320 --> 06:11.700
aquí vienen los extra.

06:11.700 --> 06:17.610
Así que si vamos a nuestra vista del juego aquí, permítanme establecer esto a una imagen de alta resolución para usted.

06:17.790 --> 06:23.100
Ahora van a venir a registrarse y una vez que se hayan registrado, se irán.

06:24.390 --> 06:28.710
Después de que pasen por delante de los demás y luego entren aquí.

06:29.070 --> 06:29.520
Sí.

06:29.520 --> 06:34.290
Así que algunos pedacitos de información de depuración en este punto.

06:34.290 --> 06:43.250
Si ves que no llegan a su destino, que se saltan los pasos o lo que sea, como, ya sabes, va a pasar

06:43.410 --> 06:46.710
mientras intentas probar esto.

06:46.860 --> 06:55.620
Lo más común en este escenario particular, o el uso de la malla de navegación es que los agentes no pueden

06:55.620 --> 06:57.700
llegar a su destino.

06:57.720 --> 07:02.380
Por ejemplo, aquí abajo, tenemos una gran pila en esta sala de espera.

07:02.400 --> 07:10.190
Ahora, recuerda que la sala de espera tiene una ubicación específica, que es un pequeño punto.

07:10.200 --> 07:16.020
Si selecciono eso y vamos hasta aquí, está justo ahí.

07:16.020 --> 07:23.550
Eso significa que los agentes tienen que llegar a ese punto específico para ser considerados en la sala de espera.

07:23.550 --> 07:27.870
Y si echamos un vistazo al código de esto, hagamos una pausa.

07:28.020 --> 07:38.910
Vamos a volver al código de alcance de los agentes y a echar un vistazo a nuestro código de agente G para considerar que realmente han

07:38.910 --> 07:41.040
llegado a un destino.

07:41.040 --> 07:46.230
Si echamos un vistazo a la última actualización, tenemos esta línea aquí para la distancia restante.

07:46.230 --> 07:51.900
Así que va a considerar que has llegado a un waypoint de destino en la malla de navegación.

07:51.900 --> 07:55.190
Si estás a una distancia.

07:55.200 --> 08:00.570
Ahora bien, si se utilizan agentes de tamaño unitario como yo, me parece que uno es bastante aceptable.

08:00.630 --> 08:06.270
Puede que quieras hacer esto un poco más grande si ves que tus agentes no llegan

08:06.270 --> 08:07.440
a ese lugar.

08:07.830 --> 08:14.520
Ahora, la otra cosa que podría suceder es que si usted establece esto a 20, entonces el agente considerará que ha llegado a un

08:14.520 --> 08:20.370
waypoint cuando está como a 20 unidades de distancia, lo que hará que las acciones se vean un poco extrañas.

08:20.370 --> 08:26.040
Así que puede hacer que un agente parezca que ha llegado a la sala de espera cuando todavía está aquí fuera,

08:26.040 --> 08:27.840
que es algo que no quieres.

08:28.380 --> 08:29.810
Así que eso es una cosa.

08:29.820 --> 08:38.790
Ahora, cualquier agente que no llegue a un waypoint seguirá intentando ejecutar una de las acciones.

08:39.120 --> 08:39.510
De acuerdo.

08:39.510 --> 08:43.170
Y se puede saber si se selecciona un agente.

08:43.170 --> 08:46.170
Así que busquemos a alguien que realmente siga haciendo cosas.

08:46.170 --> 08:53.610
Este tipo aquí y en el inspector, vamos a encontrar a su paciente padre.

08:54.090 --> 08:57.240
El ir a la sala de espera, ir al hospital y registrarse.

08:57.240 --> 09:04.380
Si echas un vistazo a todas esas cosas, verás que hay una casilla pública en la parte

09:04.380 --> 09:11.460
inferior llamada "running" que te dirá qué acción está intentando ejecutar.

09:11.550 --> 09:16.170
Así que este agente en particular de aquí, está en la recepción.

09:16.170 --> 09:18.060
Así que, obviamente, sigue registrándose.

09:18.060 --> 09:23.430
Y si echamos un vistazo a su registro, se puede decir que, de hecho, sigue funcionando.

09:23.430 --> 09:30.330
Ahora, si presionamos y pulsamos pausa y esperamos un momento hasta que termine, puedes ver ahora

09:30.330 --> 09:35.250
que eso se ha marcado y ahora va a la sala de espera en su lugar.

09:36.390 --> 09:37.140
De acuerdo.

09:37.140 --> 09:43.680
Así que ahora, mientras esto sucede, vamos a detenernos de nuevo en otra manera de echar un vistazo a la depuración.

09:43.680 --> 09:51.030
Esto es si vamos a la consola, verás que está imprimiendo los planos.

09:51.240 --> 09:57.810
Y aquí puedes ver que dice que el plan es ir al hospital, registrarse, ir a la sala de espera.

09:57.810 --> 10:04.950
Así que este plan está sucediendo en orden y he derrumbado lo que está pasando en la consola, ya que sólo será escribir

10:04.950 --> 10:08.010
esto para cada agente en particular.

10:08.010 --> 10:13.110
Pero esto te está mostrando que este es el plan que han elaborado, que es el plan

10:13.110 --> 10:15.300
que tú querías que elaboraran.

10:15.300 --> 10:18.600
Así que al menos todo es bueno, ¿no?

10:18.600 --> 10:24.570
Así que eso es conseguir un montón de agentes en funcionamiento y despojarlos.

10:24.570 --> 10:30.600
Cuando volvamos en la próxima clase, tendré que hablar un poco más de la depuración de estos escenarios

10:30.600 --> 10:37.950
porque en realidad es una parte bastante importante de esto, y empezaremos a trabajar en conseguir que nuestra enfermera

10:37.950 --> 10:39.300
se ejecute.
