CURSO: PROGRAMACIÓN DE VIDEOJUEGOS CON PYTHON (PYGAME) PARA REFUERZO ESCOLAR CON DEEPSEEK AI

—

CURSO: PROGRAMACIÓN DE VIDEOJUEGOS CON PYTHON (PYGAME) PARA REFUERZO ESCOLAR CON DEEPSEEK AI

Subtítulo: Crea tus propios videojuegos 2D mientras dominas Python. Aprende a dibujar sprites, detectar colisiones, añadir sonido y música, y construir bucles de juego fluidos con un tutor que te explica cada línea de código y te ayuda a depurar cada bug

—

FICHA TÉCNICA

Campo Descripción
Código MUN-PYGAME-001
Carga horaria total 45 horas (recomendado: 3 horas por semana durante 15 semanas)
Modalidad 100% textual guiada por DeepSeek AI, con ejercicios prácticos de programación de videojuegos, depuración guiada, retos semanales de diseño de juegos y un proyecto final de videojuego completo
Nivel educativo Intermedio. Adaptable a Educación Secundaria Obligatoria (4.º curso), Bachillerato y Formación Profesional (Informática). La complejidad de los proyectos se gradúa según el nivel del alumno
Riesgo Medio (frustración con la gestión de eventos y el bucle de juego al inicio, confusión con las coordenadas y el sistema de referencia de Pygame, posible malestar visual si no se controla la tasa de refresco, riesgo de que el alumno pase más tiempo jugando que programando). La IA no ve la pantalla del alumno; el facilitador debe verificar la comprensión del bucle de juego y la detección de colisiones
Dirigido a Estudiantes que ya dominan los fundamentos de programación en Python (variables, condicionales, bucles, funciones, listas, clases básicas) y quieren aprender a crear videojuegos 2D. Ideal como continuación del curso de Programación y Pensamiento Computacional con Python
Prerrequisito Haber completado el curso de Programación y Pensamiento Computacional con Python (MUN-PYT-001) o tener conocimientos equivalentes de Python incluyendo clases y objetos. Disponer de un ordenador con Python instalado y la librería Pygame (pip install pygame). Conexión a internet. Autorización parental para menores de edad
Corpus obligatorio cargado en DeepSeek Documentación oficial de Pygame 2.x, Guía de referencia de la API de Pygame, Tutoriales de diseño de videojuegos 2D, Manual de patrones de bucle de juego, Referencia de sprites y detección de colisiones, Guía de sonido y música en Pygame
Certificación Diploma de aprovechamiento en Programación de Videojuegos con Python (Pygame). NO es una certificación profesional de desarrollo de videojuegos

—

AVISO PARA EL ESTUDIANTE (LECTURA OBLIGATORIA)

Un videojuego no es solo código. Es una experiencia interactiva que tú creas desde cero.

DeepSeek te guiará en cada línea de código, en cada sprite y en cada colisión. Pero recuerda:

· El bucle de juego es el corazón de todo. Si no entiendes cómo funciona el bucle de juego, no entiendes cómo funciona tu videojuego. Dale tiempo a este concepto.
· Las coordenadas en Pygame empiezan en la esquina superior izquierda (0,0). La X crece hacia la derecha, la Y crece hacia abajo. Es diferente a las matemáticas tradicionales.
· Un bug en un juego no es un error: es una característica no documentada (hasta que lo arreglas). Aprende a usar prints de depuración y a leer los mensajes de error.
· El diseño del juego es tan importante como la programación. Antes de escribir código, piensa: ¿qué hace divertido a este juego? ¿Cuáles son las reglas? ¿Cómo gana o pierde el jugador?
· No intentes hacer el próximo Minecraft en tu primer proyecto. Empieza con un Pong, un Space Invaders o un laberinto. La complejidad se construye capa a capa.

—

MAPA GENERAL DEL CURSO

Parte Título Horas Enfoque
I Los cimientos de Pygame: ventana, bucle de juego y dibujo básico 12 h Instalación, ventana, bucle de juego, eventos, colores, formas geométricas, texto
II Sprites, imágenes y animación 14 h Cargar imágenes, sprites, movimiento, teclado, animaciones, sonido
III Colisiones, puntuación y física básica 12 h Detección de colisiones, vidas, puntuación, niveles, gravedad simple
IV Proyecto integrador: tu videojuego completo 7 h Diseño, desarrollo, depuración y feria de videojuegos

—

PARTE I: LOS CIMIENTOS DE PYGAME. VENTANA, BUCLE DE JUEGO Y DIBUJO BÁSICO

