Creando las funciones del match 3

¿Cómo detectar un Match3 en un juego?

Detectar "Match3" es la mecánica principal de muchos juegos de puzzle en los que el objetivo es alinear piezas iguales en una cuadrícula. Para lograrlo, necesitamos implementar funciones clave que identifiquen si las piezas que hemos movido coinciden con otras de su mismo tipo en las direcciones: arriba, abajo, izquierda o derecha. Aquí te mostramos cómo puedes hacerlo de manera efectiva usando dos funciones principales en Unity.

¿Cómo buscar coincidencias en una sola dirección?

Primero, creamos una función que busca pistas del mismo tipo en una sola dirección dada. Esta función revisa si la pieza siguiente es del mismo tipo y continúa haciéndolo hasta llegar al final de la cuadrícula o encontrar una pieza diferente.

public List<Piece> GetMatchByDirection(int xPos, int yPos, Vector2 direction, int minPieces = 3) {
    List<Piece> matches = new List<Piece>();
    Piece startPiece = piecesArray[xPos, yPos];
    matches.Add(startPiece);

    int maxValue = width > height ? width : height;

    for(int i = 1; i < maxValue; i++) {
        int nextX = xPos + (int)(direction.x * i);
        int nextY = yPos + (int)(direction.y * i);

        if (nextX >= 0 && nextX < width && nextY >= 0 && nextY < height) {
            Piece nextPiece = piecesArray[nextX, nextY];
            if (nextPiece != null && nextPiece.pieceType == startPiece.pieceType) {
                matches.Add(nextPiece);
            } else {
                break;
            }
        } else {
            break;
        }
    }

    return matches.Count >= minPieces ? matches : null;
}

En esta función:

• Se define una lista para almacenar las piezas coincidentes.
• Se identifica la pieza inicial y se agrega a la lista.
• Se utiliza un bucle for para iterar en la dirección deseada.
• Se verifica si la siguiente pieza coincide con la inicial. Si no es así, se rompe el ciclo.

¿Cómo detectar coincidencias en las cuatro direcciones?

Una vez que tenemos la función para buscar en una dirección, podemos crear una función que use esta para encontrar coincidencias en las cuatro direcciones.

public List<Piece> GetMatchByPiece(int xPos, int yPos, int minPieces = 3) {
    var upMatch = GetMatchByDirection(xPos, yPos, new Vector2(0, 1), 2) ?? new List<Piece>();
    var downMatch = GetMatchByDirection(xPos, yPos, new Vector2(0, -1), 2) ?? new List<Piece>();
    var rightMatch = GetMatchByDirection(xPos, yPos, new Vector2(1, 0), 2) ?? new List<Piece>();
    var leftMatch = GetMatchByDirection(xPos, yPos, new Vector2(-1, 0), 2) ?? new List<Piece>();

    var verticalMatches = upMatch.Union(downMatch).ToList();
    var horizontalMatches = leftMatch.Union(rightMatch).ToList();

    var finalMatches = new List<Piece>();

    if (verticalMatches.Count >= minPieces) {
        finalMatches = finalMatches.Union(verticalMatches).ToList();
    }

    if (horizontalMatches.Count >= minPieces) {
        finalMatches = finalMatches.Union(horizontalMatches).ToList();
    }

    return finalMatches;
}

Para completar la detección de "Match3":

• Se implementan llamadas a GetMatchByDirection en todas las direcciones.
• Se inicializan listas vacías si no se encuentran coincidencias.
• Se unen coincidencias verticales y horizontales usando Union.
• Finalmente, se devuelven las coincidencias encontradas.

Con estas funciones, podrás detectar eficientemente coincidencias en juegos de tipo "Match3". Animate a implementar estas funcionalidades en tus propios proyectos de juegos y observa cómo mejoran la experiencia de juego. ¡El aprendizaje continuo y la práctica te seguirán impulsando hacia adelante!