Detectar combos automáticos en un juego Match 3 es lo que separa una mecánica básica de una experiencia satisfactoria. Aquí aprendes a implementar combos en Unity usando corrutinas, revisando recursivamente las piezas que se movieron tras cada match hasta que no queden coincidencias por resolver.

¿Por qué el juego no detecta los combos automáticos?

Cuando colapsas las piezas tras un primer match, las nuevas posiciones pueden generar coincidencias adicionales que el motor no está revisando. El jugador las ve, pero el código las ignora.

En la clase Board, la función ClearPieces se encarga de eliminar las piezas que coinciden y colapsar las columnas. El problema aparece justo después: nadie vuelve a revisar las piezas recién acomodadas. Por eso necesitas una función que, tras colapsar, busque nuevos matches y repita el proceso hasta agotarlos [01:00].

¿Qué es un combo en Match 3? Es una cadena de coincidencias que se generan automáticamente después de un primer match, cuando las piezas que caen forman nuevas alineaciones de tres o más sin que el jugador las provoque directamente.

¿Cómo crear la función FindMatchesRecursively en Unity?

La idea es encadenar la lógica de detección con el colapso de columnas para que se ejecute una y otra vez mientras existan combos.

Dentro de ClearPieces, después de obtener las columnas y colapsarlas, llamas a una nueva función llamada FindMatchesRecursively y le pasas la lista de piezas que se movieron al colapsar [01:30]. Esta función no hace el trabajo pesado: su única tarea es iniciar una corrutina con StartCoroutine, también llamada FindMatchesRecursively, que recibe esa misma lista de piezas.

La corrutina debe devolver un IEnumerable, ya que las corrutinas en Unity son funciones que se ejecutan a lo largo del tiempo y permiten pausar la lógica entre frames.

¿Por qué usar una corrutina y no un método normal?

Porque queremos darle al jugador un instante para ver qué está pasando antes de ejecutar el siguiente combo. Un match instantáneo se siente confuso; uno con ritmo se siente recompensante.

Lo primero dentro de la corrutina es esperar un segundo con yield return new WaitForSeconds(1). Ese pequeño respiro permite que la animación de caída termine y que el ojo registre la nueva configuración del tablero antes de que el sistema vuelva a actuar [02:30].

¿Cómo revisar piezas en busca de nuevos matches?

Después de la espera, creas una lista vacía llamada newMatches del tipo List<Piece>. Esta lista acumulará todas las coincidencias nuevas que detectes.

Luego recorres las piezas colapsadas con un foreach y, para cada una, usas la función ya existente GetMatchByPiece, pasándole las coordenadas de la pieza y el mínimo de piezas requerido, que sigue siendo tres. Si la función devuelve algo distinto de null, agregas esos resultados a newMatches usando el método Union, que combina ambas colecciones sin duplicados. Como Union devuelve un array, lo conviertes nuevamente a lista con ToList [03:20].

Dentro del mismo foreach, llamas a ClearPieces con los matches encontrados para eliminarlos del tablero. Así, en una sola pasada, detectas y limpias las nuevas coincidencias.

¿Qué hace el método Union en C#? Combina dos colecciones eliminando duplicados y devuelve un IEnumerable. En Unity lo usas para sumar listas de piezas sin repetir referencias.

¿Cómo encadenar combos con recursividad?

La magia está en el cierre del ciclo. Si después del foreach la lista newMatches tiene más de cero elementos, significa que hubo un combo y debes repetir todo el proceso.

Para eso, declaras una variable newCollapsedPieces y le asignas el resultado de CollapseColumns, la misma función que usaste en ClearPieces. Le pasas tres argumentos:

• La lista de columnas, obtenida con GetColumns aplicada sobre newMatches.
• Un tiempo de 0.3 segundos como segundo parámetro para la animación de caída.
• Las piezas que se movieron, que servirán para la siguiente iteración.

Luego vuelves a llamar a FindMatchesRecursively pasándole newCollapsedPieces. Eso desencadena la recursión: combo uno, combo dos, combo tres, hasta que ningún match aparezca y la cadena se detenga sola [04:40].

Para cerrar bien la corrutina, terminas con yield return null, asegurando que se rompa correctamente cuando ya no haya nada que ejecutar.

¿Cómo se ve el combo funcionando en Unity?

En pantalla, haces un match de tres monos. Las piezas desaparecen, un elefante cae una posición y se alinea con otros dos elefantes que ya estaban abajo. Pasa un segundo, el sistema detecta el nuevo match y lo ejecuta automáticamente como combo [05:30].

Esa pausa de un segundo no es decorativa: es la que le da legibilidad visual al combo y convierte una mecánica funcional en una experiencia satisfactoria.

Las corrutinas abren posibilidades enormes en otros géneros: secuencias de diálogo, animaciones por turnos, oleadas de enemigos, efectos en cadena. ¿Qué otra mecánica te gustaría resolver con corrutinas? Cuéntamelo en los comentarios.