(12 horas)

—

Capítulo 1. Bienvenido al estudio de desarrollo de videojuegos

(1 hora)

· Inciso 1.1. ¿Cómo funciona este curso? Tú programas videojuegos; DeepSeek te guía
· Inciso 1.2. Conoce a tu tutor DeepSeek: cómo pedirle que revise tu código, que te explique un error de Pygame o que te sugiera ideas para tu juego
· Inciso 1.3. Tu cuaderno de diseñador/a de videojuegos: diagramas de pantallas, reglas del juego, bocetos de personajes, fragmentos de código
· Inciso 1.4. Primera provocación: «DeepSeek, si pudieras crear cualquier videojuego 2D, ¿cuál sería su mecánica principal? Descríbeme la idea en un párrafo»

—

Capítulo 2. Instalación de Pygame y tu primera ventana

(2 horas)

· Inciso 2.1. ¿Qué es Pygame? Una librería de Python para crear videojuegos 2D. Historia y ejemplos de juegos famosos creados con ella
· Inciso 2.2. Instalación: pip install pygame. Verificación: import pygame; print(pygame.ver)
· Subinciso 2.2.1. Ejercicio guiado: «DeepSeek, estoy en Windows/macOS/Linux. Guíame para instalar Pygame y verificar que funciona correctamente»
· Inciso 2.3. Inicializar Pygame y crear una ventana:
«`python
import pygame
pygame.init()
pantalla = pygame.display.set_mode((800, 600))
pygame.display.set_caption(«Mi primer juego»)
«`
· Inciso 2.4. Mantener la ventana abierta: el bucle de eventos básico
«`python
ejecutando = True
while ejecutando:
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
ejecutando = False
pygame.quit()
«`
· Inciso 2.5. Explicación línea a línea: pygame.init() (inicializa todos los módulos), set_mode((ancho, alto)) (crea la ventana), pygame.event.get() (obtiene eventos como cerrar la ventana o pulsar teclas)
· Inciso 2.6. Ejercicio práctico: crea una ventana de 800×600 píxeles que se mantenga abierta hasta que el usuario la cierre

—

Capítulo 3. El bucle de juego: el corazón palpitante de tu videojuego

(3 horas)

· Inciso 3.1. Las 3 fases del bucle de juego: Procesar entrada → Actualizar estado → Renderizar (dibujar en pantalla)
· Inciso 3.2. Controlar los FPS (frames per second): pygame.time.Clock(), clock.tick(60). Por qué limitar a 60 FPS
· Inciso 3.3. Rellenar el fondo: pantalla.fill((color_R, color_G, color_B)). Sistema RGB
· Inciso 3.4. Actualizar la pantalla: pygame.display.flip() (redibuja toda la ventana) o pygame.display.update() (solo zonas modificadas)
· Inciso 3.5. Bucle de juego completo con control de FPS:
«`python
import pygame
pygame.init()
pantalla = pygame.display.set_mode((800, 600))
reloj = pygame.time.Clock()
ejecutando = True
while ejecutando:
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
ejecutando = False
pantalla.fill((0, 0, 0)) # Fondo negro
# Aquí irán los dibujos y la lógica del juego
pygame.display.flip()
reloj.tick(60)
pygame.quit()
«`
· Inciso 3.6. Ejercicio práctico: crea un bucle de juego que cambie el color de fondo cada 60 frames (1 segundo) entre negro, azul oscuro y rojo oscuro

—

Capítulo 4. Dibujando formas geométricas y colores

(3 horas)

· Inciso 4.1. Sistema de coordenadas de Pygame: (0,0) es la esquina superior izquierda. X crece hacia la derecha, Y crece hacia abajo
· Inciso 4.2. Colores en Pygame: RGB (0-255). (255, 0, 0) = rojo, (0, 255, 0) = verde, (0, 0, 255) = azul. Colores predefinidos: pygame.Color(‘red’), pygame.Color(‘darkgreen’)
· Inciso 4.3. Dibujar rectángulos: pygame.draw.rect(pantalla, color, (x, y, ancho, alto)), pygame.draw.rect(pantalla, color, (x, y, ancho, alto), grosor_borde)
· Inciso 4.4. Dibujar círculos: pygame.draw.circle(pantalla, color, (x_centro, y_centro), radio), pygame.draw.circle(pantalla, color, (x_centro, y_centro), radio, grosor_borde)
· Inciso 4.5. Dibujar líneas: pygame.draw.line(pantalla, color, (x1, y1), (x2, y2), grosor)
· Inciso 4.6. Dibujar polígonos: pygame.draw.polygon(pantalla, color, [(x1,y1), (x2,y2), (x3,y3)])
· Inciso 4.7. Ejercicio práctico: dibuja una cara simple (emoji) usando solo formas geométricas: un círculo amarillo, dos ojos negros y una boca弧形

