Tutorial: Escribiendo juegos en Python I

Tutorial: Escribiendo juegos en Python I

Miércoles 10 Dic 2008

Muchos de nosotros gozamos a diario jugando videojuegos. Y somos muchos los que siempre hemos querido hacer nuestro propio juego. Cuando yo era chico programé infinidad de juegos en mi Atari. Pero programar un juego no es cosa sencilla, y aprender el lenguaje C no es para cualquiera.

Existe una plataforma de código libre para escribir juegos de manera sencilla, en un lenguaje poderoso. Esta es la primera parte de una serie de artículos que escribiré para enseñar a utilizar las librerías pygame para hacer videojuegos. Estas librerías son open-source y están disponibles para las plataformas tradicionales (Linux, MacOSX y Windows).

¿Qué es pygame?

Pygame es un conjunto de librerías para el lenguaje Python que facilitan el escribir juegos. Hacen fáciles tareas complicadas como cargar imágenes, desplegarlas en la pantalla, almacenar y tocar sonidos/música; también te permiten abstraerte de problemas como qué tipo de hardware tienen los usuarios.

Para aprender a usar pygame sólo necesitas tener conocimientos de Python. Como el enfoque de este tutorial no es aprender Python, les dejo la página oficial con tutoriales sobre cómo aprender este lenguaje.

Instalar pygame

La manera más sencilla de instalar Pygame es hacerlo en Linux :D, con un simple comando en el terminal. En Ubuntu la instalación es así:

  1. sudo apt-get install python-pygame

Se siguen las instrucciones y listo. En la página de Pygame pueden encontrar instrucciones para instalarlo en Windows y MacOSX

Manos a la obra

Lo primero que haremos será crear un archivo de texto llamado "demo1.py", y copiar estas líneas en él. Luego les explicaré qué significan.

  1. import pygame
  2. from pygame.locals import  *
  3. SCREEN_WIDTH = 800
  4. SCREEN_HEIGHT = 600
  5. def game():
  6.         pygame.init()
  7.         screen = pygame.display.set_mode( (SCREEN_WIDTH,SCREEN_HEIGHT) )
  8.         pygame.display.set_caption( "demo1" )
  9.    
  10.         while True:
  11.                 keyinput = pygame.key.get_pressed()
  12.                 if keyinput[K_ESCAPE] or pygame.event.peek(QUIT):
  13.                         raise SystemExit
  14. if __name__ == '__main__':
  15.         game()

Vamos por partes. Con las siguientes líneas lo que hacemos es decir que usaremos las librerías:

  1. import pygame
  2. from pygame.locals import *

Luego definimos un par de constantes, como la resolución de pantalla que usaremos para nuestro juego:

  1. SCREEN_WIDTH = 800
  2. SCREEN_HEIGHT = 600

Así, nuestro juego correrá en 800x600. Luego escribimos una función llamada "Game". Veamos el cuerpo de la función. Lo primero que hacemos es inicializar los sistemas de pygame:

  1.         pygame.init()

Después le decimos a pygame la resolución que usaremos y el nombre de nuestro juego. Como lo corremos (por ahora) dentro de una ventana, este nombre es el que se desplegará en el título de la ventana.

  1.         screen = pygame.display.set_mode( (SCREEN_WIDTH,SCREEN_HEIGHT) )
  2.         pygame.display.set_caption( "demo1" )

Finalmente, entramos a lo que es el ciclo principal del juego. Este ciclo tomará todo el tiempo de juego. Es en este juego en que sucede la inteligencia de los personajes, se calculan las nuevas posiciones, se dibujan los gráficos y se toca la música. Demos un vistazo.

Comenzamos el ciclo:

  1.         while True:

Ahora le pedimos a Pygame que nos dé un arreglo con todas las teclas que están siendo presionadas en este instante. Y luego vemos si la tecla ESCAPE está presionada. Si esto es así, procedemos a terminar el juego. Para terminar, basta con salir del ciclo principal.

  1.                 keyinput = pygame.key.get_pressed()
  2.                 if keyinput[K_ESCAPE] or pygame.event.peek(QUIT):
  3.                         raise SystemExit

Y por último, estas líneas sirven para que el juego comience. Son líneas típicas de los programas en Python, así que no las explicaremos.

  1. if __name__ == '__main__':
  2.         game()

