100 Días de Código en Python — Día 95: Proyecto de portafolio — Space Invaders con turtle

📝 Contenido original del curso#

Usando Python Turtle, construye el clásico juego de disparos Space Invaders. (El enunciado enlaza la página de Wikipedia del juego.)

Tu nave espacial puede moverse a la izquierda y a la derecha y puede disparar a algunas naves alienígenas. Cada segundo, los alienígenas se acercan a tu nave. Cuando los alienígenas tocan tu nave, se acaba el juego (game over). Normalmente hay algunas barreras entre tú y los alienígenas que te ofrecen posiciones defensivas.

Puedes jugarlo en elgoog.im/space-invaders.

Pregunta de la tarea — Momento de reflexión: cómo abordaste el proyecto; qué fue difícil y qué fácil; cómo mejorarías; tu mayor aprendizaje; qué harías distinto.

Prerequisitos: turtle, eventos de teclado y tracer/update (Días 18–20); herencia (Día 21); Pong, Turtle Crossing y Breakout (Días 22, 23 y 87); listas y comprensión de listas (Días 4 y 26).

🔍 Antes de programar#

Juega 5 minutos y escribe la especificación. Ejemplo (el tuyo puede ser distinto):

OBJETOS: Nave, Alien (muchos, en formación), Bala (de la nave), Bala enemiga,
         Barrera (varios bloques), Marcador
REGLAS:
  - La nave se mueve ← → sin salir de la pantalla y dispara con espacio.
  - Solo una bala de la nave en pantalla a la vez (como en el original).
  - La flota se mueve de lado a lado; al tocar un borde, TODA baja y cambia de dirección.
  - Bala que toca un alien: ambos desaparecen, suma puntos.
  - Los aliens disparan al azar hacia abajo.
  - Bala (de cualquiera) que toca una barrera: la barrera pierde un "trozo".
  - Game over si una bala enemiga toca la nave (y se acaban las vidas)
    o si un alien llega a la altura de la nave.
  - Victoria (o siguiente nivel) si no quedan aliens.

Lista de tareas sugerida: ventana y ciclo → nave → disparo → flota estática → flota en movimiento → impactos → disparos enemigos → barreras → vidas y marcador → fin del juego.

💡 Compara con el Breakout (Día 87): la bala es como la pelota (pero va en línea recta y desaparece); los alienígenas son como los ladrillos (pero se mueven). Reutiliza lo que puedas.

🎯 Objetivo de aprendizaje#

Mover un grupo de objetos de forma coordinada, tomando decisiones sobre el grupo, no sobre cada objeto por separado.

📖 Explicación conceptual#

Si cada alienígena revisara su propio borde, el de la derecha bajaría y los demás seguirían avanzando: la formación se deshace. Verificado con una versión con error: dos aliens en x = 280 y x = 230 terminan en [(280, 180), (240, 200)], a alturas distintas.

La decisión correcta se toma para toda la flota: si el alien que está más a la derecha (o más a la izquierda) va a salirse, todos bajan y todos cambian de dirección.

🔎 Ejemplo explicado#

BORDE = 280

def mover_flota(posiciones, direccion, paso=10, bajada=20):
    if not posiciones:
        return posiciones, direccion
    xs = [x for x, _ in posiciones]
    if max(xs) + paso * direccion > BORDE or min(xs) + paso * direccion < -BORDE:
        return [(x, y - bajada) for x, y in posiciones], -direccion
    return [(x + paso * direccion, y) for x, y in posiciones], direccion

• Trabaja con tuplas de posiciones, no con tortugas: se prueba sin ventana. En el juego, aplicarías las nuevas posiciones con alien.goto(x, y).
• direccion es 1 (derecha) o -1 (izquierda): multiplicar por ella evita escribir dos casos.
• Se revisa la próxima posición (max(xs) + paso * direccion) para no salirse ni un paso.
• if not posiciones evita el error de max() con una lista vacía (cuando no quedan aliens).

Verificado: 5 aliens entre −100 y 100 avanzan 18 pasos; en el paso 19 bajan de y = 200 a y = 180 y la dirección pasa a −1; en el siguiente paso el de la derecha va de 280 a 270.

¿"Cada segundo"?#

El enunciado dice que los aliens se acercan cada segundo, pero el ciclo del juego se repite muchas veces por segundo (para que la nave y las balas se muevan suave). Solución: mover la flota solo cada cierto número de cuadros, o con un temporizador aparte (screen.ontimer(mover, 1000)). En el original, la flota acelera a medida que quedan menos aliens: ¿cómo lo harías?

Balas#

• Una bala a la vez: si ya hay una bala de la nave en pantalla, la barra espaciadora no hace nada. Esto hace el juego más estratégico y simplifica el código.
• Balas que salen de la pantalla: ocúltalas y quítalas de la lista (o reutilízalas). Si solo las ocultas, la lista crece sin fin y el juego se vuelve lento.

Impactos#

Usa la idea de colisión rectangular del Breakout (Día 87): comparar la distancia en cada eje con la suma de los "medios tamaños". Y aplica la regla de oro: no eliminar de una lista mientras la recorres; recorre una copia o marca los eliminados y bórralos después.

Barreras con "vida"#

Dos enfoques:

Alcanzar la nave#

