Bueno, en cuanto a mecánica de juego lo tenemos casi todos, tenemos pavor a los enemigos, sin embargo,
nos falta una cosa nos falta que el manager haga algo más que escanear un solo enemigo.
Querremos que espanté múltiples enemigos y que incluso incremente el número de enemigos que son escaneados
en pantalla en cada oleada, de modo que necesitamos cada vez más y más y más enemigos en pantalla.
También necesitamos escanear powerups a cada una de las oleadas para poderle dar una posibilidad al
usuario que luche contra las hordas de enemigos y que ese número de power ups también sea variable.
A ver el escríbelo tenéis porque se les palmauna ayer.
Lo que pasa que es panea en el START y sólo aparece una oleada de enemigos.
Vamos a necesitar escanear múltiples veces tanto enemigos como apoderadas, y cada vez que el número
de enemigos vuelva a cero es planear una nueva oleada con más número de enemigos, más número de apps,
lo que sea.
Entonces vamos a utilizar de nuevo los bucles para poder hacer un escaneo constante uno detrás de otro.
Y aquí va a aparecer un concepto nuevo bastante interesante, que es el de saber cuántos enemigos quedan
en pantalla.
No nos va a quedar más remedio que buscar todos los objetos que cumplan una cierta condición, que sean
de tipo enemigo.
Así que vamos a por ello.
El spawn manager va a ser el que vamos a toquetear de ahora en adelante durante bastante rato.
Además, entonces lo que vamos a hacer va a ser lo siguiente acordaros que aquí en un momento dado yo
hice un bucle que desde cero hasta diez es pavoneaba diez enemigos.
Vale, aquí lo hice a piñón, quizá un poco a saco.
Lo que pasa que lo hice en el START.
Como yo voy a querer generar oleadas, este código voy a tener que copiar y pegar para generar cada
oleada que se me pase por la cabeza a la que tenéis que copiar y pegar código.
Qué es lo que tiene que venir siempre a la cabeza?
Funciones, no rutinas, funciones o métodos.
Entonces voy a cortar esta cosa, me voy a venir aquí abajo y vamos a hacer un Public Bait Spawn Enemy.
Es voi dijiste que los bugs no se pueden hacer.
Este es un caso donde como vais a generar enemigos y los vais a enchufar en la pantalla, como os enchufan
en la pantalla y no hay nada más que hacer con esos enemigos.
Puede ser.
Si lo haceis así, la funcionalidad de escanear una oleada la tenéis cumplida.
Lo único que voy a hacer es uno en lugar de colocar hasta 10.
Voy a colocar hasta tres para que no haya tantos, porque sobretodo cada oleada habrá más enemigos.
Como empecemos con 10 y en la siguiente oleada y 20 ya la moldeado va a ser muerte súbita.
Esto?
Y lo que no os tenéis que olvidar es que como lo acabo de quitar del estar.
Si ahora lo que quiero es que haya un paneo de una oleada en el estar, aquí hay que llamar.
Ahora ya no hay que escribir todo el bucle.
Ahora sólo hay que llamar a las funciones Pawn Enemy Wait, que acabáis de crear.
Por tanto, arriba en el estar Spawn Enemy Way.
Abro, cierro, paréntesis y punto y coma.
Por tanto, si lo haceis así, solo hecho un factor.
Solo le he cambiado de sitio.
El start llama a My way my wait que está abajo, hace un bucle y este bucle fijaros que es un bucle
for y lo único que hace es para cada entero entre 0 y 3, por tanto para igual a cero, para igual a
1 y para igual a 2.
Un total de 3 veces ejecuta esta línea de código instancia el Enemy FAP en la posición aleatoria que
el método que habíamos generado con la rotación que tuviera el propio Privat.
Acordaros que yo solo tengo un enemigo, sólo tengo la bola roja.
Si vosotros añadimos un segundo enemigo o un tercer enemigo, un cuarto enemigo.
Incluso dentro de este bucle podéis elegir aleatoriamente qué enemigo queréis escanear y os dais más
variedad al juego.
Por tanto, ahora tenemos nuestro bucle en una función se paradita que es llamada en el estar, pero
que además podrá ser llamada en otros momentos, en particular cuando no haya enemigos en pantalla.
Ya os dije que ayer la documentación es la clave.
Entonces, Spawn Enemy Wait es un método que habéis creado vosotros, a la que queréis un método vosotros
documentarlo.
Recordad que para documentar triple barra de comentario saldrá esta cosa.
Fijaros que como no devuelve nada y como no tiene parámetros de entrada solo aparece Summary, no aparece
ni el return ni aparecen los páramos.
Y para documentar esta cosa, pues sería un método que genera un número determinado de enemigos.
En pantalla vale.
Sería.
En particular, hay alguien que todavía no entienda lo del IMAS más y además.
Hay alguien que no entienda la asignatura a la cabecera del bucle for.
El bucle for siempre tiene tres partes declaración de variables, condición para que el bucle continúe
y incremento, de modo que este bucle se leería.
Este bucle crea una variable entera llamada ahí y con valor inicial cero.
El bucle que va entre la llave de apertura y la llave de cierre se va a ejecutar mientras el valor de
I sea más pequeño estricto que 3, y cada vez que llegamos al final, cada vez que lleguemos a esta
llave de cierre, el valor de la variable se incrementará en una unidad más.
Por cierto, sería lo mismo que esto igual hay más o no, lo que pasa que esto es tan común en programación.
Igual hay +1 igual a +1 igual a +1 que se le ha dado el shortcuts y más más vale.
Pequeño paréntesis también existe.
Más vale la diferencia entre un y más, más, más, más.
Y es que si el más está delante de la variable, se incrementa el inicio del bucle.
Sí, el más más está detrás de la variable.
Se incrementa al final del bucle.
Vale, por tanto y con cuidado, a ver si os interesa incrementarlo antes o después.
Vale porque se lo incrementas antes, cuando comprobéis.
Aquí se ejecutaría una vez menos la condición de continuación que se está aquí.
Siempre se evalúa al inicio la llave y la inicialización es antes siquiera de que empiece el bucle,
o sea, realmente lo que ocurre dentro del ordenador.
Cuando yo escribo esto es primero se reserva un espacio en memoria para una variable llamada ahí y se
le asigna el valor cero.
A partir de aquí, el cuerpo del bucle entre la llave de apertura y de cierre es ejecutado, siempre
y cuando esta condición sea verdadera.
Entonces nos ponemos la llave de apertura cero es más pequeño que tres.
Si ejecutas esta línea, llegáis a la llave de cierre.
Condición de finalización que es más de incremento y más, o sea, y valía cero.
Ahora vale 1.
Subimos aquí ahora y vale 1.
1.
Sigue siendo más pequeño que 3.
Si ejecutamos esta línea, llegamos al final de la llave de cierre, incrementamos en una unidad ahora
y pasa a valer 2.
Subimos de nuevo arriba.
Verificamos si esto todavía es cierto.
2.
Es más pequeño que 3.
Si todavía es cierto, ejecutamos el bucle.
Llegamos a la llave de cierre.
Condición de incremento y más.
Ahora vale.
3.
Subimos arriba del bucle.
3.
Es más pequeño, estricto que 3?
No, esto ya es falso.
Como es falso, el cuerpo del bucle no es ejecutado.
Paso a la siguiente línea que estaría por aquí que no hay nada y por tanto el bucle ha terminado.
No entendemos esto.
La primera vez que lo cuentan es una paja mental muy grande.
Vale, pero es la diferencia entre un humano y una máquina.
El humano tiene que hacer esto a mano y se tira 3 días.
La máquina te lo hace en menos de un milisegundo.
De hecho, el ejemplo claro que suelo poner yo cuando explico los bucles desde cero es contar hasta
100.
Ya podéis contar todo lo rápido que queráis, pero los 3, 4, 5 segundos no lo quita nadie.
Vale, y si contáis de forma más normal los 15 20 segundos no los quita nadie.
La máquina te lo cuenta, te lo imprime por pantalla en menos de un milisegundo porque es rapidísimo.
El caso más bestia contratas a un millón, hasta 10 millones, hasta mil millones, hasta 2 elevado
a 32 o 2 elevado a 64.
No acabareis probablemente en toda vuestra vida.
El ordenador te lo hace en un par de segundos.
Entonces es la potencia que tiene un ordenador el de automatizar tareas para repetirlas super rápidamente,
como esta cosa de aquí.
Si un humano tuviera que instancias algo en una posición, imaginad que es un juego de mesa colocar
las fichas de un enemigo en una mesa, pues entre que busca las fichas busca donde las quiere poner,
las pone las rotas, las coloca, pasan un par de segundos, el ordenador te lo hace al instante y por
eso muchas veces usamos las rutinas, porque son tan rápidas que queremos que no sea tan rápido que
esperemos unos segundos o que dé la sensación de que aparezca primero un enemigo, luego otro, luego
otro, luego otro.
Vale que de hecho lo podríais hacer aquí si en lugar del spawn enemy huay será una función fuera una
rutina en el propio.
Podriais instancias de un enemigo, esperar un segundo instancia a un enemigo y esperar un segunda instancia
a un enemigo o esperar un segundo y que así fueran apareciendo paulatinamente, ahora las oleadas saldrán
de golpe.
Pero si queréis una mejora, cambias la función por rutina y hacéis que esperen una pequeña cantidad
de tiempo para que vayan apareciendo como setas.
Incluso le añades una animación, le añades un sistema de partículas como aquella explosión que teníamos
en lugar de aparecer de la nada.
Van apareciendo literalmente como setas, van apareciendo.
Os voy dando ideas porque son cosas que ya sabéis hacer con lo que yo os he explicado.
Vale, entonces esto serían las oleadas de enemigos y vamos a preparar este código para que les pawnee
sea cada vez un poco más difícil.
Cómo?
Muy fácil.
Aquí vuelve a haber algo prohibido para nosotros, que es un número a piñon escrito.
Vale, entonces esta cosa que hay aquí, escrita a saco, debería ser mucho mejor.
Una variable, entonces, como el propio Spawn Enemy Web se presta a ello.
Lo más normal sería que aquí, entre paréntesis, le indicamos una variable con cuántos enemigos queréis?
Por ejemplo, in number of enemies.
Número de enemigos a escanear.
Por cierto, no sé por qué el método público no tiene mucho sentido.
Lo puedes hacer en privado.
No quiero que nadie me lo invoque.
Nadie de fuera, digo, tiene mucho sentido, pues el privado.
Cuando colocas una variable dentro de los paréntesis es lo que en programación llamamos un argumento.
Un argumento es suministrado a una función para que la función haga uso de ese argumento.
Qué quiere decir esto?
Esto es muy importante.
Quiere decir que esta variable que hay aquí solo existe desde que abriese esta llave hasta que la cerramos
aquí abajo.
No intentéis acceder a ella aquí porque no existe.
Veis que no sale nada aquí no existe porque estáis fuera de la llave que cierra la función.
Sin embargo, sí la consulto aquí veis que sí, que me sale.
Vale, por tanto, esto se llama el ámbito de visibilidad de las variables.
El ámbito de visibilidad es donde las puedes usar y la regla de oro es la siguiente.
Una variable existe desde la llave que la define hasta la llave que cierra.
Por ejemplo, aquí tenía variables que las he definido fuera de cualquier método correcto.
La llave que las definen cerradas es la de la clase.
Esto quiere decir que la variable enemy spawn rains son utilizables desde esta llave que abre hasta
la llave que cierra, que es la última del fichero de hecho.
Por eso, si os fijáis, tanto esta variable como ésta las he utilizado en el estar no, pero se ha
utilizado en el género opposition o las he utilizado dentro de esta función porque son globales.
De hecho, es el sitio más general en el que podéis definir una variable.
Sólo hay una cosa más general que esto que sacarla de una clase.
Vale, entonces existen desde esa llave de apertura hasta esta llave de cierre.
El nombre lo hacen enemigos, como es un argumento de esta función.
Esta función va definida por esta llave que hay aquí.
Por tanto, la variable de los enemigos va a existir en el ámbito de visibilidad, desde esta llave
abierta hasta esta de aquí, es decir, aquí, dentro de esta zona de color azul, que si que existe
la variable number of enemies y la podéis utilizar, por ejemplo, para que en lugar de escanear tres
enemigos, siempre se es pawnee, el number of enemies en cuestión que le suministramos a la función.
Lo entendéis?
Hay otro caso todavía más bestia el foro A, que define una variable entera inicialmente igual a cero
y Puyo y cuyo nombre es y esta variable y está definida por este foro donde va a existir esta variable
y desde la llave que abre hasta la llave que cierra.
Quiere decir esto que aquí fuera?
Yo coloco igual a 7 y está en rojo.
Falla porque está fuera del ámbito de visibilidad en la cual ha sido definida.
Ni te cuento si lo saco de la función igual a 6 capullo.
Sin embargo, dentro del bucle tú vienes aquí y haces y igual a 8 y no hay problema porque existe la
variable.
Los fallos que me encuentro de la gente que empieza a programar es que las llaves esta se cree que son
de decoración.
Vale o se cree que esto es bonito?
No es bonito, encierra un sistema de cajas.
De hecho, las cajas las tenéis visibles siempre aquí.
A lo mejor no lo veis, pero en vuestro editor si lo miráis cada vez que ponéis una de estas palabrotas
de color azul, veis que aquí os sale un simbolito menos menos, indica.
Un sistema de cajas anidado onda dentro de la otra.
Una llave no puede cerrarse a menos que sea exactamente la que había sido abierto anteriormente.
Entonces, si yo cierro aquí, veis que el foro me aglutina desde su llave de apertura a la vez y al
revés, que aquí hay unos puntos suspensivos con el cuerpo del bucle.
El cuerpo es las líneas de código que van definidas dentro de ellas.
Entonces variable que definís en este foro variable que solo es visible en el ámbito de visibilidad.
Tendré la llave que abre y cierra el propio foro.
Vale lo mismo para esto genérico de siempre.
Y además, yo voy a poder cerrar esta llave de la clase sin cerrarla del foro.
No, porque es un sistema anidado de cajas.
Fijaros que la caja del foro está dentro de la caja del Spawn Enemy Way y está dentro de la caja de
toda la clase.
Es un sistema de cajas, siempre es una caja dentro de otra caja.
La forma que tenemos de marcar, donde se abre y donde se cierra la caja es con estas cabecitas.
Técnicamente hay un caso en el que no necesitarías llaves, que precisamente es éste cuando sólo hay
una línea de código.
Cuando el bucle, por ejemplo, sólo tiene una línea de código.
Técnicamente no os hace falta ni la llave que abre ni la llave que cierra.
Entonces es un poco más corto.
Yo no os recomiendo que hagáis esto, incluso yo, que ya llevo un par de añitos programando 2 o 3,
no lo hago nunca.
Es una muy mala práctica.
A mí me gusta tener súper bien definidas dónde están las cajas y si de un vistazo.
Además, con este editor va fantástico porque aparecen las rayitas verticales que unen las llaves,
que te guía superbién.
Si se las quitas te desaparece la raya vertical.
Entonces fijaros que no desaparece, se queda, lo que pasa que es más difícil de detectar.
Yo prefiero que las dejéis.
Es como el disputo algo.
Ya os dije que es cuando estáis dentro de una clase.
Sobran, no hace falta, pero colocarlo da un poco de más énfasis, que se trata de una variable mía.
Vale.
De hecho, el propio Hobbys es muy divertido porque ves que esta variable se llama number of enemies.
Fijaros aquí porque esto es muy importante.
Esta variable Nãmero Fene existe desde la llave de la línea 35 hasta la llave de la línea 40 aquí fuera.
Yo ahora puedo definir otro seremis.
Se llaman igual y estas son absolutamente iguales.
Los gays se llaman igual.
La diferencia es que ésta existe fuera del método.
Esta solo existe dentro del método.
Entonces, si las dos se llaman igual.
Cuando yo escribo números enemigos, a cuál de las dos hago referencia?
Veis que hay dos a cual hago referencia?
A la de fuera o la de dentro?
Pues la regla es la siguiente.
Si es la de fuera es porque es la de la clase.
Es mi nombre FNM.
Si es la de dentro, sin dis.
Veís que de hecho el color lo dice ahora las lilas o azules?
Lo que sea esto.
Las azules son miembros de una clase, son propiedades de la clase, pertenecen a la propia clase.
Estas son pecata minuta.
Esto estaba por aquí porque hace falta y da gracias.
Pero veis que estas de color blanco son estas que hay aquí.
De hecho me lo pone de color amarillo porque seguramente me está sugiriendo renombra o capullo que lo
has llamado igual, pero no hay ningún problema.
Esto existe y se hace.
Además hace muchísimo, muchísimo, muchísimo, muchísimo, para copiar valores y demás.
Pero tened en cuenta eso que dices cuando colocas un dis ya sabéis que lo que viene después es una propiedad
que es global y que por tanto es una propiedad de la clase, si no que lo que hay es el DIS.
Sabéis que es una variable intermedia.
Por ejemplo, aquí cuando hecho el Generate Composition veis que estas salen en azul sin necesidad de
poner el disco.
Están azules.
Yo sé que son propiedades, pero es que si le pongo el visto más claro que son propiedades de la clase,
mientras que estas de aquí ves que están de color blanco las de color blanco.
Esto es una variable que de nuevo solo existe entre la llave de apertura y la llave de cierre.
Donde habéis declarado entendéis esto?
Sé que soy un poco pesado, pero es que es muy importante, sobre todo si la primera vez que programes
vale, entonces no hace falta esto.
Evidentemente no hace falta esto.
Lo que si me van a hacer falta son dos cosas.
La primera, este método ahora tiene un parámetro de entrada lo veis?
Si tiene un parámetro de entrada, hay que documentarlo dentro del sumario.
Colocar un paramos de hecho fuera del summary lo puedes colocar.
Que puñetas?
La variable un número de enemigos y las explicaciones número de enemigos a crear.
Tal cual.
Sigue sin devolver nada, por tanto no estaría obligado a colocar aquí un returning nada por el estilo.
Esto es correcto, lo que es Pawn Enemy Way era llamado o no en el Star?
Os acordáis?
El Star llama a este método y este método ahora entre paréntesis, que es lo que está esperando un número
entero.
Cuántos enemigos hay que spamear por tanto?
Hace un rato que tengo un error aquí arriba.
Lo veis?
Y si me pongo encima me va a decir Oye, por qué es un error esto?
Porque no tengo el valor de cuántos tengo que crear, lo tengo que suministrar aquí queréis generar
dos enemigos, ponéis dos.
Queréis generar tres enemigos?
Con lo que hay son tres.
Queréis generar 3,8 enemigos?
No se puede porque habéis dicho que era un número entero.
Vale, lo veis?
Que argumento de tipo float no se puede asignar a un parámetro de tipo y muchas veces saber programar
no es tener conocimientos en la cabeza, es saber leer lo que tenéis delante.
O sea, esto para mí es como la cocina.
Tú tienes tu receta de cocina, la sigues y suele salir.
A veces improvisar, cambias algo, pero la receta suele salir.
Hay que saber leerla, pues estos saben leer.
Una receta de cocina coma 3,8 enemigos.
Lo siento tres coma ocho o tres o cuatro tres coma ocho.
No vale.
De hecho, ahora que lo hemos cambiado nos podemos ir cómodamente a nuestro editor y lo que debería
pasar es que después de todo este rFactor se tendrían que generar tres enemigos en el estar.
De momento no veis que ahí aparecen las tres bolitas?
Estas valen si la habéis puesto otro número se genera otro número determinado de bolas, pero por lo
menos ahora.
Ya empezamos a dar el pego de los enemigos que se generan y demás.
Si vale, perfecto, pues básicamente ya tenemos nuestro código, sobretodo fijaros lo importante que
es la documentación.
Para mí esto es la clave, es la clave, porque tú cuando quieres utilizar Spawn Enemy Way, ahora lo
hemos programado nosotros y lo usamos nosotros mismos en un proyecto más grande.
Imaginad que tu programa es el método y yo lo tengo que usar.
Necesitaré saber qué parámetros de entrada tiene que devuelve.
Qué hace entonces?
Yo vengo aquí a Spawn Enemy Way, método que genera un número determinado de enemigos y demás.
Vale, perfecto.
Puedo leer cómodamente qué es lo que hace este determinado argumento?
Vale, entonces cualquier 3 y me quedo tan ancho.
De hecho, fijaros que ya me colocan.
Dan fe de mis dos puntos para saber exactamente que ese 3 es el número de enemigos, cuanto mejor documentado
está, cuando mejor le deis el nombre.
Es una delicia programar con algo bien escrito, si vale, perfecto.
Ya tenemos las oleadas casi preparadas.