Corriendo nuestro juego

Ha llegado la hora correr el juego. Para eso, simplemente ejecuta este comando en un terminal abierto en la misma carpeta de tu juego:

  1. python demo1.py

¿Y qué veremos? Pues muy poco hasta aquí. Simplemente veremos una ventana en negro con el título de nuestro juego. Si presionas la tecla ESCAPE la ventana se cerrará.

No podemos decir que nuestro juego es muy interesante hasta ahora, pero es la base de todos los programas que podrás escribir de ahora en adelante.

Agregando una imagen de fondo

Vamos un poco más allá de lo básico. Agregar una imagen de fondo a nuestro juego es muy sencillo. Primero debemos crear una función que es la que usaremos para leer imágenes desde el disco duro.

  1. def load_image(filename, transparent = False):
  2.         try: image = pygame.image.load(filename)
  3.         except pygame.error, message:
  4.                 raise SystemExit, message
  5.         image = image.convert()
  6.         if transparent:
  7.                 color = image.get_at((0,0))
  8.                 image.set_colorkey(color, RLEACCEL)
  9.         return image

Esta función es bastante simple. Lo que hace es leer la imagen desde el disco duro y almacenarla en una variable temporal. Si el segundo parámetro es verdadero, entonces la función get_at se usa para obtener el color del pixel en la posición (0,0). Esto lo haremos cuando trabajemos con personajes. Por ahora puedes ignorarlo.

Luego, descarga esta imagen y ponla en la misma carpeta que el juego.

Ahora, los últimos toques al código. Haremos algunas modificaciones al método principal. Antes del ciclo while agregaremos las siguientes líneas:

  1. screen = pygame.display.set_mode( (SCREEN_WIDTH,SCREEN_HEIGHT) )
  2. background_image = load_image('back.jpg');

Lo que hicimos aquí fue crear una superficie. Las superficies son los objetos gráficos de Pygame. Pero esta superficie en particular es la que representa a la ventana principal del juego. Lo que dibujemos en ésta saldrá dibujado en nuestro juego. Luego cargamos la imagen "back.jpg" en memoria y la almacenamos en la variable background_image.

Ahora agregamos bajo el ciclo while estas otras líneas:

  1. screen.blit(background_image, (0,0) )
  2. pygame.display.flip()

Estas últimas dos líneas hacen que por cada ciclo la imagen de fondo se dibuje sobre la superficie de la pantalla. Los parámetros (0, 0) son para indicarle al intérprete que la esquina superior izquierda de la imagen se dibuje sobre la esquina superior izquierda de la pantalla. En otras palabras, es la posición en la pantalla.

Resultado final

El código final de esta segunda versión sólo es un poco más largo. Veamos:

  1. import pygame
  2. from pygame.locals import *
  3. SCREEN_WIDTH = 800
  4. SCREEN_HEIGHT = 600
  5. def load_image(filename, transparent = False):
  6.         try: image = pygame.image.load(filename)
  7.         except pygame.error, message:
  8.                 raise SystemExit, message
  9.         image = image.convert()
  10.         if transparent:
  11.                 color = image.get_at((0,0))
  12.                 image.set_colorkey(color, RLEACCEL)
  13.         return image
  14. def game():
  15.         pygame.init()
  16.         screen = pygame.display.set_mode( (SCREEN_WIDTH,SCREEN_HEIGHT) )
  17.         pygame.display.set_caption( "demo1" )
  18.         background_image = load_image('back.jpg');
  19.         while True:
  20.                 screen.blit(background_image, (0,0) )
  21.                 pygame.display.flip()
  22.                 keyinput = pygame.key.get_pressed()
  23.                 keyinput = pygame.key.get_pressed()
  24.                 if keyinput[K_ESCAPE] or pygame.event.peek(QUIT):
  25.                         raise SystemExit
  26.  
  27.        
  28. if __name__ == '__main__':
  29.         game()

Si lo hiciste todo bien, tipeando "python demo1.py" deberías ver algo como esto:

Bueno, con esto terminamos la primera parte. En la segunda veremos cómo hacer personajes y lograr que éstos se muevan por la pantalla. ¡Nos vemos!