3.4 - Clonar, funciones y sprites "el juego de la vida de John Conway
3.4: El Juego de la Vida de Conway con clones
🎯 Objetivo de este tutorial
Vamos a implementar el Juego de la Vida de John Conway (1969), un autómata celular que simula la evolución de células en una cuadrícula. Aprenderás a:
Usar clones para crear una cuadrícula de celdas.
Gestionar el estado de cada celda (viva/muerta) con listas.
Calcular el número de vecinos de cada celda.
Aplicar las reglas de evolución para generar ciclos automáticos.
Visualizar la evolución con disfraces.
🧩 Paso 1: Entender el concepto
El Juego de la Vida es una simulación donde cada celda puede estar viva (negra) o muerta (transparente). En cada ciclo, el estado de cada celda depende del número de vecinos vivos que tenga (de las 8 celdas que la rodean).
Reglas estándar:
Una célula viva con 2 o 3 vecinos vivos sobrevive.
Una célula muerta con exactamente 3 vecinos vivos nace.
En cualquier otro caso, la célula muere o permanece muerta.
🌐 Curiosidad: Existen estudios científicos sobre los patrones que genera este autómata, ¡y algunos incluso tienen nombre propio (como el "planeador" o el "cañón de Gauss")!
🖼️ Paso 2: Preparar los disfraces
Crea un objeto (sprite) con dos disfraces:
Disfraz 1: "Vivo" – un cuadrado o círculo de color negro.
Disfraz 2: "Muerto" – completamente transparente (o blanco).
Este objeto será la "plantilla" para todos los clones. Cada clon cambiará de disfraz según su estado.
📊 Paso 3: Crear las variables y listas
Necesitaremos una serie de variables y listas globales:
| Variable/Lista | Uso |
|---|---|
tamañoX | Número de celdas en horizontal (ejemplo: 15). |
tamañoY | Número de celdas en vertical (ejemplo: 15). |
tamCelda | Tamaño en píxeles de cada celda (ejemplo: 16). |
numClon | Identificador único de cada clon (del 1 al total). |
inicioX, inicioY | Coordenadas donde empieza la cuadrícula. |
Lista juegoActual | Almacena el estado actual (0 = muerto, 1 = vivo) de todas las celdas. |
Lista juegoSiguiente | Almacena el estado calculado para el próximo ciclo. |
El total de celdas es
tamañoX * tamañoY(por ejemplo, 15×15 = 225 celdas).
🗺️ Paso 4: Generar el mapa inicial
Al presionar la bandera, debemos crear la cuadrícula con valores aleatorios (0 o 1).
Código en el objeto principal (no clon):
al presionar bandera
borrar lista [juegoActual]
fijar [tamañoX] a [15]
fijar [tamañoY] a [15]
fijar [tamCelda] a [16]
// Generar mapa aleatorio
repetir (tamañoX * tamañoY) veces
añadir (número al azar entre (0) y (1)) a [juegoActual]
// Calcular punto de inicio para centrar la cuadrícula
fijar [inicioX] a (redondear ((tamañoX * tamCelda) / -2)) // Ej: -120
fijar [inicioY] a (redondear ((tamañoY * tamCelda) / -2)) // Ej: -120
// Crear clones
fijar [numClon] a [1]
repetir (tamañoX * tamañoY - 1) veces
crear clon de [este objeto]
cambiar [numClon] por (1)
esperar [0.5] segundos // Para evitar sobrecargaEl
esperares necesario porque si creamos todos los clones a la vez, pueden solaparse y no dar tiempo a ejecutar sus códigos correctamente.
🧬 Paso 5: Código del clon (al comenzar como clon)
Cada clon se posiciona en la cuadrícula y se mantiene actualizando su estado.
al comenzar como clon
// Calcular posición X e Y según su número
fijar [posX] a (inicioX + ((numClon - 1) mod tamañoX) * tamCelda + (tamCelda / 2))
fijar [posY] a (inicioY + (redondear ((numClon - 1) / tamañoX)) * tamCelda + (tamCelda / 2))
ir a x: (posX) y: (posY)
// Bucle principal del clon
por siempre
// Cambiar disfraz según el estado en la lista
si <(elemento (numClon) de [juegoActual]) = [1]> entonces
cambiar disfraz a [Vivo]
sino
cambiar disfraz a [Muerto]
esperar [0.1] segundos // Para no saturar
numClones el identificador único (del 1 al total). Con él accedemos a la listajuegoActualpara saber si está vivo o muerto.
🔁 Paso 6: El ciclo de evolución (calcular siguiente generación)
Este código se ejecuta al hacer clic en un botón "Siguiente ciclo" o de forma automática. Calcula el nuevo estado de todas las celdas.
Pasos:
Borrar la lista
juegoSiguiente.Recorrer todas las celdas (filas y columnas).
Para cada celda, contar cuántos vecinos vivos tiene.
Aplicar las reglas para decidir si vive o muere en el siguiente ciclo.
Al final, copiar
juegoSiguientesobrejuegoActual.
Código (bloque personalizado):
definir calcularSiguiente
borrar lista [juegoSiguiente]
fijar [indice] a [1]
repetir (tamañoY) veces // Filas
repetir (tamañoX) veces // Columnas
fijar [vecinos] a [0]
// Vecinos (usando el índice actual)
// Arriba izquierda: indice - tamañoX - 1
// Arriba: indice - tamañoX
// Arriba derecha: indice - tamañoX + 1
// Izquierda: indice - 1
// Derecha: indice + 1
// Abajo izquierda: indice + tamañoX - 1
// Abajo: indice + tamañoX
// Abajo derecha: indice + tamañoX + 1
// Sumar vecinos vivos (solo si existen y están dentro de la cuadrícula)
// ... (8 comprobaciones similares)
// Aplicar reglas
si <(vecinos) = [3]> entonces
añadir [1] a [juegoSiguiente] // Nace o sigue vivo
sino
si <(vecinos) = [2] y (elemento (indice) de [juegoActual]) = [1]> entonces
añadir [1] a [juegoSiguiente] // Sobrevive
sino
añadir [0] a [juegoSiguiente] // Muere o sigue muerto
fin
fin
cambiar [indice] por (1)
fin
fin
// Copiar juegoSiguiente a juegoActual
fijar [i] a [1]
repetir (longitud de [juegoSiguiente]) veces
reemplazar elemento (i) de [juegoActual] por (elemento (i) de [juegoSiguiente])
cambiar [i] por (1)Atención: En Scratch, para acceder a los vecinos debes comprobar que no te salgas de los bordes (ej: si estás en la primera columna, no tienes vecino izquierdo).
🧮 Paso 7: Calcular vecinos (versión simplificada)
Dentro del bucle de celdas, usamos el índice actual (indice) para acceder a los vecinos:
// Vecino arriba (solo si no estamos en la primera fila)
si <(indice) > (tamañoX)> entonces
sumar a vecinos (elemento (indice - tamañoX) de [juegoActual])
fin
// Vecino abajo (solo si no estamos en la última fila)
si <(indice) <= (tamañoX * (tamañoY - 1))> entonces
sumar a vecinos (elemento (indice + tamañoX) de [juegoActual])
fin
// ... similar para los demásPara los vecinos diagonales, suma o resta
tamañoX + 1otamañoX - 1.
🟢 Paso 8: Botón para avanzar ciclos automáticamente
Crea un botón que, al hacer clic, ejecute el bloque calcularSiguiente repetidamente.
al hacer clic en este objeto
por siempre
calcularSiguiente
esperar [1] segundos // Para que se vea la evoluciónPuedes detenerlo con el botón rojo de Scratch o con un condicional.
✅ Resumen del tutorial 3.3
| Concepto | Aplicación en el proyecto |
|---|---|
| Clones | Cada celda de la cuadrícula es un clon del objeto original. |
| Listas | juegoActual y juegoSiguiente almacenan el estado de todas las celdas (0 o 1). |
| Identificación | La variable numClon identifica cada clon (1 al total). |
| Posicionamiento | Se calcula con inicioX, inicioY, tamCelda y el índice del clon. |
| Vecinos | Se calculan restando o sumando tamañoX al índice. |
| Reglas | Una célula viva con 2-3 vecinos sobrevive; una muerta con 3 vecinos nace. |
| Ciclos | Se calcula el siguiente estado en juegoSiguiente y se copia a juegoActual. |
🧠 Ampliaciones y curiosidades
Patrones famosos: Investiga el "planeador" (glider) o el "cañón de Gauss" (Gosper glider gun) que generan comportamientos complejos.
Cambiar reglas: Modifica los números (2, 3) para crear variantes del juego.
Velocidad: Ajusta el tiempo de espera entre ciclos para ver la evolución más rápido o más lento.
Tamaño: Cambia
tamañoXytamañoYpara cuadrículas más grandes (ej: 30×30).
Este proyecto es un ejemplo perfecto de cómo Scratch puede usarse para simulaciones científicas complejas, combinando clones, listas y lógica matemática. ¡Anímate a experimentar y a descubrir los patrones que genera tu propio "mundo"
Comentarios
Publicar un comentario