Share
Ahora estamos a mitad de camino en esta serie, y hasta ahora hemos cubierto mucho. En el tutorial anterior, agregamos un sistema de puntos a nuestro juego, finalmente aplicamos la "gravedad" a los bloques y mejoramos nuestro sistema de emparejamiento. En este tutorial, realizaremos algunas pequeñas mejoras en nuestro sistema de intercambio, agregaremos el texto de puntos flotantes que puedes ver en la versión final del juego y terminaremos nuestro sistema de combinación de una vez por todas..
Aquí está una demostración del juego en el que estamos trabajando a lo largo de esta serie:
En este momento, el juego tiene implementado un sencillo mecanismo de intercambio. Si bien el sistema que utilizamos para realizar estos intercambios es muy efectivo, existen dos problemas que puede encontrar mientras juega, y ambos deberían solucionarse antes de continuar..
Estos problemas se derivan de la misma idea: que el sistema de intercambio no tiene en cuenta los límites del campo de juego.
¿Que significa exactamente? Bueno, primero, si quisieras, podrías mover un bloque fuera del campo de juego hacia la izquierda o hacia la derecha, haciendo un intercambio como el que se ilustra a continuación:
Si entras en el juego y haces este intercambio, verás que el juego no hace nada para detenerte y actúa como si el campo del juego continuara para siempre en una dirección horizontal. La razón de esto es que, en este momento, el campo de juego hace continuar para siempre horizontalmente.
Como nunca definimos dónde están los bordes izquierdo y derecho del campo de juego, o incluso si el campo del juego tiene bordes izquierdo y derecho, el juego nunca intenta impedir que el jugador mueva el bloque más hacia el lado. Este problema también surge cuando cambias el otro extremo del campo de juego también.
Para resolver este problema, agregaremos algunas nuevas condiciones a la Bloquear> En arrastrar y soltar drop Evento. Vaya a este evento y agregue esta condición al Subevento que verifica los intercambios a la izquierda:
Condición: Bloqueo izquierdo> Comparar comparación X = mayor o igual X = SPAWNX
Ahora agregue esta condición al Sub-Evento que verifica los swaps correctos:
Condición: Bloqueo derecho> Comparar X Comparación = Menor o igual X = SPAWNX + Bloque.Ancho * 8
Los eventos de intercambio a la izquierda y a la derecha deberían tener este aspecto:
Estas nuevas condiciones que agregamos están siendo utilizadas por los eventos de intercambio como una verificación para garantizar que el intercambio se encuentre dentro de los bordes horizontales del campo de juego. El primero garantiza que la posición a la que se cambiaría el bloque no está más a la izquierda que los Bloques que se encuentran más a la izquierda, y el segundo garantiza que la posición a la que se está intercambiando el bloque no está más a la derecha que la derecha. la mayoría de los bloques.
Con el segundo, utilicé una fórmula con Block.Width para encontrar dónde están los bloques más a la derecha para asegurarse de que, si el tamaño de los Bloques cambiara, no evitaría que esta condición funcione.
Si ejecuta el juego, ya no podrá realizar intercambios horizontales que podrían poner bloques fuera del área de juego..
El otro problema que tenemos es que el juego no te impide intercambiar un bloque debajo del campo de juego. Abre el juego e intenta hacer un intercambio como el que he ilustrado en esta imagen:
Después de hacer este intercambio, deberías haber visto que el bloque simplemente desaparece detrás de la parte inferior del campo de juego, y los bloques que estaban arriba deberían haber caído para llenar el espacio ahora vacío. Nuevamente, este problema se debe a que nunca definimos dónde está el borde inferior del campo.
En el tutorial anterior, declaramos que los bloques deberían dejar de caer después de alcanzar una cierta altura, pero nunca dijimos si estaba bien que un bloque fuera por debajo de esa altura al realizar un intercambio.
Arreglar esto será tan simple como los dos problemas anteriores. Vaya al subevento que comprueba si hay swaps a la baja y agregue esta condición:
Condición: Bloqueo de fondo> Comparar Comparación de Y = menor o igual Y = SPAWNY
Tu código para esta sección ahora debería verse así:
Al igual que la condición anterior, esto asegura que el intercambio no colocará el bloque en un área fuera del campo de juego. En este caso, se ve en el área debajo del campo de juego.
Si prueba su juego en este punto, ahora no debería poder hacer swaps que pongan el bloque debajo de la base del campo de juego..
En este punto, hemos resuelto los problemas con el sistema de intercambio, y podemos seguir mejorando nuestro sistema de puntos..
En este momento, nuestro sistema de puntos es bastante eficaz. Funciona de la manera que pretendemos y ya muestra todo correctamente. Sin embargo, a pesar de eso, si le diste el juego a un jugador y lo sentaras con él, es posible que no puedan decir exactamente cuántos puntos obtuvieron de cada grupo que ganaron, ya que el juego puede moverse rápidamente..
Para resolver este problema, vamos a agregar ventanas emergentes de texto que muestran cuántos puntos gana el jugador de los grupos que forman. Esto agregará un toque visual adicional al juego, y dejará en claro al jugador cuán valiosos pueden ser los grupos más grandes.
Antes de que podamos comenzar a agregar la funcionalidad, debemos crear un nuevo objeto que actuará como una ventana emergente de texto, así que siga estos pasos.
Accentsconagua
FloatingPointsText Campo de juego 616, 250 127, 43 0 Calibri, Negrita, 24 255, 255, 255 1.25.El objeto que acabamos de crear se usará para crear el texto flotante que le dice al jugador cuántos puntos les dará un grupo determinado. Ahora que tenemos este objeto, debemos implementarlo para que cuando el jugador haga una coincidencia, genere una nueva instancia del objeto y cambie el texto para mostrar el número apropiado de puntos..
Para generar el texto de puntos vamos a agregar dos nuevas Acciones a la NumMatchesFound cheques en el FindMatches función.
Ve a la FindMatches función, y agregar estas dos acciones al final de cada NumMatchesFound> 3 comprobar:
Acción: Sistema> Crear objeto Objeto = FloatingPointsText Layer = 2 X = Block.X - Block.Width / 2 Y = Block.Y - Block.Width / 2 Action: FloatingPointsText> Set Text Text = NumMatchesFound * 10
Tu FindMatches La función ahora debería verse así:
Entonces, ¿qué están haciendo estas acciones? La primera acción crea el FloatingPointsText Objeto en la parte superior del primer bloque en el grupo, y el segundo multiplica el número de bloques en el grupo por 10, al igual que nuestra fórmula de puntos, y establece el texto del nuevo objeto en ese número.
Si ejecuta el juego en este punto, debería notar que el texto no se mueve en absoluto. Para solucionar este problema, vamos a agregar un nuevo evento a nuestro juego..
Volver a Hoja de evento 1 y añadir un nuevo evento:
Condición: Sistema> Cada acción de tick: FloatingPointsText> Mover en ángulo Ángulo = -90 Distancia = 0.25
Tu nuevo evento debería verse así:
Si ejecuta el juego ahora, verá que el texto se mueve.
En este punto, nuestro FloatingPointsText funciona de la manera que queremos, pero es posible que haya notado un pequeño problema ahora que el sistema está instalado. El problema en sí se deriva de la forma en que funciona el sistema de emparejamiento, y ahora que podemos ver que todavía hay un problema con el emparejamiento, podemos solucionar el problema final y poner a punto nuestro sistema de emparejamiento.
Si aún no sabes de qué problema estoy hablando, entra en el juego y crea un grupo que contenga cuatro bloques. Una vez que se haga su grupo, debería ver algo similar a lo que tengo en la imagen a continuación:
Como puedes ver, en realidad tenemos dos instancias de los objetos de texto flotante. Si crea un grupo con cinco bloques, el problema se agrava aún más y verá tres instancias del texto de puntos..
El motivo de este problema se basa en la forma en que se detectan las coincidencias. En este momento, nuestro sistema de emparejamiento examina cada bloque individualmente, y mira en la dirección correcta, y hacia abajo, para encontrar coincidencias. Debido a esto, el sistema de coincidencia en realidad está encontrando tres grupos de tamaños diferentes aquí, aunque en realidad es solo un grupo grande.
El primer grupo se encontrará cuando comience con el Bloque A, y contendrá cinco bloques:
El segundo grupo se encontrará cuando comience con el bloque B y contendrá cuatro bloques:
Y el tercer grupo se encontrará cuando comience con el Bloque C, y contendrá tres bloques:
Entonces, en este momento, nuestro sistema de emparejamiento es muy ineficiente, y está roto, ya que está revisando los mismos bloques varias veces y registrando más grupos de los que existen.
Resolver este problema es en realidad mucho más simple de lo que parece al principio..
El problema aquí se debe principalmente al hecho de que el sistema de emparejamiento no tiene forma de saber si el bloqueo con el que está comenzando es en realidad el comienzo del grupo. Si pudiéramos garantizar que solo observamos los Bloques que estaban más alejados a la derecha, o los más altos, dentro de los grupos a los que pertenecían, entonces el sistema de emparejamiento sería efectivo tal como está.
Por lo tanto, todo lo que tenemos que hacer es agregar una condición o Evento que garantice que no haya bloques coincidentes arriba, o a la izquierda del bloque con el que comenzamos, y para informarle a la función cuando ha realizado esta comprobación, para que pueda proceda normalmente si el bloque que está mirando es el comienzo del grupo.
Lo primero que añadiremos es un nuevo parámetro para el CheckMatches función. Este parámetro será un entero y será 1 o 0.
Si el parámetro es 1, le indicará a la función que debe realizar la verificación para asegurarse de que está mirando el bloque inicial en el grupo; si esto es 0, Se indicará a la función que tiene. ya realizó esta verificación, y puede proceder normalmente para determinar si el grupo se compone de tres o más bloques.
Entonces, empieza por ir a la FindMatches función. En esta función llamas CheckMatches dos veces. Ya que esta es la primera vez que llamas CheckMatches para cualquier bloque que esté mirando, debe agregar un nuevo parámetro a cada una de estas llamadas de función y establecerlo en 1 para que verifique si el bloque que está viendo es el comienzo de un grupo.
Tu FindMatches La función ahora debería tener este aspecto, y he resaltado las dos declaraciones modificadas para su conveniencia:
Ahora que estamos diciendo CheckMatches cuando necesite realizar esta nueva verificación, debemos agregar la nueva verificación para que se realice. Ir a tu CheckMatches función, y agregue este nuevo Sub-Evento como el primer Sub-Evento:
Evento: Bloque> Comparar X Comaprison = Igual a X = Function.Param (0) - ((Block.Width + 2) * Function.Param (3)) Condición: Block> Comparar Y Comaprison = Igual a Y = Function.Param (1) - ((Block.Width + 2) * Function.Param (4)) Condición: Función> Comparar parámetro Índice = 5 Comparación = Igual al valor = 1
Antes de que termines de modificar el CheckMatches También necesita agregar una declaración Else en la parte superior del evento original para el CheckMatches función, y necesita agregar el nuevo parámetro a la CheckMatches función de llamada y configurarlo para 0.
El nuevo código para la función CheckMatches debería verse así:
El evento que agregamos hace exactamente lo que describí anteriormente. Primero, mira el bloque de arriba, o a la izquierda del bloque inicial que pasas.
Si ese bloque es del mismo color que el que pasaste, no hace nada ya que sabe que el bloque que pasaste no es el primer bloque de ese grupo..
Por otro lado, si es no del mismo color que el bloque que pasó, la comprobación original se produce debido a la instrucción Else que acabamos de agregar, y busca un grupo de tres o más bloques de la forma en que normalmente lo haría.
Si prueba el juego en este punto y forma un grupo con más de tres bloques, debería ver solo un objeto de texto flotante que le indica cuántos puntos valió ese grupo..
Ahora que hemos terminado de arreglar todas estas características, y finalmente hemos completado nuestro sistema de coincidencia, estamos listos para implementar el sistema de movimiento. Ya que hemos hecho mucho en este tutorial, y dado que el sistema de movimiento nos obliga a crear múltiples sistemas complejos, voy a esperar hasta el próximo artículo para iniciar el sistema de movimiento..
Si está ansioso por comenzar a trabajar en ello, considere algunas de estas cosas. Obviamente, lo primero que tienes que hacer es implementar el movimiento mismo. Para eso, intente usar un sistema similar al que usamos cuando hacemos flotar los objetos de texto de puntos. A partir de ahí, comienza a considerar cómo cambiarías la velocidad a la que se mueven. Finalmente, ¿cómo generará nuevas filas de bloques para el jugador y cómo lo sabrá? cuando para generar nuevas filas?
Tómese un tiempo para considerar estas cosas, y lo veré aquí la próxima semana para la próxima gran entrega de la serie..
