Arreglar bug de tripletes en tablero Candy Crush
Clase 13 de 31 • Curso de Desarrollo de Videojuegos para Móviles con Unity
Contenido del curso
Sprite Atlas y Generación de Caramelos
- 5

Sprite Editor y cámaras en Unity para móviles
11:53 min - 6

Sprites múltiples en Unity con slice automático
12:06 min - 7

Script base de Candy en Unity C#
10:57 min - 8

Configuración y Gestión del Tablero en Unity con C#
10:08 min - 9

Inicializar tablero 2D con bucles anidados
10:27 min - 10

Configuración de slice por tamaño en Unity
05:22 min - 11

Creación y Configuración de Tablero en Unity para Videojuegos
08:22 min - 12

Sprites aleatorios de prefabs en Unity
07:18 min
Diseño de Game Play
- 13

Arreglar bug de tripletes en tablero Candy Crush
Viendo ahora - 14

OnMouseDown para seleccionar caramelos
12:14 min - 15

Swap de caramelos sin mover GameObject
10:17 min - 16

Configuración de Física en Unity para Movimiento de Caramelos
13:30 min - 17

Detección y Eliminación de Coincidencias en Candy Crush
12:06 min - 18

Anular sprites en lugar de destruir objetos
15:26 min - 19

Caída en cascada para match-3 con corrutinas
13:23 min - 20

Generar caramelos sin crear matches accidentales
09:09 min - 21

Último bug visual: rebotes y recálculos
10:55 min
Retos finales
- 22

Diseño de Interfaz Gráfica en Unity para Videojuegos
11:20 min - 23

Variables autocomputadas en Unity GUI Manager
07:31 min - 24

Implementación de Singleton en Gestor de Interfaz de Usuario
08:13 min - 25

Corrutinas para pantalla Game Over sin interrupciones
06:55 min - 26

Multiplica puntuación con combos inteligentes
04:46 min - 27

Integra tres audios en tu videojuego de caramelos
01:47 min - 28

Animación y Destrucción de Caramelos en Videojuegos
02:00 min - 29

Menú principal para tu videojuego móvil
03:28 min
Cierre del curso
Aprende a inicializar un tablero tipo Candy Crush en Unity sin tripletes desde el primer fotograma. Aquí verás cómo combinar un doble bucle, comparar vecinos estratégicamente y usar un bucle do-while para garantizar variedad, además de mantener la jerarquía limpia con Board Manager.
¿Cómo evitar tripletes al iniciar el tablero en Unity?
Evitar tres caramelos iguales contiguos desde el inicio mejora el gameplay y evita ventajas injustas. La clave es comparar el caramelo actual con el vecino de abajo y el vecino de la izquierda mientras generas el tablero por columnas de abajo hacia arriba.
- Genera por columnas, de abajo a arriba, y luego la siguiente columna.
- Compara solo abajo e izquierda: derecha y arriba aún no existen lógicamente.
- Usa hasta seis tipos: hay variedad suficiente sin forzar repeticiones.
- Controla el flujo con un do-while que reintenta el índice si coincide con un vecino.
¿Qué patrón de recorrido y vecinos usar?
- Recorre columnas (x) y luego filas (y) de abajo a arriba.
- Compara el id actual con: candies[x-1, y] (izquierda) y candies[x, y-1] (abajo).
- Evita comparar fuera de límites: usa x > 0 e y > 0.
¿Cómo se implementa el do-while con Random.Range y prefabs.Count?
Este patrón asegura al menos una asignación y reintenta si hay choque con vecinos. Usa Random.Range y el tamaño de prefabs.Count para elegir un índice válido.
int idx = -1; // identificador provisional
// Dentro del doble bucle (x columnas, y filas):
do
{
idx = Random.Range(0, prefabs.Count);
}
while (
(x > 0 && idx == candies[x - 1, y].GetComponent<Candy>().id) ||
(y > 0 && idx == candies[x, y - 1].GetComponent<Candy>().id)
);
// Usa idx para instanciar y configurar el caramelo sin volver a randomizar.
var newCandy = Instantiate(prefabs[idx], /* posición y rotación */);
// newCandy.GetComponent<SpriteRenderer>().sprite = ... // asigna el sprite si aplica.
newCandy.GetComponent<Candy>().id = idx; // asigna el identificador único.
candies[x, y] = newCandy; // guarda en la matriz.
¿Cómo asignar el prefab, el sprite y el id sin duplicar?
- No vuelvas a llamar a Random.Range tras validar: reutiliza idx.
- Con idx obtienes el prefab y su sprite correspondiente.
- Asigna el id al componente Candy: es la referencia única para comparar vecinos.
¿Por qué el id y la matriz candies aseguran variedad?
El id único por caramelo es la forma fiable de comparar tipos. La matriz candies[x, y] guarda cada instancia en su posición, permitiendo consultar vecinos ya creados. Así, por construcción, no habrá dos iguales consecutivos en filas o columnas al iniciar.
- El id vive en el componente Candy: comparación directa y rápida.
- La matriz es la “verdad” del tablero: consulta inmediata de izquierda y abajo.
- Con el do-while, solo aceptas un idx si no coincide con vecinos ya existentes.
¿Qué condiciones de borde considerar en la primera columna y fila?
- Primera columna: x == 0, no hay vecino a la izquierda.
- Primera fila: y == 0, no hay vecino abajo.
- Condición booleana compuesta con OR: evalúa coincidencia con izquierda o abajo si x > 0 o y > 0.
bool coincideIzquierda = (x > 0) && (idx == candies[x - 1, y].GetComponent<Candy>().id);
bool coincideAbajo = (y > 0) && (idx == candies[x, y - 1].GetComponent<Candy>().id);
bool repetir = coincideIzquierda || coincideAbajo;
¿Cómo ordenar la jerarquía con el Board Manager para trabajar mejor?
Mantener los caramelos como hijos del Board Manager limpia la jerarquía y agiliza el trabajo en el editor. Así despliegas o colapsas todos los hijos desde un solo nodo y localizas más fácil otros objetos como cámara y fondo.
- Jerarquía limpia: menos ruido en el panel lateral.
- Organización lógica: todo el tablero depende del Board Manager.
- Operaciones en lote: mover, activar o desactivar ramas completas.
¿Qué línea de código hace a los caramelos hijos del tablero?
Basta con establecer el padre de la transform del caramelo al transform actual del Board Manager.
newCandy.transform.parent = this.transform; // jerarquiza el caramelo bajo el Board Manager
¿Te gustaría ver otras validaciones iniciales o variantes del patrón de generación? Comparte tus dudas y propuestas en los comentarios.