def alcanzo_nave(posiciones, y_nave=-250, margen=20):
    return any(y <= y_nave + margen for _, y in posiciones)

any(...) devuelve True si al menos un alien cumple la condición (verificado: un alien en y = −240 → True; en y = 0 → False).

⚠️ Errores frecuentes#

Problema#

Construir Space Invaders con Python turtle.

Contexto#

Continúa la "semana de juegos clásicos" (Día 87): cada grupo presenta un segundo juego, esta vez con muchos objetos en movimiento.

Objetivo#

Un Space Invaders jugable, con flota en formación, disparos de ambos lados, barreras, vidas y marcador.

Requisitos funcionales#

1. Nave que se mueve ← → con límites y dispara con espacio.
2. Flota de al menos 3 filas × 8 columnas que se mueve en bloque y baja al tocar un borde.
3. Impactos de balas en aliens (con puntos) y en barreras.
4. Game over si los aliens alcanzan la nave o si se acaban las vidas; victoria si no quedan aliens.

Restricciones técnicas#

• Clases en archivos separados (nave.py, flota.py, barrera.py, marcador.py).
• Movimiento de la flota y colisiones en funciones puras probadas.
• Sin copiar un tutorial de Space Invaders (mismo principio del Día 87).

Planificación#

La especificación de la sección 2 es tu plan. Añade: probar cada tarea antes de marcarla; corregir; mejorar con los retos.

Construcción paso a paso#

• Versión 1 — Nave: ventana, ciclo y nave con límites.
• Versión 2 — Disparo: una bala a la vez, que desaparece al salir.
• Versión 3 — Flota: formación estática; luego, movimiento en bloque.
• Versión 4 — Impactos: balas contra aliens, puntos.
• Versión 5 — Contraataque: disparos enemigos al azar (random.choice de los aliens de la fila inferior de cada columna), vidas.
• Versión 6 — Barreras.
• Versión final: fin del juego, reinicio, README.md con GIF y diario.

Pruebas#

🧪 Prueba y depuración#

for alien in aliens:
    if alien.xcor() > 280 or alien.xcor() < -280:
        direccion *= -1
        alien.sety(alien.ycor() - 20)
    alien.setx(alien.xcor() + 10 * direccion)

Encuentra tres problemas: solo baja el alien que tocó el borde (la formación se rompe); la dirección puede cambiar varias veces en la misma vuelta si varios aliens están en el borde; y los aliens ya recorridos se movieron con la dirección anterior.

⭐ Extensión del proyecto#

• 🟢 Reto 1 — Aplicación: la flota acelera a medida que quedan menos aliens.
• 🟡 Reto 2 — Ampliación: la nave misteriosa (OVNI) que cruza la parte superior de vez en cuando y da puntos al azar.
• 🟠 Reto 3 — Desafío: barreras de bloques que se "desmoronan" de forma realista (el bloque golpeado y, a veces, un vecino).
• 🔴 Reto 4 — Pensamiento computacional: niveles con formaciones distintas leídas desde archivos de texto, y una dificultad que se ajusta al jugador (si pierde rápido, el siguiente intento es un poco más fácil). Diseña la regla de ajuste y justifica por qué es justa.

Situación#

Los páramos colombianos producen buena parte del agua que llega a muchas ciudades. El grupo ecológico quiere un juego que muestre sus amenazas: desde arriba descienden "amenazas" (incendios, basura, ganadería no controlada, minería ilegal) hacia los frailejones de la parte inferior.

Requisitos#

1. Reutiliza la estructura de tu Space Invaders: las amenazas bajan en formación.
2. El jugador elige la "herramienta" adecuada para cada amenaza (por ejemplo, 1 = agua, 2 = recolección, 3 = vigilancia), con disparos de color distinto; solo la correcta elimina la amenaza.
3. Al final, una pantalla con un dato real sobre cada amenaza, con su fuente (investiga en fuentes confiables).

Decisiones que debes tomar (y justificar)#

• ¿Cómo muestras qué herramienta sirve para qué amenaza sin que el juego sea solo adivinar?
• ¿Cómo evitas que el juego trivialice un problema serio?

Casos de prueba#

• Herramienta incorrecta: la amenaza sigue.
• Un frailejón alcanzado desaparece; si se pierden todos, el juego termina.

Conceptuales#

1. ¿Qué diferencia hay entre herencia y composición? Da un ejemplo de cada una en este juego.
2. ¿Por qué la decisión de bajar debe tomarse para toda la flota?
3. ¿Por qué hay que eliminar de la lista las balas que salen de la pantalla?
4. ¿Qué hace any()?

Análisis de código#

xs = [x for x, _ in posiciones]

¿Qué contiene xs? ¿Qué significa el _?

Predicción#

Con BORDE = 280, una flota cuyo alien más a la derecha está en x = 275 y direccion = 1, paso = 10: ¿qué hace mover_flota?

Depuración#

"Cuando elimino al último alien, el juego se cierra con ValueError: max() arg is an empty sequence." ¿Dónde y cómo lo corriges?

Modificación#

Cambia mover_flota para que el paso aumente cuando quedan menos de 10 aliens.

Creación#

Escribe aliens_que_pueden_disparar(posiciones) que devuelva, para cada columna (misma x), solo el alien de más abajo.