Detectar un Match 3 en Unity requiere comparar piezas iguales en cuatro direcciones desde una posición inicial. Aquí aprendes a programar dos funciones en C# que escanean la cuadrícula y devuelven las coincidencias listas para usarse en la lógica del juego, ideal si ya estás construyendo un match-3 puzzle.

La idea es simple: una función busca piezas iguales en una sola dirección, y otra función reutiliza esa primera para revisar arriba, abajo, izquierda y derecha. Todo se implementa dentro de la clase Board.

¿Qué hace la función GetMatchByDirection en Unity?

Esta función recorre la cuadrícula desde una posición inicial siguiendo un vector de dirección y devuelve una lista con todas las piezas del mismo tipo que encuentra antes de toparse con una distinta o salirse del tablero [02:15].

La firma queda así: recibe int xPos, int yPos, Vector2 direction y un int minPieces con valor por defecto de 3. Retorna una List<Piece>.

¿Por qué el valor mínimo de piezas es 3? Porque un Match 3 requiere al menos tres piezas iguales alineadas. Si encuentras solo dos, no cuenta como coincidencia válida y la función devuelve null.

¿Cómo se itera en una sola dirección sin salirse de la cuadrícula?

Dentro de la función inicializas una lista vacía matches y agregas la startPiece (la pieza ubicada en xPos, yPos). Luego defines un maxValue con el mayor entre width y height usando un operador ternario.

El for loop arranca en i = 1 y avanza mientras i < maxValue. En cada iteración calculas la próxima posición con esta lógica:

• nextX = xPos + (int)direction.x * i.
• nextY = yPos + (int)direction.y * i.
• Validas que nextX y nextY estén dentro de [0, width) y [0, height).

Si la posición es válida, obtienes nextPiece desde el array bidimensional. Si no es nula y su pieceType coincide con el de startPiece, la agregas a matches. Si no coincide o es nula, ejecutas break para romper el loop [05:40].

¿Cuándo retornar la lista de matches?

Al salir del loop, comparas matches.Count contra minPieces. Si es mayor o igual, devuelves matches. Si no, devuelves null.

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

int nextX;
int nextY;
int maxValue = width > height ? width : height;

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

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

if (matches.Count >= minPieces)
    return matches;

return null;

}

¿Cómo combinar las cuatro direcciones con GetMatchesByPiece?

La segunda función, GetMatchByPiece, llama cuatro veces a GetMatchByDirection usando vectores distintos para cubrir arriba, abajo, derecha e izquierda [08:30].

Las direcciones se expresan como Vector2:

• Arriba: (0, 1).
• Abajo: (0, -1).
• Derecha: (1, 0).
• Izquierda: (-1, 0).

Aquí el minPieces que se pasa es 2, no 3. La razón es que una pieza puede tener una coincidencia arriba y otra abajo, sumando tres en total. Si exigieras tres por dirección, perderías ese tipo de match.

¿Qué pasa si una dirección no encuentra matches? GetMatchByDirection devuelve null. Para evitar errores, inicializas cada variable (upMatch, downMatch, rightMatch, leftMatch) con una lista vacía cuando sea null.

¿Por qué usar Union de System.Linq para fusionar listas?

Una vez tienes las cuatro listas, las combinas con el método Union de LINQ. Esto requiere agregar using System.Linq; al inicio del archivo.

Union tiene una ventaja clave: elimina duplicados automáticamente, así que una pieza que aparezca en varias direcciones solo se contará una vez. Como devuelve un array, le aplicas ToList() al final.

El flujo es:

• verticalMatches = upMatch.Union(downMatch).ToList().
• horizontalMatches = leftMatch.Union(rightMatch).ToList().
• Creas foundMatches como lista vacía de Piece.

¿Cómo decidir qué matches agregar al resultado final?

Antes de unir verticales y horizontales al resultado, validas que cada grupo cumpla con el mínimo. Si verticalMatches.Count >= minPieces, los agregas a foundMatches con Union. Lo mismo para horizontalMatches.

Finalmente retornas foundMatches, contenga elementos o esté vacía. Esa lista es la que tu juego usará para eliminar piezas y disparar la siguiente jugada [12:45].

Con estas dos funciones ya tienes el motor de detección listo. ¿En qué parte del flujo del juego planeas llamar GetMatchByPiece, justo después del swap o también al generar el tablero inicial? Cuéntamelo en los comentarios.