—

Capítulo 5. Mostrando texto en pantalla

(2 horas)

· Inciso 5.1. Fuentes en Pygame: pygame.font.Font(None, 36) (fuente por defecto, tamaño 36), pygame.font.Font(‘arial.ttf’, 24) (fuente específica)
· Inciso 5.2. Crear una superficie de texto: texto = fuente.render(‘Hola, mundo!’, True, color). El segundo argumento True activa el antialiasing
· Inciso 5.3. Posicionar el texto: pantalla.blit(texto, (x, y)). Obtener el rectángulo del texto para centrarlo: texto.get_rect(center=(400, 300))
· Inciso 5.4. Mostrar puntuación, vidas y mensajes en pantalla
· Inciso 5.5. Ejercicio práctico: añade un marcador de puntuación y un texto de «Game Over» a tu prototipo de juego

—

Capítulo 6. Eventos de teclado y ratón

(1 hora)

· Inciso 6.1. Eventos de teclado: pygame.KEYDOWN, pygame.KEYUP, evento.key. Constantes de teclas: pygame.K_LEFT, pygame.K_RIGHT, pygame.K_SPACE, pygame.K_ESCAPE
· Inciso 6.2. Estado del teclado en tiempo real: teclas = pygame.key.get_pressed(). if teclas[pygame.K_UP]: para movimiento continuo
· Inciso 6.3. Eventos de ratón: pygame.MOUSEBUTTONDOWN, pygame.MOUSEMOTION, evento.pos (coordenadas del cursor), evento.button (1=izquierdo, 2=medio, 3=derecho)
· Inciso 6.4. Ejercicio práctico: mueve un rectángulo con las flechas del teclado y cambia su color al hacer clic sobre él

—

PARTE II: SPRITES, IMÁGENES Y ANIMACIÓN

(14 horas)

—

Capítulo 7. Cargando y mostrando imágenes

(3 horas)

· Inciso 7.1. Formatos de imagen soportados: PNG (recomendado, soporta transparencia), JPG (no soporta transparencia), BMP, GIF
· Inciso 7.2. Cargar una imagen: imagen = pygame.image.load(‘personaje.png’). Ruta relativa o absoluta
· Inciso 7.3. Convertir la imagen para mejorar el rendimiento: imagen = imagen.convert_alpha() (si tiene transparencia) o imagen.convert() (sin transparencia)
· Inciso 7.4. Mostrar la imagen: pantalla.blit(imagen, (x, y)). Redimensionar: pygame.transform.scale(imagen, (ancho, alto)). Rotar: pygame.transform.rotate(imagen, grados)
· Inciso 7.5. Obtener el rectángulo de la imagen: rect = imagen.get_rect(). rect.x, rect.y, rect.center, rect.topleft
· Inciso 7.6. Ejercicio práctico: carga una imagen de un personaje y muévela por la pantalla con las flechas del teclado

—

Capítulo 8. La clase Sprite de Pygame

(3 horas)

· Inciso 8.1. ¿Qué es un sprite? Un objeto gráfico con propiedades (imagen, posición, velocidad) y comportamiento (moverse, chocar, desaparecer)
· Inciso 8.2. La clase pygame.sprite.Sprite: herencia y métodos. __init__, update
«`python
class Jugador(pygame.sprite.Sprite):
def __init__(self):
super().__init__()
self.image = pygame.Surface((50, 50))
self.image.fill((0, 255, 0))
self.rect = self.image.get_rect()
self.rect.center = (400, 300)
def update(self):
teclas = pygame.key.get_pressed()
if teclas[pygame.K_LEFT]: self.rect.x -= 5
if teclas[pygame.K_RIGHT]: self.rect.x += 5
«`
· Inciso 8.3. Grupos de sprites: pygame.sprite.Group(). grupo.add(sprite), grupo.draw(pantalla), grupo.update()
· Inciso 8.4. Ejercicio práctico: convierte tu personaje en un Sprite y crea un grupo de sprites para gestionarlo

—

Capítulo 9. Movimiento suave y delta time

(2 horas)

