100 Días de Código en Python — Día 23: Proyecto Final "Turtle Crossing" (Cruce de la Tortuga)

🔍 Antes de programar (actividad de diseño)#

Antes de abrir cualquier archivo, responde en papel:

• Entradas: ¿qué hace el usuario?
• Objetos: ¿qué objetos hay en pantalla? ¿Cuántos de cada uno?
• Estado: ¿qué datos cambian durante el juego (nivel, velocidad, posiciones)?
• Condiciones de fin: ¿cuándo termina el juego?
• Dibuja la pantalla con las coordenadas de: la salida de la tortuga, la meta, la zona donde aparecen los autos y el marcador.

📝 Ejercicio original del curso#

Enunciado: la tortuga aparece abajo en el centro, mirando al Norte, y avanza una distancia fija cada vez que se pulsa ↑.

Solución del curso (en palabras):

• class Player(Turtle): con super().__init__().
• shape("turtle"), penup(), goto(STARTING_POSITION) (una tupla) y setheading(90).
• Método go_up(): self.forward(MOVE_DISTANCE). Como la tortuga mira al Norte, avanzar es subir.
• En main.py: screen.listen() y screen.onkey(player.go_up, "Up"), sin paréntesis (Día 19).

Buena práctica que destaca el curso: usar la constante MOVE_DISTANCE permite cambiar el juego desde la parte superior del archivo, sin buscar dentro del código.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: agrega la tecla ↓ para retroceder, pero sin salir por debajo de la posición inicial.
• 🟡 Reto 2: permite moverse a los lados con ← y →, sin salir de la ventana.
• 🟠 Reto 3: cuenta cuántos pasos da el jugador en total y muéstralo al terminar el juego.
• 🔴 Reto 4: ¿qué pasa si el jugador mantiene presionada ↑? Recuerda lo aprendido sobre onkey y onkeypress en el Día 22 y decide cuál es más justo para este juego.

📝 Ejercicio original del curso#

Enunciado: crear autos de 20 × 40 píxeles, de colores aleatorios, que aparezcan en el borde derecho a una altura aleatoria y se muevan hacia la izquierda a velocidad constante.

🔍 Antes de programar#

• ¿CarManager es un auto o maneja muchos autos? ¿Debe heredar de Turtle?
• ¿Cómo estiras un cuadrado de 20 × 20 para que mida 40 de largo?
• ¿Entre qué valores de Y deben aparecer los autos para dejar espacio libre a la salida y a la llegada?

Solución del curso, paso a paso#

1. CarManager no hereda de Turtle: tiene una lista self.all_cars = [] (composición, como la serpiente del Día 21).
2. create_car() crea un auto nuevo:
   • Turtle("square"), penup() y color(random.choice(COLORS)).
   • shapesize(stretch_wid=1, stretch_len=2) → 20 de alto × 40 de largo.
   • random_y = random.randint(-250, 250): deja espacio libre arriba y abajo.
   • goto(300, random_y) y self.all_cars.append(new_car).
3. move_cars() recorre la lista y hace car.backward(STARTING_MOVE_DISTANCE). Los autos miran al Este, así que retroceder los lleva a la izquierda.
4. En el bucle del juego: car_manager.create_car() y car_manager.move_cars().

Los errores que el propio curso encuentra:

• El método se llamaba create_cars (plural), pero crea un solo auto: se renombra a create_car. Los nombres deben decir la verdad.
• Primero estiró el ancho en lugar del largo y aparecieron "formas raras". Se corrigió a stretch_wid=1, stretch_len=2.
• Demasiados autos: se creaba uno cada 0,1 s y era imposible cruzar.

📖 La solución de la probabilidad: "lanzar un dado"#

def create_car(self):
    random_chance = random.randint(1, 6)
    if random_chance == 1:
        # ... crear el auto ...

En cada vuelta del bucle se "lanza un dado" y solo se crea un auto si sale 1.

