100 Días de Código en Python — Día 94: Proyecto de portafolio — Un bot que juega al dinosaurio de Chrome

📝 Contenido original del curso#

En Chrome, cuando intentas entrar a un sitio y no hay internet, ves un pequeño dinosaurio (aparentemente porque los dinosaurios tienen brazos cortos y "no alcanzan" tu sitio web).

En esa página hay un juego oculto: si pulsas la barra espaciadora, puedes jugar al T-rex run. (El enunciado incluye una imagen del juego.) También puedes acceder directamente en elgoog.im/t-rex.

Tu objetivo hoy es escribir un script de Python que automatice el juego. Tu programa mirará los píxeles de la pantalla para decidir cuándo pulsar la barra espaciadora y jugar automáticamente.

Puedes ver cómo se ve el juego automatizado con un bot en elgoog.im/t-rex/?bot.

Quizá quieras investigar dos paquetes: Pillow y PyAutoGUI.

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: Pillow (Día 85); NumPy e imágenes como arreglos (Día 77 y Día 92); automatización con Selenium (Días 48–53), que aquí se reemplaza por control directo de teclado; ciclos while (Día 5).

🔍 Antes de programar#

Juega 3 partidas a mano y responde:

La última pregunta es clave: después de cierta puntuación, el juego pasa a modo noche (colores invertidos). Un bot que no lo sepa fallará.

Capturar#

from PIL import ImageGrab

captura = ImageGrab.grab()                    # toda la pantalla
captura = ImageGrab.grab(bbox=(x1, y1, x2, y2))  # solo una región (más rápido)

ImageGrab funciona en Windows y macOS; en Linux depende del entorno gráfico. pyautogui.screenshot() es una alternativa (usa Pillow por dentro).

Calibrar: encontrar las coordenadas#

Las coordenadas dependen de tu pantalla: no copies las de otra persona. Una forma de encontrarlas:

import pyautogui, time

time.sleep(3)                  # tiempo para poner el ratón sobre el dino
print(pyautogui.position())    # Point(x=..., y=...)

Después, guarda una captura y ábrela para comprobar que la zona elegida es la correcta:

ImageGrab.grab(bbox=ZONA).save("zona.png")

⚠️ Escalado de pantalla en Windows: si tu pantalla está al 125 % o 150 %, las coordenadas de pyautogui y las de la captura pueden no coincidir. Síntoma: la zona guardada no es la que esperabas. Comprueba siempre con zona.png y consulta la documentación de pyautogui sobre este tema.

🎯 Objetivo de aprendizaje#

Convertir una región de píxeles en una decisión sí/no con un umbral.

📖 Explicación conceptual#

En el modo día, el fondo es casi blanco y los cactus son gris oscuro. Si en la zona delante del dinosaurio aparecen suficientes píxeles oscuros, hay un obstáculo. Dos parámetros:

• umbral: a partir de qué valor un píxel es "oscuro" (en escala de grises, 0 es negro y 255 blanco).
• mínimo: cuántos píxeles oscuros hacen falta (para ignorar polvo o ruido).

🔎 Ejemplo explicado#

import numpy as np

def hay_obstaculo(captura, zona, umbral=100, minimo=5):
    region = np.array(captura.crop(zona).convert("L"))
    return int((region < umbral).sum()) >= minimo

• crop(zona) recorta la región (izquierda, arriba, derecha, abajo).
• convert("L") pasa a escala de grises: un solo número por píxel.
• region < umbral produce un arreglo de True/False; .sum() cuenta los True (NumPy trata True como 1).
• Recibe una imagen, no captura la pantalla: por eso se puede probar con imágenes fabricadas.

Prueba verificada (sin pantalla):

from PIL import Image, ImageDraw

pantalla = Image.new("RGB", (600, 150), (247, 247, 247))   # fondo del juego
ZONA = (120, 90, 160, 120)
assert not hay_obstaculo(pantalla, ZONA)

ImageDraw.Draw(pantalla).rectangle((140, 85, 150, 125), fill=(83, 83, 83))  # "cactus"
assert hay_obstaculo(pantalla, ZONA)

Alternativa sin NumPy: recorrer los píxeles con region.getdata(). Funciona, pero getdata está obsoleto en Pillow 12 (verificado: muestra un aviso y se eliminará en Pillow 14), y fue unas 14 veces más lento en la prueba. En un bot, la velocidad importa: cada milisegundo de retraso es un salto tardío.

El modo noche (verificado)#

En un fondo oscuro, todos los píxeles son "oscuros": hay_obstaculo devuelve True sin cactus (falso positivo) y el dinosaurio saltaría sin parar. Idea: mirar primero un píxel del fondo (lejos de los obstáculos) y, si es oscuro, invertir la lógica (buscar píxeles claros). Tu turno: escribe fondo_es_oscuro(captura, punto) y adapta la decisión.

⚠️ Errores frecuentes#

Uso responsable#

Automatizar un juego sin conexión para aprender está bien. Usar bots en juegos en línea contra otras personas suele violar los términos del juego (y es trampa). Automatizar clics en páginas web puede violar sus términos de uso. Aplica lo aprendido en el Día 93: primero, ¿puedo?, ¿debo?

Problema#

