"AÑO DE LA RECUPERACIÓN Y CONSOLIDACIÓN DE LA ECONOMÍA
PERUANA"
➢ CURSO ACADEMICO:
PROGRAMACION DE COMPUTADORAS
➢ TITULO:
“DESARROLLO DE JUEGO PONG 2D CON CODIGO PYTON”
➢ INTEGRANTES:
o CONDORI ARIZACA WALDIR
o DE LA CRUZ APAZA THAYS
o FLORES MOLINA DANIEL
o GASTELO CARDENAS PARIS
➢ PROFESOR:
o MAMANI YANAPA, WILSON FERRIOL
2025
1
INDICE
1. RESUMEN. ..................................................................................................................................................... 3
2. INTRODUCCION ............................................................................................................................................. 3
3. PROBLEMÁTICA ............................................................................................................................................. 4
3.1 Comprensión del flujo lógico de un videojuego 2D .............................................. 4
3.2 Implementación de colisiones coherentes y dinámicas ....................................... 4
3.3 Gestión estructurada de los estados del juego.................................................... 4
3.4 Manejo de la interacción del usuario ................................................................... 4
3.5 Diseño de una interfaz gráfica clara y funcional .................................................. 5
4. Objetivos ....................................................................................................................................................... 5
4.1. Objetivo General ................................................................................................ 5
4.2. Objetivos específicos ......................................................................................... 5
5. Desarrollo del Código y Análisis del Funcionamiento.................................................................................... 6
6. RESULTADOS................................................................................................................................................ 13
7. CONCLUSIONES ........................................................................................................................................... 14
2
1. RESUMEN.
El presente trabajo desarrolla un videojuego bidimensional basado en Pong, utilizando el
lenguaje Python y la biblioteca Pygame. El proyecto permite aplicar conceptos
fundamentales de la programación de videojuegos: control por eventos, animación,
colisiones, gestión de estados y actualización en tiempo real.
El sistema implementado incluye movimiento continuo de elementos, detección precisa
de colisiones, puntuación automática, pausa, reinicio de partida, cuenta regresiva y
animación de mensaje de victoria. El juego se ejecuta de manera estable a 60 FPS sin
pérdida de rendimiento.
2. INTRODUCCION
La programación de videojuegos es una de las metodologías más eficaces para
desarrollar habilidades en lógica computacional, estructuras de control y manipulación de
gráficos. Python, gracias a su sintaxis clara y al soporte de bibliotecas como Pygame,
ofrece un entorno accesible para implementar simulaciones interactivas y sistemas de
animación en tiempo real.
El videojuego Pong fue escogido por su simplicidad conceptual y su potencial didáctico.
Mediante la recreación de este clásico, los integrantes aplicaron fundamentos de
programación estructurada, física básica y diseño modular. El proyecto no solo reproduce
la dinámica tradicional del juego, sino que incorpora mejoras significativas que enriquecen
la experiencia del usuario.
3
3. PROBLEMÁTICA
El desarrollo del videojuego plantea diversos desafíos asociados al manejo de gráficos en
tiempo real, la programación orientada a eventos y la coordinación precisa entre lógica y
visualización. A continuación, se detallan las principales dificultades encontradas:
3.1 Comprensión del flujo lógico de un videojuego 2D
Un videojuego 2D se ejecuta sobre un game loop continuo encargado de actualizar la lógica,
procesar la interacción del usuario y renderizar la escena. Para garantizar un funcionamiento
estable, se requiere:
1. Procesamiento de eventos en escalas de milisegundos.
2. Mantenimiento de un framerate constante para evitar retrasos o saltos visuales.
3. Sincronización precisa entre la actualización gráfica y la lógica interna del juego.
Estas condiciones exigen un diseño estructurado que permita fluidez y consistencia en cada
cuadro renderizado.
3.2 Implementación de colisiones coherentes y dinámicas
La pelota debe reaccionar correctamente ante distintos elementos del entorno, como:
• Paredes laterales y superiores.
• Paletas controladas por los jugadores.
• Zonas de anotación.
Para evitar movimientos predecibles, es necesario incorporar variaciones controladas en los
rebotes, generando trayectorias más naturales y reduciendo patrones repetitivos.
3.3 Gestión estructurada de los estados del juego
El videojuego debe contemplar transiciones claras entre distintos estados operativos, tales
como:
• Juego en curso.
• Pausa.
• Pantalla de victoria.
• Reinicio de la partida.
Cada estado debe administrarse de manera independiente y sin interferir con el flujo general,
garantizando estabilidad y continuidad en la experiencia del jugador.
3.4 Manejo de la interacción del usuario
El sistema debe interpretar correctamente distintas entradas del jugador, entre ellas:
• Movimientos de las paletas mediante teclas dedicadas.
• Activación o desactivación de la pausa.
• Comandos para reiniciar o finalizar la sesión de juego.
Una lectura eficiente y libre de retardos es esencial para mantener la jugabilidad.
4
3.5 Diseño de una interfaz gráfica clara y funcional
La presentación visual debe integrar de forma coherente:
• Los elementos principales del juego.
• El marcador de puntuación.
• La cuenta regresiva inicial.
• Indicadores de estado (pausa, victoria, reinicio).
El reto consiste en organizar estos componentes de manera intuitiva y dinámica, asegurando
una experiencia visual estable y comprensible para el usuario.
4. Objetivos
4.1. Objetivo General
Desarrollar un videojuego 2D funcional en Python utilizando la librería Pygame, basado en
una versión mejorada del clásico Pong, incorporando mecánicas extendidas y una interfaz
responsiva orientada a optimizar la experiencia interactiva del jugador
4.2. Objetivos específicos
• Implementar la detección de entradas por teclado para permitir un control preciso y
fluido de ambas paletas.
• Programar un sistema de colisiones dinámicas que incluya variaciones en el ángulo
de rebote de la pelota, evitando trayectorias repetitivas.
• Diseñar un sistema de puntuación automático que finalice la partida cuando un jugador
alcance cinco puntos.
• Integrar funcionalidades avanzadas, tales como pausa, reinicio de la partida, cuenta
regresiva animada y efecto de parpadeo en el mensaje de victoria.
• Mantener un framerate estable de 60 FPS para asegurar una representación gráfica
fluida y consistente.
• Documentar el código fuente mediante comentarios y estructura clara, facilitando su
comprensión, mantenimiento y ampliación futura.
5
5. Desarrollo del Código y Análisis del Funcionamiento
El programa inicia configurando todos los elementos necesarios para ejecutar el videojuego.
Entre los primeros pasos se encuentran:
• Importación de librerías:
pygame, sys, time y random, necesarias para gestionar gráficos, eventos, cierres del
programa, pausas y variaciones aleatorias.
• Inicialización de Pygame ([Link]()): habilita todos los módulos gráficos, de
entrada y temporización.
• Creación de la ventana de juego (800×600 px): mediante
[Link].set_mode(), y asignación del título con set_caption().
• Definición de colores, fuentes tipográficas y variables globales que controlan estados,
marcador y propiedades visuales.
Posteriormente se construyen los elementos principales del juego:
• Paletas, definidas con [Link], posicionadas a ambos lados de la ventana.
• Pelota, también representada por un rectángulo cuyo ancho equivale al diámetro.
• Velocidades iniciales para paletas y pelota, adecuadas para un movimiento estable.
• Marcadores para ambos jugadores.
Antes de iniciar cada partida, se ejecuta una cuenta regresiva en pantalla (3, 2 y 1),
utilizando un renderizado centrado y una pausa de un segundo entre cada número.
Al reiniciar el juego se restauran:
• La posición inicial de las paletas.
• La pelota al centro de la pantalla.
• Las puntuaciones (0 – 0).
6
• El estado general (juego activo, sin pausa).
Posteriormente se llama nuevamente a la cuenta regresiva.
Bucle principal del juego
El núcleo funcional se desarrolla en un game loop continuo que administra:
• Lectura de entradas del usuario.
• Actualización de posiciones.
• Detección de colisiones.
• Evaluación de estados (activo, pausa, fin de partida).
• Renderizado de gráficos en pantalla.
Dentro del bucle, el programa procesa:
• Tecla P para activar o desactivar la pausa.
• Teclas S y N al finalizar la partida para reiniciar o salir.
• Teclas W, S, ↑ y ↓ para el movimiento de paletas.
La lógica distingue entre:
• Juego activo,
• Juego en pausa,
• Juego finalizado,
mostrando mensajes específicos en cada estado.
En cada fotograma se actualiza la posición de la pelota y se verifica su interacción con las
paredes y las paletas. El algoritmo de rebotes incorpora variaciones mediante:
([Link] - [Link]) // 10
7
sumado a un pequeño valor aleatorio, lo que permite obtener trayectorias diversas y menos
predecibles.
Cuando la pelota atraviesa los bordes laterales:
• Se otorga un punto al jugador correspondiente.
• La pelota se reinicia en el centro dirigiéndose hacia el lado opuesto.
Si un jugador alcanza cinco puntos:
• El juego pasa al estado finalizado.
• Se muestra un mensaje de victoria con efecto de parpadeo.
El renderizado por fotograma incluye:
• Fondo negro.
• Paletas.
• Pelota.
• Línea media punteada.
• Marcador o mensajes según el estado.
Finalmente, [Link]() mantiene el bucle a 60 FPS, garantizando fluidez visual.
5.2 Análisis del código
Importación de librerías
• import pygame • import sys
• import time • import random
• pygame: núcleo gráfico y de eventos.
8
• sys: necesario para cerrar la aplicación correctamente.
• time: usado en temporizaciones (cuenta regresiva).
• random: permite modificar aleatoriamente la dirección de la pelota.
Inicialización de Pygame
[Link]()
Activa los módulos esenciales de la librería, requisito previo para cualquier operación gráfica
o de entrada.
Configuración de la pantalla
ANCHO, ALTO = 800, 600
pantalla = [Link].set_mode((ANCHO, ALTO))
[Link].set_caption("Pong 2D Mejorado")
Se establece la resolución y el nombre de la ventana principal.
Definición de colores
NEGRO = (0, 0, 0)
BLANCO = (255, 255, 255)
Colores en formato RGB utilizados en el renderizado.
Parámetros de paletas y pelota
paleta_ancho, paleta_alto = 15, 100
pelota_radio = 10
Dimensiones de los elementos de juego.
Fuentes tipográficas
fuente = [Link]("Arial", 40)
fuente_grande = [Link]("Arial", 60)
Se emplean para marcador, mensajes y cuenta regresiva.
9
Velocidad de las paletas
velocidad_paleta = 7
Definida en píxeles por fotograma.
Variables para animación de parpadeo
parpadeo = True
tiempo_parpadeo = 0
Permiten alternar la visibilidad del mensaje final.
Función: cuenta regresiva
Muestra 3, 2, 1 con un retardo de un segundo:
for i in range(3, 0, -1):
[Link](NEGRO)
texto = fuente_grande.render(str(i), True, BLANCO)
[Link](texto, (centro))
[Link]()
[Link](1)
Función: reiniciar_juego
Restaura posiciones, marcador y velocidad:
global paleta1, paleta2, pelota, velocidad_pelota, puntos1, puntos2, pausado
Reinicia elementos clave y ejecuta la cuenta regresiva previa al inicio de la partida.
Bucle principal
while True:
Ejecuta continuamente la lógica del juego.
10
Gestión de eventos
• Cierre de ventana.
• Pausa (P).
• Reinicio (S) o salida (N) al finalizar.
• Lectura de teclas para movimiento de paletas.
Movimiento de paletas
Controlado con:
• Jugador 1: W y S
• Jugador 2: ↑ y ↓
Se verifican límites para evitar que salgan de la pantalla.
Movimiento de la pelota
pelota.x += velocidad_pelota[0]
pelota.y += velocidad_pelota[1]
La pelota avanza según su vector de velocidad.
Rebotes
• Con paredes: se invierte la componente vertical.
• Con paletas:
o Se invierte la componente horizontal.
o Se añade un componente vertical según el punto de impacto.
o Se agrega un valor aleatorio para diversidad en trayectorias.
Sistema de puntuación
• Si cruza el borde izquierdo → punto para jugador 2.
• Si cruza el borde derecho → punto para jugador 1.
La pelota vuelve al centro con una velocidad inicial hacia el jugador que perdió el punto.
11
Condición de victoria
Al llegar a 5 puntos:
• Se detiene el juego.
• Se activa el mensaje intermitente por parpadeo.
Renderizado final
Cada fotograma dibuja:
• Fondo negro.
• Paletas y pelota.
• Línea central segmentada.
• Marcador o mensajes.
[Link]() actualiza la pantalla y [Link](60) mantiene el juego a 60 FPS.
12
6. RESULTADOS
La ejecución del programa permitió obtener un videojuego completamente funcional, estable
y coherente con los objetivos planteados. Entre los principales resultados se destacan:
• Videojuego operativo y con lógica consolidada: La mecánica de juego responde
correctamente a todos los requerimientos esenciales y a las funciones avanzadas
implementadas.
• Controles intuitivos y precisos:
El jugador 1 utiliza W y S, mientras que el jugador 2 emplea ↑ y ↓. La disposición
mejora la jugabilidad y facilita partidas locales sin necesidad de configuraciones
adicionales.
• Colisiones dinámicas y trayectorias variadas:
La combinación entre el punto de impacto y la variación aleatoria en el rebote genera
patrones menos predecibles, otorgando una experiencia más desafiante y entretenida.
• Sistema de pausa y reinicio correctamente articulado:
El juego puede pausarse en cualquier momento y reiniciarse tras una victoria, sin
afectar la estabilidad del bucle principal ni corromper las variables internas.
• Interfaz visual clara y responsiva:
Los mensajes de estado (pausa, ganador y cuenta regresiva) presentan buena
legibilidad, centrado adecuado y coherencia con la estética minimalista del juego.
• Rendimiento óptimo:
La ejecución estable a 60 FPS garantiza una animación fluida incluso en equipos de
bajo rendimiento, evidenciando una correcta gestión de recursos y temporización.
13
7. CONCLUSIONES
El desarrollo del proyecto Pong 2D Mejorado demuestra que Python, en conjunto con la
biblioteca Pygame, es una herramienta eficaz para la creación de videojuegos interactivos
con gráficos en tiempo real. El trabajo permitió integrar y aplicar principios esenciales de la
programación multimedia, tales como:
• Manejo estructurado de eventos del usuario.
• Ejecución de animaciones en tiempo real con sincronización constante.
• Implementación de lógica de colisiones y física simple.
• Administración de estados del sistema (juego activo, pausa, fin de partida).
• Renderizado continuo y eficiente de elementos gráficos.
El videojuego cumple plenamente los objetivos propuestos y constituye una base sólida para
futuras extensiones, como incorporación de inteligencia artificial para un jugador, efectos
sonoros, menús interactivos o distintos niveles de dificultad.
Asimismo, el proyecto evidencia la importancia de comprender el flujo interno de un game
loop y cómo cada componente (eventos, lógica, física y gráficos) debe integrarse de manera
coherente para obtener una experiencia fluida. La práctica adquirida fortalece
significativamente las habilidades del desarrollador en programación interactiva y diseño de
sistemas en tiempo real.
14