🛠️ Nota técnica: en la lección se dice que esto "garantiza" un auto cada seis vueltas y luego se aclara que hay probabilidad de por medio. La forma precisa de decirlo es: la probabilidad de crear un auto en cada vuelta es 1/6, así que en promedio aparece un auto cada 6 vueltas (unos 0,6 segundos). Puede haber dos autos seguidos o 20 vueltas sin ninguno.

Frase del curso para recordar: "Hay un millón de formas diferentes de resolver este problema. Mientras funcione, la forma que elijas será la mejor."

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: cambia el "dado" a 1 entre 3 y a 1 entre 10. ¿Cómo cambia la dificultad?
• 🟡 Reto 2: en lugar de alturas aleatorias libres, crea carriles fijos (por ejemplo, cada 40 píxeles) y elige uno al azar.
• 🟠 Reto 3: haz que la probabilidad de aparición aumente con el nivel.
• 🔴 Reto 4: simula sin ventana 10 000 vueltas del bucle con random.randint(1, 6) y cuenta cuántos autos se crean. ¿Se acerca a 10 000 / 6? ¿Cuál fue la racha más larga sin autos?

📝 Ejercicio original del curso#

Enunciado: detener el juego cuando la tortuga choca con un auto.

Solución del curso:

for car in car_manager.all_cars:
    if car.distance(player) < 20:
        game_is_on = False

Además, screen.exitonclick() al final para que la ventana no se cierre y se pueda ver el choque.

🛠️ Nota técnica (análisis de esta adaptación): es el mismo problema del Día 22. distance < 20 es un círculo de radio 20 alrededor del centro del auto, pero el auto es un rectángulo de 40 × 20. Si la tortuga toca la punta delantera o trasera del auto, la distancia entre centros puede ser de 20 a 30 píxeles: la tortuga parece chocar, pero el juego no lo detecta. Además, la tortuga avanza de a varios píxeles por pulsación. Una detección más fiel compara los ejes por separado: la diferencia en X menor que la mitad del largo del auto más la mitad de la tortuga, y lo mismo en Y.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: imprime en la consola la distancia exacta en el momento del choque. Juega 5 partidas y anota los valores.
• 🟡 Reto 2: implementa la detección rectangular como método Player.choca_con(car).
• 🟠 Reto 3: agrega 3 vidas: al chocar, la tortuga vuelve al inicio y pierde una vida.
• 🔴 Reto 4: después de chocar, la tortuga es invulnerable durante 2 segundos y parpadea (alterna showturtle y hideturtle). ¿Cómo mides el tiempo dentro del bucle?

📝 Ejercicio original del curso#

Enunciado: cuando la tortuga llega arriba (Y > 280), vuelve al inicio y los autos se mueven más rápido.

Solución del curso:

1. En Player, un método que devuelve un booleano:

def is_at_finish_line(self):
    if self.ycor() > FINISH_LINE_Y:
        return True
    else:
        return False

2. En Player, el método go_to_start(). El curso nota que goto(STARTING_POSITION) aparece dos veces (en __init__ y aquí) y lo reemplaza en __init__ por self.go_to_start(): evitar código repetido.
3. En CarManager: un atributo self.car_speed = STARTING_MOVE_DISTANCE, que ahora se usa en move_cars(), y un método level_up() que hace self.car_speed += MOVE_INCREMENT.
4. En main.py: si player.is_at_finish_line(), entonces player.go_to_start() y car_manager.level_up().

Mejora de legibilidad (alternativa válida): una comparación ya es un booleano, así que is_at_finish_line puede escribirse en una línea: return self.ycor() > FINISH_LINE_Y. Las dos versiones funcionan igual; la segunda es más corta y la usan mucho los programadores con experiencia.

¿Por qué la velocidad es un atributo y no la constante? La constante es el valor inicial. El atributo es el estado actual, que cambia durante el juego (Día 19).

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: cambia MOVE_INCREMENT a 3. Juega hasta el nivel 5. ¿Es mejor la progresión?
• 🟡 Reto 2: en lugar de sumar, multiplica la velocidad por 1,3 en cada nivel. Calcula en una tabla la velocidad de los niveles 1 a 8 con los dos métodos.
• 🟠 Reto 3: al subir de nivel, elimina los autos que ya salieron de la pantalla.
• 🔴 Reto 4: diseña una fórmula de dificultad que combine velocidad y frecuencia de aparición, y justifica por qué el juego sigue siendo posible de ganar en el nivel 10.