Escribir un bot que juegue al T-rex run mirando los píxeles de la pantalla.

Contexto#

La clase de tecnología estudia cómo "ven" y "deciden" los robots. El juego del dinosaurio es un laboratorio seguro para experimentar con sensores (píxeles), reglas y actuadores (teclas).

Objetivo#

Un bot calibrado que supere, de manera consistente, la puntuación que tú logras jugando a mano.

Requisitos funcionales#

1. Captura la zona de peligro y decide saltar según los píxeles.
2. Se detiene con seguridad (FAILSAFE y límite de tiempo).
3. Funciona en modo día y en modo noche.
4. Muestra en la terminal cuántos saltos hizo.

Restricciones técnicas#

• Detección en una función pura probada con imágenes (sección 4).
• Coordenadas y umbrales como constantes en un solo lugar (o en un archivo de configuración).
• Ciclo while con condición de salida.

Planificación#

1. Comprender el juego (juega y observa). 2. Entradas: píxeles. 3. Procesos: capturar → decidir → pulsar. 4. Salidas: teclas. 5. Dividir en percibir/decidir/actuar. 6. Calibrar. 7. Implementar. 8. Probar. 9. Ajustar. 10. Mejorar.

Construcción paso a paso#

• Versión 1 — Calibración: script que imprime la posición del ratón y guarda zona.png.
• Versión 2 — Decisión offline: hay_obstaculo con las pruebas de la sección 4 y con 2 capturas reales guardadas (una con cactus y otra sin).
• Versión 3 — Bot básico: ciclo de 30 s que captura y salta.
• Versión 4 — Ajuste: mide la puntuación de 5 partidas y ajusta zona, umbral y mínimo. Registra los cambios en una tabla.
• Versión 5 — Modo noche y velocidad: adapta la lógica.
• Versión final: README.md con un GIF, la tabla de ajustes y el diario.

Pruebas#

🧪 Prueba y depuración#

while True:
    pantalla = ImageGrab.grab()
    if pantalla.getpixel((300, 400)) != (255, 255, 255):
        pyautogui.press("space")

Encuentra cuatro problemas: bucle infinito sin salida; captura toda la pantalla (lento); mira un solo píxel y exige blanco exacto (el fondo del juego no es (255, 255, 255) y cualquier variación dispara el salto); y no considera el modo noche.

⭐ Extensión del proyecto#

• 🟢 Reto 1 — Aplicación: agacharse (pyautogui.keyDown("down")) cuando el obstáculo está arriba (pájaros), usando una segunda zona.
• 🟡 Reto 2 — Ampliación: zona que se desplaza automáticamente según el tiempo transcurrido, para compensar la aceleración.
• 🟠 Reto 3 — Desafío: medir la velocidad de los obstáculos con dos capturas seguidas (¿cuántos píxeles se movió el borde del cactus?) y calcular el momento ideal del salto.
• 🔴 Reto 4 — Pensamiento computacional: diseña un experimento para encontrar los mejores parámetros (zona, umbral, mínimo): define qué medir, cuántas partidas por combinación y cómo comparar resultados sin engañarte con la suerte de una sola partida.

Situación#

En la sala de informática, cada inicio de clase hay que abrir las mismas 3 aplicaciones, ubicarlas en la pantalla y abrir la carpeta del curso. Toma 3 minutos por computador.

Requisitos#

1. Un script con pyautogui (o, mejor, con subprocess y os.startfile donde sea posible) que abra y organice las aplicaciones.
2. Espera a que cada aplicación aparezca (por ejemplo, buscando una imagen en pantalla con pyautogui.locateOnScreen) en lugar de usar pausas fijas.
3. Modo "simulación" que solo imprime lo que haría.

Decisiones que debes tomar (y justificar)#

• ¿Qué pasos se pueden hacer sin controlar el ratón (más confiable) y cuáles lo necesitan?
• ¿Qué hace el script si una aplicación no se abre?

Casos de prueba#

• En modo simulación, no se mueve el ratón.
• Si una aplicación tarda, el script espera sin fallar (hasta un límite).

🏫 Solo en computadores y con permisos autorizados por el docente o el administrador de la sala.

Conceptuales#

1. Describe el ciclo percibir–decidir–actuar con el ejemplo del bot.
2. ¿Por qué conviene que hay_obstaculo reciba una imagen en lugar de capturar la pantalla?
3. ¿Qué es un falso positivo? Da un ejemplo en este proyecto.
4. ¿Para qué sirve pyautogui.FAILSAFE?

Análisis de código#

region = np.array(captura.crop((100, 50, 120, 60)).convert("L"))
print(region.shape)

¿Qué forma tiene region? (Cuidado con el orden: filas, columnas.)

Predicción#

Con umbral=100 y minimo=5, una zona con 4 píxeles de valor 50 y el resto 247, ¿hay obstáculo?

Depuración#

"Mi bot funciona los primeros 30 segundos y luego empieza a chocar con todos los cactus." Da dos causas posibles.

Modificación#

Cambia hay_obstaculo para que devuelva también la posición (columna) del primer píxel oscuro de la zona.

Creación#

Escribe es_modo_noche(captura, punto) y combínala con hay_obstaculo en una función decidir(captura).