· Inciso 9.1. Delta time: el tiempo transcurrido entre frames. reloj.tick(60) devuelve los milisegundos desde la última llamada
· Inciso 9.2. Movimiento independiente del framerate: velocidad * dt / 1000.0. Así el movimiento es constante a 30, 60 o 144 FPS
· Inciso 9.3. Vectores de movimiento: pygame.math.Vector2. posicion += velocidad * dt
· Inciso 9.4. Ejercicio práctico: implementa movimiento suave con delta time en tu juego

—

Capítulo 10. Animaciones con spritesheets

(3 horas)

· Inciso 10.1. ¿Qué es un spritesheet? Una imagen que contiene todos los fotogramas de una animación
· Inciso 10.2. Recortar frames de un spritesheet: spritesheet.subsurface((x, y, ancho, alto))
· Inciso 10.3. Ciclo de animación: lista de frames, índice actual, cambiar frame cada N milisegundos
«`python
self.frames = [cargar_frame(i) for i in range(num_frames)]
self.frame_actual = 0
self.tiempo_acumulado = 0
# En update:
self.tiempo_acumulado += dt
if self.tiempo_acumulado > 100: # Cambiar frame cada 100ms
self.frame_actual = (self.frame_actual + 1) % len(self.frames)
self.image = self.frames[self.frame_actual]
self.tiempo_acumulado = 0
«`
· Inciso 10.4. Ejercicio práctico: crea una animación de caminar para tu personaje usando spritesheets

—

Capítulo 11. Sonido y música

(3 horas)

· Inciso 11.1. Inicializar el mezclador de sonido: pygame.mixer.init()
· Inciso 11.2. Efectos de sonido: sonido = pygame.mixer.Sound(‘disparo.wav’), sonido.play(), sonido.set_volume(0.5)
· Inciso 11.3. Música de fondo: pygame.mixer.music.load(‘fondo.mp3’), pygame.mixer.music.play(-1) (bucle infinito), pygame.mixer.music.set_volume(0.3)
· Inciso 11.4. Pausar, reanudar y detener la música
· Inciso 11.5. Formatos soportados: WAV (recomendado para efectos, sin compresión), MP3 y OGG (para música)
· Inciso 11.6. Ejercicio práctico: añade efectos de sonido a tu juego (disparo, colisión, game over) y una música de fondo

—

PARTE III: COLISIONES, PUNTUACIÓN Y FÍSICA BÁSICA

(12 horas)

—

Capítulo 12. Detección de colisiones entre sprites

(4 horas)

· Inciso 12.1. Colisiones con rectángulos: rect1.colliderect(rect2). Devuelve True si los rectángulos se solapan
· Inciso 12.2. Colisiones con sprites: pygame.sprite.spritecollide(sprite, grupo, dokill=False). Devuelve una lista de sprites que colisionan
· Inciso 12.3. pygame.sprite.groupcollide(grupo1, grupo2, dokill1, dokill2). Colisiones entre dos grupos
· Inciso 12.4. Colisiones con máscaras (pixel-perfect): pygame.sprite.collide_mask(sprite1, sprite2). Más preciso pero más costoso
· Inciso 12.5. Ejercicio práctico: crea un juego de naves donde el jugador dispare balas que destruyen enemigos al colisionar

—

Capítulo 13. Sistemas de puntuación, vidas y oleadas

(3 horas)

· Inciso 13.1. Variables de estado del juego: puntuacion, vidas, nivel, enemigos_restantes
· Inciso 13.2. Incrementar puntuación al destruir enemigos o recoger objetos
· Inciso 13.3. Sistema de vidas: perder una vida al recibir daño, Game Over cuando las vidas lleguen a 0
· Inciso 13.4. Sistema de oleadas (waves): al eliminar todos los enemigos, aparece una nueva oleada más difícil
· Inciso 13.5. Ejercicio práctico: implementa puntuación, vidas y oleadas en tu juego de naves

—

Capítulo 14. Física básica: gravedad, salto y plataformas

(3 horas)

· Inciso 14.1. Simular gravedad: velocidad_y += gravedad * dt. gravedad = 0.5 (ajustable)
· Inciso 14.2. Sistema de salto: if en_suelo and tecla_salto: velocidad_y = -10. en_suelo se comprueba con colisiones contra el suelo o plataformas
· Inciso 14.3. Plataformas móviles y estáticas. Colisiones solo desde arriba
· Inciso 14.4. Fricción y velocidad terminal
· Inciso 14.5. Ejercicio práctico: crea un pequeño juego de plataformas con gravedad, salto y plataformas

—