📝 Ejercicio original del curso#

Enunciado: mostrar el nivel en la esquina superior izquierda y "GAME OVER" en el centro al chocar.

Solución del curso (mismo patrón de los Días 21 y 22):

• Scoreboard(Turtle) con self.level = 1, hideturtle() y penup().
• update_scoreboard(): clear(), goto(-280, 250) aproximadamente (el curso ajustó la altura probando) y write(f"Level: {self.level}", align="left", font=FONT).
• increase_level(): suma 1 y llama update_scoreboard().
• game_over(): goto(0, 0) y escribe "GAME OVER" centrado sin borrar, para que se siga viendo el nivel alcanzado.

Recordatorio del orden: penup → goto → write. Si mueves la tortuga después de escribir, el texto no se mueve.

Invitación del curso: si este proyecto te costó, vuelve a construir la serpiente y el Turtle Crossing desde cero, mirando solo cómo funciona el juego. "A partir de aquí, las cosas se volverán más complejas."

Problema#

Integrar los pasos 3 a 7 en un juego completo y probado.

Contexto#

Es tu proyecto final del bloque de Turtle. Al terminarlo, habrás construido tres juegos (Serpiente, Pong y Turtle Crossing) con la misma estructura: clases que heredan de Turtle, un administrador de objetos y un bucle de juego.

Requisitos funcionales#

1. Tortuga que avanza con ↑.
2. Autos aleatorios de colores que cruzan de derecha a izquierda.
3. GAME OVER al chocar.
4. Al cruzar: vuelve al inicio, los autos aceleran y el nivel sube.
5. El nivel siempre visible.

Restricciones técnicas#

Usar el código inicial con sus cuatro archivos; Player y Scoreboard heredan de Turtle; CarManager usa composición.

Planificación: diagrama de flujo del bucle del juego#

┌─► update() y sleep(0.1)
│        │
│   ¿sale 1 en el dado? ── sí ──► crear auto
│        │
│   mover todos los autos
│        │
│   ¿algún auto choca con la tortuga? ── sí ──► GAME OVER ──► fin
│        │ no
│   ¿la tortuga cruzó la meta? ── sí ──► volver al inicio, acelerar autos, subir nivel
│        │
└────────┘

Este es el "diagrama de flujo" del que habla el curso en el mensaje de cierre: piensa la lógica antes de escribirla.

Pruebas#

🧪 Prueba y depuración: el juego que se vuelve lento#

En la versión del curso, los autos que salen por la izquierda nunca se eliminan de all_cars. Hagamos la cuenta:

• En cada vuelta, la probabilidad de crear un auto es 1/6.
• Si alguien juega 5 minutos, a 10 vueltas por segundo, son unas 3000 vueltas → unos 500 autos en la lista.
• En cada vuelta, move_cars() mueve los 500, aunque casi todos ya estén fuera de la pantalla y nadie los vea. Y el choque se revisa con los 500.

Actividad:

1. Agrega un print(len(car_manager.all_cars)) al bucle y juega 2 minutos. Anota cómo crece el número.
2. Corrige el problema: cuando un auto tenga xcor() < -320, ocúltalo con hideturtle() y sácalo de la lista. *(Cuidado: no elimines elementos de una lista mientras la recorres con for; recorre una copia con all_cars[:], el *slicing* del Día 21.)*
3. Vuelve a medir y compara.

⭐ Extensión del proyecto#

• Autos de distintos tamaños (motos, buses) con stretch_len aleatorio.
• Carriles que van en sentidos opuestos.
• Guardar el nivel récord (¡lo aprenderemos mañana, Día 24!).
• Personalizar colores y formas, y compartir una captura, como propone el curso.

Situación#

Los páramos colombianos son "fábricas de agua". En este juego, un frailejón (el jugador) se mueve de izquierda a derecha en la parte baja de la pantalla para atrapar gotas de agua que caen, y debe esquivar la basura que cae también.

