Bienvenido de nuevo, Mis desarrolladores de juegos favoritos.
En este video, en realidad hemos empezado a engendrar
enemigos de una manera inteligente.
Entonces ahora cuando ejecutemos el juego,
Hagamos esto más grande para que veas
correctamente lo que está pasando.
El después de que termine el candidato,
aparece el primer enemigo,
aparece el segundo enemigo,
y simplemente se sientan ahí esperando que los matemos.
Entonces una vez que sí los matemos,
intentemos ir a ellos.
Está bien.
Eso es en realidad, oh, bien, eso fue vergonzoso.
Reiniciemos el nivel.
Espera eso. Entonces
hicimos tan buenos enemigos que no podemos matarlos.
De acuerdo, así que déjame intentarlo.
Déjame llegar a cierta distancia para que ya no podamos.
Entonces una vez que los llamamos, se puede ver
que tenemos la ola completa.
Y entonces otra vez, conseguimos que el enemigo desove porque hemos
hecho la cantidad de enemigos y aquí también para esta ola.
Entonces, no perdamos más tiempo y empecemos.
Ah, caso.
Entonces sigamos adelante y en realidad empieza a ser dueño de enemigos.
El primero que vamos a hacer es
obviamente crear aquí algún tipo
de ya sea una co-rutina o podemos crear también un contador.
Pero nos vamos a quedar con
el Coubertin Y este cortejo se llamará
cada vez que tengamos este retraso engendrado.
Por lo que este equipo central estará engendrando a los enemigos.
De todos modos, empecemos y veremos
cómo funciona todo.
Entonces vamos a crear un enumerador de ojos aquí.
Y se va a llamar la onda de desove.
Y la ola que queremos realmente engendrar.
Por lo tanto onda a mancha.
Por lo que ya tenemos la ola que queremos abarcar.
Tendrá sus propios enemigos,
su nombre, y la cantidad de enemigos que tiene.
Entonces vamos a crear un bucle for.
En este for loop, vamos a empezar
con un entero I igual a 0.
Nos vamos a asegurar
que nunca superemos el peso para engendrar,
o es la ola para engendrar,
la cantidad de enemigos?
Y también vamos a estar incrementándolo en
uno cada vez.
Entonces aquí vamos a crear un número enemigo aleatorio.
Y va a ser el rango aleatorio.
Y este rango será superior a 0.
Y la ola para engendrar enemigos longitud de puntos.
Entonces ahí vamos y recordamos que los enemigos,
y aquí hay una serie de objetos de juego.
Por lo que queremos pasar ahí dentro a un enemigo aleatorio.
Entonces voy a entrar aquí donde diremos
que algún tipo de método
para engendrar porque queremos tenerlo
fuera del, esto aquí mismo.
Esta sólo será la ola de desove.
Este será el desovador enemigo aquí dentro.
Y qué vamos a hacer,
y la forma en que funcionará este numerador
ya que vamos a ceder
retorno nuevo, espera cuatro segundos.
Y va a estar en la ola.
Responder. No demora, retraso de desove de puntos.
Entonces, ¿qué está pasando aquí?
Esta es la primera vez que creo que usamos
el retorno de rendimiento
dentro de un bucle for en un enumerador o una coroutine.
Entonces pasamos por este bucle.
Cada vez que elegimos un número aleatorio,
engendramos algún tipo de enemigo,
y luego esperamos cuatro segundos.
Y entonces otra vez, engendramos a un enemigo, engendramos a un enemigo.
Por lo que esto nos permitirá
ceder retorno y llamar a esto varias veces,
esta ola engendrada varias veces.
Y después de hacer esto,
vamos a crear también
el método real que engendrará al enemigo.
Así engendra enemigo.
Y aquí dentro vamos a decir que le vamos a mandar
el objeto de juego y el enemigo a desovar.
Y aquí dentro vamos a decir debug dot log solo para
asegurarnos de que sabemos qué enemigo está
siendo engendrado y todo está funcionando correctamente.
Entonces desove al enemigo.
Y le vamos a dar el enemigo para engendrar.
Pero nombre.
Ahí vamos. Y simplemente estamos llegando a instanciar.
Y luego se comió el NMI. Demasiado pequeño.
Y va a ser, oops, discúlpame.
Entonces va a ser toda la posición de punto de transformación
y transformamos la estación de fila.
Entonces, ¿cuál es la transformación?
¿ De qué transformación estamos hablando?
Por lo que debido a que el spawner de olas está
apegado al gestor de nivel,
esta será la posición y la rotación
del objeto de juego level manager en nuestra escena.
Y más adelante, estaremos creando
varios puntos sobre los que estarán desovando los enemigos.
Por lo que funcionará así.
Tendremos algún tipo de array.
Nos ocuparemos de eso más adelante que ahora está
enfocado en instanciar realmente a estos enemigos.
Así engendrar enemigo, la ola para engendrar
enemigos en la posición
del número enemigo aleatorio que acabamos de crear.
Entonces voy a añadir un entrar aquí. ¿Qué estamos haciendo?
Tenemos que llamar también a la coroutina y aquí,
así que antes de que nos olvidemos, tan co-rutina.
Engendrar, engendrar, enemigos, ola.
Sí, ahí vamos.
¿ Y de qué manera deberíamos estar desovando?
Si bien aquí solo vamos a decir que es la ola,
ondas en la posición siguiente onda.
Entonces va a ser probablemente
0 en este momento porque la siguiente ola,
mientras que la siguiente,
comienza en 0 justo aquí.
Entonces va a ser la primera ola
que es por solo experimentar por ahora,
que está enfocada en lo que esto hace.
Entonces una co-rutina que inicia si nos aseguramos
de que no estamos
desove de la cuenta regresiva es menor a 0,
no estamos desove,
estamos listos para empezar a desovar.
Entonces iniciamos el recubrimiento aquí dentro tenemos el bucle recorrerá
la cantidad de enemigos en
la ola que recibimos.
Como coroutina, creamos un número aleatorio.
Engendramos a un enemigo aleatorio que sólo tiene la depuración
para decirnos qué enemigo se está generando
probablemente lo eliminará más adelante.
Y luego instanciamos al enemigo real sobre el manager.
Y entonces qué pasa? Rendimos retorno,
esperamos cuatro segundos y luego engendramos en otro enemigo.
Entonces antes de que se llame este bucle que de nuevo,
tenemos que sopesar el retraso de desove
que nos designa.
Entonces voy a guardar todo eso.
Voy a volver atrás y unidad.
Y veamos qué tenemos aquí como gerente de nivel.
Espere a que esto compile cualquier cosa.
De acuerdo, entonces vamos al
encargado de nivel del gerente y ¿qué tenemos aquí dentro?
Estaba jugando por ahí,
tal vez no hice esto en el video.
Entonces tenemos esta ola aquí mismo.
Es la onda esqueleto.
Los enemigos que tenemos aquí dentro son
el enemigo esqueleto y el cobarde volando alto.
El número de enemigos que queremos es y responder
laico será de dos segundos.
Voy a salvar esto.
¿ Dónde está el nivel manager y nuestro mundo?
No está en el 000.
Volvamos a ponerlo a 0,
así que está justo delante de nuestro jugador.
Y vamos a ejecutar el juego y ver cómo se ve.
Entonces ahora 12, deberíamos ver la cuenta regresiva de olas.
Ahí vamos y whoa,
eso son demasiados enemigos.
Veamos qué hicimos mal aquí dentro.
Entonces guardamos eso.
Lo que está pasando aquí,
estamos revisando la cuenta regresiva es menor a 0.
¿ No estamos en estado de desove?
Bueno, veamos.
Empezamos con el conteo, así que no lo estamos.
Por lo que obviamente necesitamos cambiar nuestros estados aquí.
Entonces antes de que realmente creemos el bucle o iniciemos el bucle,
vamos a decir que estamos en
un estado que es igual a
los Estados desove, pero desove.
Y luego cuando terminemos de desovar,
vamos a entrar en un estado,
que es la ponderación.
Por lo que estamos esperando a que los enemigos sean engendrados.
Entonces ahora empezamos antes de que realmente pasemos por el bucle,
dijimos el estado.
Entonces ahora esto no se llamará cada
vez y no tendremos tantos enemigos.
Volvamos a probar esto.
Ejecuta el juego. Podemos ver la cuenta regresiva aquí.
Yo lo hice público. Ahí vamos.
Entonces 0, conseguimos al enemigo y empieza a disparar.
Después conseguimos otro enemigo,
y luego les dimos otro enemigo,
y se está llamando cada dos segundos.
Así que mira a estos pequeños cowers aquí mismo.
Este es un mecánico de juego genial realmente agradable, como puedes ver,
cada dos segundos, 1212, y ahí vamos.
Entonces, como puedes ver,
se está llamando a enemigos cada segundo.
Pero ahora quizá te estés preguntando,
¿por qué tenemos tantos enemigos, a
pesar de que dijimos que la cantidad
de enemigos debería ser sólo también.
Bueno. Es porque aquí dentro, en
realidad no tenemos reiniciando la cuenta regresiva de las olas.
De nuevo, algo con lo que trataremos más adelante.
Pero primero pensemos en cuándo estaremos
reiniciando realmente la ola y cuándo hace una onda real?
Y así podemos o crear un tiempo entre ola.
Entonces digamos la primera ola y la segunda onda,
hay un retraso entre ellos.
O podemos tener algún mecánico realmente agradable y darle a
nuestra capa o a la persona que está jugando nuestro juego
oportunidad de seguir adelante y matar a todos los
enemigos en esta ola antes de que comience la siguiente ola.
Entonces esto es lo que vamos a hacer.
Y para ello, vamos a
crear algún tipo de método
que hará un seguimiento de si un enemigo ha muerto o no.
Entonces volvamos aquí abajo.
Y después del enemigo engendrado,
vamos a crear un privado.
Va a haber un booleano,
y van a ser los enemigos o vivos.
Y esto volverá cierto si
todos los enemigos están vivos o no.
Ah sí, si todos los enemigos están vivos y falsos,
si uno de ellos o ninguno de ellos está vivo.
Entonces aquí lo que voy a decir,
voy a crear una condición if.
Y voy a tener el objeto final de tipo.
Y los objetos de tipo en realidad no encuentran objetos,
encuentran objetos de tipo.
Y el controlador enemigo,
estaré buscando el controlador enemigo longitud de punto.
Y va a ser igual a 0.
Y si lo es, entonces vamos a devolver falso.
Tan falso, eso significa que todos los enemigos han muerto.
Y luego si pasamos por
este y no regresamos falso,
entonces vamos a volver verdad.
Eso significa que los enemigos siguen vivos.
Entonces ahora tenemos una ola
o de asegurarnos de que todos nuestros enemigos
se hayan agotado y podremos
usarlo aquí mismo como condición de alguna manera.
Pero hay un pequeño problema que me está molestando.
El hallazgo de objetos de tipo en
el controlador enemigo es en realidad un muy engorroso,
digamos operación en el sistema.
Ocupa muchos recursos cada
vez para pasar por todos los objetos en el
controlador enemigo,
lo que a veces no es muy necesario.
Entonces lo que queremos hacer es que queremos tener algún tipo
de temporizador en los enemigos están vivos checker.
Por lo que en realidad no comprobamos
cada fotograma si todos los enemigos están muertos.
Pero en cambio, tenemos esto
siendo comprobado cada par de segundos.
Entonces te lo voy a emitir como un reto,
y tu reto es retrasar la comprobación.
Por lo que antes que nada,
necesitarás crear una variable para
el tiempo que transcurre entre buscar enemigos.
En el método booleano se asegura de que no miremos
a todos los enemigos excepto cuando se acabe el tiempo.
Preste atención a dónde debemos restablecer este contador.
Por lo que esto será muy importante.
Entonces con eso dicho,
pausa el video ahora mismo y ve a hacer cada Shannon.
De acuerdo, bienvenido de nuevo.
Entonces me voy a desplazar hasta aquí.
Y voy a crear un flotador privado.
El tiempo entre la búsqueda del enemigo, entre la búsqueda del enemigo.
Y digamos que es una F.
Así que 1 segundo. Cada 1 segundo comprobamos
por todos los enemigos de la deuda.
Y entonces aquí dentro voy a decir que el tiempo entre la
búsqueda se está reduciendo por el tiempo.Deltatime,
cada fotograma, y esto se llamará
cada fotograma.
Y luego aquí abajo,
voy a revisar antes de que realmente verifiquemos
todos los objetos.
Si el tiempo entre búsqueda es menor o igual a 0,
entonces estaremos buscando. Ahí vamos.
Y entonces, ¿cuándo realmente restablecemos esto?
Por lo que una vez que el tiempo entre
búsqueda es menor o igual a 0,
empezamos por comprobar si todos los enemigos han muerto.
Y también podemos seguir adelante
y restablecer esta vez entre búsquedas.
Y voy a ponerlo en 1.5 porque no creo
que esto sea algo
que quizá quieras cambiar en el inspector, el
tiempo entre búsquedas enemigas,
esto puede ser bastante estándar.
Pero si crees que podrías
necesitar cambiar esta variable,
obviamente esta f no funcionará.
Necesitas subir aquí,
crear una variable separada
si hiciste eso, felicitaciones,
este es el mejor paso o la mejor forma de pensar,
el mejor diseño del juego tal vez.
Pero para mí, creo que esto
será algo muy constante,
algo que no va a cambiar.
No creo que alguna vez tengamos que cambiar
el tiempo entre las búsquedas enemigas.
¿ Eso terminará?
Volvamos a subir aquí.
Y tenemos que asegurarnos de que nosotros,
¿Dónde está aquí y actualizar.
Vamos a comprobar que
el estado es igual a los estados de desove punto de espera.
Entonces eso significa que constantemente estamos
desoviendo enemigos y estamos en la espera.
Por lo que comprobamos después de que obviamente terminamos esto para bucle,
comprobamos es el estado esperando.
Entonces si está aquí,
vamos a comprobar si los enemigos están vivos.
Y note que agregamos este signo de exclamación,
que significa exactamente lo contrario.
Entonces si todos los enemigos tienen Lloyd van a
guardar debug dot log, ola.
Completa.
Guarda eso.
Y de lo contrario, si no lo es,
entonces simplemente vamos a regresar.
¿ Y por qué estamos haciendo esto?
¿ Por qué estamos diciendo retorno?
Dijimos que devuelto significa que no hacemos
nada más dentro del método, sobre todo en actualización.
¿ Por qué? Porque una vez que la ola esté completa,
no queremos volver a entrar en la ola,
ahora podemos comprobar si no estamos en desove,
que no estaremos n
porque obviamente estamos y la espera
y volver a empezar la grabación y
empezar a crear de nuevo a los enemigos.
Por lo que una vez que la ola esté completa,
queremos evitar que toda la actualización funcione.
Entonces voy a guardar eso.
Voy a volver a mi ganancia.
Y ahora deberíamos ver eso cuando corremos el juego.
Entonces conseguimos, después de cinco segundos de Cuenta atrás,
obtenemos el conteo al enemigo.
Después de dos segundos podemos contar otro al enemigo.
Y ahí vamos.
Se puede ver que lo hemos detenido todo para que ya no tengamos
más enemigos que tenemos que hacerlo.
Entonces voy a tratar de matar esos.
Entonces los tenemos a ambos.
Y como puedes ver, de nuevo,
se ha completado la ola y luego los enemigos
empiezan a desovar de nuevo. Está bien, genial.
Entonces con eso fuera del camino,
asegúrate de comprometer tus cambios.
Espero que lo disfruten y los veré en
el próximo video donde estaremos
desovar puntos por múltiples olas
y completándolos todos,
matando a todos los enemigos,
completando todo el camino,
y tal vez tener algún tipo de mensaje realmente bonito.
Entonces nos vemos.