Capítulo 15. Menús, pantallas de inicio y game over

(2 horas)

· Inciso 15.1. Máquina de estados del juego: MENU, JUGANDO, GAME_OVER, PAUSA
· Inciso 15.2. Pantalla de menú principal con título y botones (texto clickable)
· Inciso 15.3. Pantalla de Game Over con puntuación final y opción de reiniciar
· Inciso 15.4. Pausa durante el juego (tecla ESC o P)
· Inciso 15.5. Ejercicio práctico: añade un menú principal, una pantalla de Game Over y la opción de reiniciar a tu juego

—

PARTE IV: PROYECTO INTEGRADOR. TU VIDEOJUEGO COMPLETO

(7 horas)

—

Capítulo 16. Diseño del juego y documento de diseño (GDD)

(2 horas)

· Inciso 16.1. Elige el género de tu proyecto final:
· Shooter espacial (Space Invaders / Galaga)
· Plataformas (estilo Mario o Geometry Dash simple)
· Arcade de esquivar (estilo Frogger o Crossy Road)
· Pong / Breakout (juegos de raqueta)
· Snake (juego de la serpiente)
· Laberinto (estilo Pac-Man)
· Inciso 16.2. Elabora el Documento de Diseño del Juego (GDD): historia, mecánicas, controles, condiciones de victoria/derrota, estética, sonido
· Inciso 16.3. «DeepSeek, te paso mi idea. Ayúdame a pulir las mecánicas para que sea divertido y justo. Hazme preguntas para que yo tome las decisiones»

—

Capítulo 17. Desarrollo y depuración del proyecto

(3 horas)

· Inciso 17.1. Implementa el bucle de juego con la máquina de estados (MENU, JUGANDO, GAME_OVER)
· Inciso 17.2. Crea las clases de sprites necesarias (jugador, enemigos, balas, objetos, plataformas)
· Inciso 17.3. Implementa las colisiones y la lógica de puntuación
· Inciso 17.4. Añade sonidos y música
· Inciso 17.5. Depura cada funcionalidad y pide a un compañero que pruebe el juego
· Inciso 17.6. «DeepSeek, te paso fragmentos de mi código. Revísame la lógica y dime si hay errores o algo que se pueda mejorar»

—

Capítulo 18. Empaquetado del juego para compartir

(1 hora)

· Inciso 18.1. ¿Cómo compartir tu juego con amigos que no tienen Python? Opciones:
· PyInstaller: pip install pyinstaller, pyinstaller –onefile –windowed mi_juego.py
· Subirlo a itch.io: plataforma para juegos indie
· Compartir el código en GitHub con instrucciones de instalación
· Inciso 18.2. Crear un requirements.txt: pip freeze > requirements.txt
· Inciso 18.3. Incluir assets (imágenes, sonidos) en la carpeta del proyecto
· Inciso 18.4. Ejercicio práctico: empaqueta tu juego con PyInstaller y compártelo con un compañero

—

Capítulo 19. Feria de videojuegos, cierre y diploma

(1 hora)

· Inciso 19.1. Presenta tu videojuego al grupo: muestra la pantalla de inicio, juega una partida, explica cómo lo hiciste
· Inciso 19.2. Recapitulación: ¿qué conceptos de programación y diseño de videojuegos dominas ahora?
· Bucle de juego con delta time
· Sprites, animaciones y spritesheets
· Detección de colisiones y física básica
· Sonido y música
· Máquinas de estados para menús y pantallas
· Inciso 19.3. Próximos pasos: Godot Engine, Unity con C#, desarrollo 3D, publicación en Steam o itch.io
· Inciso 19.4. Diploma de aprovechamiento y cierre

—

RESUMEN EJECUTIVO DEL CURSO

Dimensión Resumen
Rol de la IA Tutora de Pygame, revisora de código, depuradora de bugs, generadora de ideas de mecánicas y asesora de diseño de videojuegos
Rol del estudiante Desarrollador/a de videojuegos en formación: crea, depura, itera y presenta un videojuego completo con sprites, colisiones, sonido y música
Rol del facilitador Apoyo técnico, verificador de la comprensión del bucle de juego, dinamizador de la feria de videojuegos
Meta última Que el alumno comprenda el bucle de juego, domine la detección de colisiones y sea capaz de construir y compartir un videojuego 2D completo con Python y Pygame
Horas 45
Estructura 4 Partes, 19 Capítulos

—

¿Deseas que continuemos con otro curso de la lista, o prefieres explorar un ámbito diferente del ecosistema?