Requisitos#

1. Frailejon(Turtle): se mueve con ← y → sin salir de la ventana.
2. Una superclase Objeto(Turtle) y dos subclases: Gota(Objeto) y Basura(Objeto), con la probabilidad de aparición como constante de cada clase.
3. Un CieloManager (composición) que crea objetos en la parte superior con un "dado", los mueve hacia abajo y elimina los que salen de la pantalla.
4. Atrapar una gota: +1 litro. Tocar basura: −1 vida (3 vidas).
5. Cada 10 litros, sube el nivel y los objetos caen más rápido.
6. Marcador con litros, vidas y nivel. GAME OVER con el total de litros "protegidos".

Decisiones que debes tomar#

• ¿Qué parte del Turtle Crossing puedes reutilizar casi sin cambios?
• ¿Cómo haces que la dificultad crezca de forma justa?

Reflexión#

Escribe dos líneas sobre qué aprendiste del páramo investigando para tu juego.

Situación problema#

Para la feria de tecnología del colegio, cada estudiante presentará un juego arcade original, diseñado y programado desde cero con Turtle.

Pregunta orientadora#

¿Cómo diseñar un juego propio aplicando las mismas estructuras de la serpiente, Pong y Turtle Crossing, pero con una idea nueva?

Requerimientos#

1. Documento de diseño (antes de programar, máximo una página): idea, reglas, controles, condiciones de victoria y derrota, y un boceto de la pantalla con coordenadas.
2. Al menos 3 clases propias, de las cuales al menos 2 heredan de Turtle y 1 usa composición (un administrador de objetos).
3. Al menos una jerarquía de herencia de dos niveles (por ejemplo, Enemigo → EnemigoRapido) con un método sobrescrito que use super().
4. Bucle de juego con tracer(0), update() y sleep.
5. Control por teclado con funciones pasadas como argumentos.
6. Al menos un rebote o un cambio de dirección por colisión.
7. Niveles de dificultad y objetos que se eliminan al salir de la pantalla.
8. Marcador con clear() y GAME OVER.
9. Constantes en mayúsculas para todos los valores configurables.

Etapas de desarrollo#

Entregables#

• Código completo en varios archivos.
• Documento de diseño y diagrama de clases.
• Tabla de al menos 10 casos de prueba con los resultados.
• Registro de errores: al menos 5 errores que encontraste y cómo los resolviste.
• Video corto o capturas de una partida.

Casos de prueba mínimos#

Criterios técnicos#

• main.py solo coordina: crea objetos, vincula teclas y ejecuta el bucle.
• No hay código copiado y pegado entre clases.
• Otro estudiante puede entender el juego leyendo el documento de diseño y los docstrings.

Posibles extensiones#

Sonido, pantalla de inicio, dos jugadores o un récord guardado en archivo (Día 24).

Conceptuales#

1. ¿Por qué CarManager no hereda de Turtle y Player sí?
2. ¿Qué diferencia hay entre la constante STARTING_MOVE_DISTANCE y el atributo car_speed?
3. ¿Qué significa que "la probabilidad de crear un auto es 1/6"?

Análisis de código#

def is_at_finish_line(self):
    return self.ycor() > FINISH_LINE_Y

¿Qué tipo de dato devuelve? ¿Por qué no necesita if?

Predicción#

car_speed empieza en 5 y aumenta en 10 por nivel. ¿Cuál es la velocidad en el nivel 4? ¿Y si en lugar de sumar 10 se multiplicara por 1,5?

Depuración#

def move_cars(self):
    for car in self.all_cars:
        car.backward(STARTING_MOVE_DISTANCE)

def level_up(self):
    self.car_speed += MOVE_INCREMENT

El jugador sube de nivel, pero los autos no aceleran. ¿Por qué?

Modificación#

Haz que los autos aparezcan por la izquierda y se muevan hacia la derecha. ¿Qué tres cosas cambias?

Creación#

Escribe CarManager.cars_on_screen() que devuelva cuántos autos están dentro de la ventana (entre −300 y 300 en X).