Estos dos te muestran el interprete y la salida que produce de forma interactiva:

• http://shell.appspot.com/
• http://try-python.mired.org/

Mientras que estos otros dos nos permiten escribir un script y luego probar como funciona:

• http://pythonwebconsole.thomnichols.org/
• http://codepad.org/ (este también funciona como pastebin y soporta varios lenguajes)

Obviamente por motivos de seguridad tienen algunos modulos algo capados, pero pueden resultar útiles

• Rellenar el fondo con un color especifico
• Dibujar lineas en la pantalla
• Dibujar un circulo
• Sincronizar el movimiento usando tiempo

A continuación la explicación (aunque es recomendable que hayan leído la parte anterior antes de seguir):

Paso 1: Creando lo básico (rellenar el fondo y dibujar lineas)

Lo primero es crear la ventana, que tendrá un fondo azul y en donde dibujaremos una linea blanca que servirá de separador (en la parte de arriba se mostrara la información más adelante).

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/07/14/tutorial-pygame-4-figuras-y-texto

# ---------------------------
# Importación de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys

# -----------
# Constantes
# -----------

WIDTH = 640
HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


# ------------------------------
# Función principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 4")

    # el bucle principal del juego
    while True:
        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                if event.key == K_ESCAPE:
                    sys.exit()

        # Re dibujar los elementos en pantalla
        screen.fill((30, 145, 255))
        pygame.draw.line(screen, (255, 255, 255), (0, 25), (640, 25), 2)
        # actualizamos la pantalla
        pygame.display.flip()


if __name__ == "__main__":
    main()

La mayor parte de este código la explicamos en la segunda parte del tutorial. Lo nuevo es que en vez de usar una imagen de fondo, utilizamos un color para rellenar la pantalla al hacer screen.fill((30, 145, 255)) que en términos simples llena la pantalla con un color celeste, el color se ingresa usando el valor RGB del color, que en este caso es (30, 145, 255)

El RGB (Red, Green, Blue) es un modelo de color en donde cualquier color se puede formar mediante los colores primarios (rojo, verde, azul).

Los colores primarios se representan de la siguiente manera: el rojo es el (255,0,0), el verde con (0,255,0) y el azul con (0,0,255). La ausencia de color (o sea el negro) es el (0,0,0) y el blanco (255,255,255)

Cualquier otro color se obtiene con la mezcla de estos, como por ejemplo el amarillo se obtiene al combinar el rojo con el verde, o sea (255,255,0) y lo mismo para el resto de los colores.

Lo otro fue dibujar una linea blanca en la ventana, para dibujar lineas se usa line del modulo draw de la siguiente forma:

pygame.draw.line(Superficie, Color, Inicio, Fin, Grosor)

Que en este caso con pygame.draw.line(screen, (255, 255, 255), (0, 25), (640, 25), 2) Ocurre lo siguiente: la superficie sobre la cual se dibuja es la pantalla (que llamamos screen), el color de la linea es blanco (255, 255, 255) y dibuja os una linea paralela a 25 pixeles del borde, por lo que comienza en (0, 25) y termina en (640, 25) y esta linea es de 2 pixeles de ancho (grosor)

Existe también el pygame.draw.aaline() que dibuja lineas aplicando anti-alias (suavizar el borde de linea para que la linea no se vea pixelada o escalonada) y su uso es el siguiente

pygame.draw.aaline(Superficie, Color, Inicio, Fin, blend=1)

Si blend está en valor True (1), las figuras se mezclarán con la tonalidad de los pixeles existentes en lugar de sobre-escribirlos.

Paso 2: Crear el proyectil (dibujar un circulo) y mostrar texto

Ahora dibujaremos un circulo (que sera nuestro proyectil) en la esquina inferior izquierda y crearemos un sprite que contenga la información del proyectil.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/07/14/tutorial-pygame-4-figuras-y-texto

# ---------------------------
# Importación de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys

# -----------
# Constantes
# -----------

WIDTH = 640
HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


class Proyectil(pygame.sprite.Sprite):
    "Clase que representa el proyectil lanzado"

    def __init__(self, x, y):
        self.angulo = 45
        self.veloc = 50
        self.tiempo = 0
        self.x = x
        self.y = y
        self.xreal = x
        self.yreal = HEIGHT - self.y


# ------------------------------
# Función principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 4")

    # se define la letra por defecto
    fuente = pygame.font.Font(None, 20)

    # se crea un proyectil a lanzar
    bala = Proyectil(0, HEIGHT)

    # el bucle principal del juego
    while True:
        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                if event.key == K_ESCAPE:
                    sys.exit()

        text = "Velocidad: %3d (m/s)   Angulo: %d   x=%d m   y=%d m" % (
            bala.veloc, bala.angulo, bala.xreal, bala.yreal)
        mensaje = fuente.render(text, 1, (255, 255, 255))

        # Re dibujar los elementos en pantalla
        screen.fill((30, 145, 255))
        screen.blit(mensaje, (15, 5))
        pygame.draw.line(screen, (255, 255, 255), (0, 25), (640, 25), 2)
        pygame.draw.circle(screen, (0, 0, 0), (int(bala.x), int(bala.y)), 10)
        # actualizamos la pantalla
        pygame.display.flip()


if __name__ == "__main__":
    main()

Creamos una clase (sprite) que representa nuestro proyectil y le ingresamos algunos valores por defecto como son el angulo y velocidad de disparo, o sea esta parte:

class Proyectil(pygame.sprite.Sprite):
    "Clase que representa el proyectil lanzado"

    def __init__(self, x, y):
        self.angulo = 45
        self.veloc = 50
        self.tiempo = 0
        self.x = x
        self.y = y
        self.xreal = x
        self.yreal = HEIGHT - self.y

Si se fijan el tiempo lo dejamos en 0 (ya que comenzara a contar a partir del disparo del proyectil) y definimos dos valores self.x, self.y que representan la posición del proyectil en la pantalla y otro par de valores self.xreal, self.yreal que después tomaran la posición que se calcule que tendrá el proyectil, estos valores serán diferentes en el eje y, ya que pygame considera el (0,0) en la equina superior izquierda y las formulas físicas que describen el movimiento (ver mas adelante) consideran el (0,0) en la esquina inferior izquierda. Mas adelante (en el while True) iniciamos esta clase (bajo el nombre de “bala”) con la posición inicial de esta (en este caso la esquina inferior izquierda).

Ahora vamos a mostrar en pantalla un texto (que aparecerá en la parte superior de la ventana) indicando la información básica del proyectil: angulo y velocidad de disparo (al momento de disparar) y su posición. Para mostrar el texto primero definimos la fuente a utilizar y su tamaño haciendo: fuente = pygame.font.Font(None, 20)

En pygame.font.Font el primer valor es la ubicación y nombre de la fuente utilizada. Si se ingresa None se utiliza la fuente por defecto.

El segundo valor es la altura de la fuente (en pixeles).

Luego almacenamos el mensaje como una cadena de texto en la variable “text” (usando la información obtenida desde la clase “bala”) y este texto se tiene que dibujar en alguna superficie (pygame no puede dibujar el texto directamente, sino hay que crear una “imagen” de de ese texto), para lo cual usamos mensaje = fuente.render(text, 1, (255, 255, 255)) con lo cual almacenamos esa “imagen” en el objeto mensaje (tal como si fuera un sprite) y después de manera análoga a un sprite esa “imagen” se muestra en la pantalla usando screen.blit(mensaje, (15, 5)) donde (15, 5) es la posición en que se muestra (arriba a la izquierda)

El Font.render toma como primer valor la cadena de texto a mostrar, el segundo valor es si usa antialias (=1) o no y el tercero es el color del texto. Se puede agregar un cuarto valor para crear un borde en el texto

Por ultimo hacemos: pygame.draw.circle(screen, (0, 0, 0), (int(bala.x), int(bala.y)), 10) En este caso dibujamos un circulo en la la pantalla/ventana (que llamamos screen) este es de un color negro, que esta en la posición (bala.x, bala.y) o sea en la esquina inferior izquierda (aunque después al disparar el proyectil estos valores se modifican, moviendo el circulo), los int son para transformar los valores a números enteros, ya que los valores originales pueden ser decimales y el ultimo valor le indica que el circulo tiene un radio de 10 px.

Paso 3: preparando el proyectil

Ahora vamos a modificar un poco nuestro juego, de tal manera que podamos aumentar o disminuir tanto el angulo como la velocidad de disparo.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/07/14/tutorial-pygame-4-figuras-y-texto

# ---------------------------
# Importación de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys

# -----------
# Constantes
# -----------

WIDTH = 640
HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


class Proyectil(pygame.sprite.Sprite):
    "Clase que representa el proyectil lanzado"

    def __init__(self, x, y):
        self.angulo = 45
        self.veloc = 50
        self.tiempo = 0
        self.x = x
        self.y = y
        self.disparar = False
        self.xreal = x
        self.yreal = HEIGHT - self.y

    def update(self):
        "actualizar la posición del proyectil"

        if self.disparar == True:
            # esta en movimiento, hay que actualizar la posición
            pass
        else:
            # se mantiene sin disparar, por lo cual no se hace nada
            pass

        # si sale de la pantalla reiniciar la posición (a inferior izq.)
        if (self.y > HEIGHT) or (self.x > WIDTH):
            self.x = 0
            self.y = HEIGHT
            self.disparar = False

# ------------------------------
# Función principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 4")

    # se define la letra por defecto
    fuente = pygame.font.Font(None, 20)

    # se crea un proyectil a lanzar
    bala = Proyectil(0, HEIGHT)

    pygame.key.set_repeat(1, 80)  # Activa repetición de teclas

    # el bucle principal del juego
    while True:
        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    if bala.angulo < 90:
                        bala.angulo = bala.angulo + 1
                elif event.key == K_DOWN:
                    if bala.angulo > 0:
                        bala.angulo = bala.angulo - 1
                elif event.key == K_RIGHT:
                    if bala.veloc < 100:
                        bala.veloc = bala.veloc + 1
                elif event.key == K_LEFT:
                    if bala.veloc > 10:
                        bala.veloc = bala.veloc - 1
                elif event.key == K_SPACE:
                    bala.disparar = True
                elif event.key == K_ESCAPE:
                    sys.exit()

        # Actualizar la posición e información
        bala.update()
        text = "Velocidad: %3d (m/s)   Angulo: %d   x=%d m   y=%d m" % (
            bala.veloc, bala.angulo, bala.xreal, bala.yreal)
        mensaje = fuente.render(text, 1, (255, 255, 255))

        # Re dibujar los elementos en pantalla
        screen.fill((30, 145, 255))
        screen.blit(mensaje, (15, 5))
        pygame.draw.line(screen, (255, 255, 255), (0, 25), (640, 25), 2)
        pygame.draw.circle(screen, (0, 0, 0), (int(bala.x), int(bala.y)), 10)
        # actualizamos la pantalla
        pygame.display.flip()


if __name__ == "__main__":
    main()

El código es bastante sencillo, en la parte en donde se detecta que teclas se han pulsado se limita la velocidad y angulo de disparo de la siguiente manera: Al pulsar la flecha hacia arriba que se aumente el angulo (hasta un máximo de 90 grados (sexagesimales), o sea un angulo recto) y la flecha hacia abajo lo disminuye hasta un angulo de 0 grados. Mientes que a la derecha se aumenta la velocidad (hasta un máximo de 100) y a la izquierda se disminuye la velocidad (hasta un mínimo de 10).

Dentro de la clase proyectil (o sea la bala) se ha definido un metodo update (que después es utilizado en el while True) y que va actualizando la posición del proyectil en la pantalla. En este método se agrega una comprobación de tal manera que si el proyectil sale de la pantalla los valores se reinicien

Si se fijan el valor por defecto para self.disparar es False. De esta manera al pulsar a barra espaciadora se dispara el proyectil (cambiando el valor de disparar a True), por lo que al llamar el bala.update() se va calculando la nueva posición de la bala (a continuación se explicara como obtener la nueva posición)

Un poco de física

Antes de continuar hay que entender la base del lanzamiento de proyectiles, la cual voy a intentar explicarla de una manera sencilla a continuación.

Voy a considerar el punto (0,0) “el origen” como la esquina inferior izquierda, para que se mantengan las ecuaciones de la misma forma en que se encontrarían en un libro (después se va a ajustar el valor para que corresponda con el de pygame)

Como se trata de un lanzamiento de proyectiles, podemos aplicar algunos supuestos para simplificar el problema:

• la vaca es esférica y sin rozamiento
• No tendremos en cuenta el efecto de rotación de la Tierra (que desvía el proyectil)
• La velocidad del proyectil es suficientemente pequeña como para despreciar la resistencia que presenta el aire en oposición a su movimiento (roce)
• La aceleración de gravedad g es constante (no varia su valor con la altura ni con curvatura de la superficie terrestre)

Entonces tenemos (de forma simplificada) las siguientes ecuaciones para determinar la posición (en cualquier momento) de un objeto en el eje x e y:

Como en nuestro caso, el objeto a lanzar (la esfera o proyectil) esta inicialmente en el origen (0,0) por lo cual:
e

Además la única aceleración que afecta el proyectil es la gravedad (y que solo influye de manera vertical), por lo tanto en este caso queda:

Esto es una parábola. Si consideraremos a la aceleración de gravedad con un valor de g = -9,8 (el signo menos es porque actúa hacia abajo) y la velocidad con la que se lanza el proyectil es un vector (que depende del ángulo y su valor), por lo que hay que descomponerla en sus componentes horizontal () y vertical ():

Ya que es un vector la suma de sus componentes (horizontal y vertical) da el valor del modulo del vector. Además el modulo del vector con las componentes de este en el eje x e y forman un triangulo, por lo que aplicando trigonometría se puede determinar los valores de los componentes horizontal y vertical:

En la imagen se aprecia el triangulo que se forma, así tenemos las siguientes razones trigonometricas:

Despejando tenemos:

Con lo cual se puede obtener la componente en ambos ejes de la velocidad.

Así en resumen, el proyectil tendrá el siguiente comportamiento:

• De forma horizontal solo depende de la velocidad (que es constante), por lo que se moverá en este caso hacia la derecha
• De forma vertical tenemos a la velocidad que lo impulsa hacia arriba y la gravedad que se opone (hacia abajo). Por lo cual el proyectil en un inicio comenzara a subir, pero luego por la aceleración de gravedad comenzara a caer (el tiempo esta al cuadrado en el segundo termino, por lo cual al aumentar t (el tiempo), la aceleración por el tiempo al cuadrado terminara superando a la velocidad por el tiempo y en ese instante empezara a caer)

Paso 4: Movimiento del proyectil

Ahora aplicamos lo anterior en nuestro programa, por lo que modificamos el método update para que a medida que trascurre el tiempo calcule la posición del proyectil, por lo la versión final de nuestro juego / simulador queda de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/07/14/tutorial-pygame-4-figuras-y-texto

# ---------------------------
# Importación de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys
import math

# -----------
# Constantes
# -----------

WIDTH = 640
HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


class Proyectil(pygame.sprite.Sprite):
    "Clase que representa el proyectil lanzado"

    def __init__(self, x, y):
        self.angulo = 45
        self.veloc = 50
        self.tiempo = 0
        self.x = x
        self.y = y
        self.disparar = False
        self.xreal = x
        self.yreal = HEIGHT - self.y

    def update(self):
        "actualizar la posición del proyectil"
        self.velocx = self.veloc * math.cos(math.radians(self.angulo))
        self.velocy = self.veloc * math.sin(math.radians(self.angulo))

        if self.disparar == True:
            # esta en movimiento, hay que actualizar la posición
            self.xreal = (0 + self.velocx * self.tiempo)
            self.yreal = (0 + self.velocy * self.tiempo +
                (-9.8 * (self.tiempo ** 2)) / 2)
            # Corregir la posición en el eje vertical
            self.x = self.xreal
            self.y = HEIGHT - self.yreal
        else:
            # se mantiene sin disparar, por lo cual no se hace nada
            pass

        # si sale de la pantalla reiniciar la posición (a inferior izq.)
        if (self.y > HEIGHT) or (self.x > WIDTH):
            self.x = 0
            self.y = HEIGHT
            self.tiempo = 0
            self.disparar = False

# ------------------------------
# Función principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 4")

    # se define la letra por defecto
    fuente = pygame.font.Font(None, 20)

    # se crea un proyectil a lanzar
    bala = Proyectil(0, HEIGHT)

    pygame.key.set_repeat(1, 80)  # Activa repetición de teclas
    clock = pygame.time.Clock()

    # el bucle principal del juego
    while True:
        # registramos cuanto ha pasado desde el ultimo ciclo
        tick = clock.tick(60)
        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    if bala.angulo < 90 and bala.disparar == False:
                        bala.angulo = bala.angulo + 1
                elif event.key == K_DOWN:
                    if bala.angulo > 0 and bala.disparar == False:
                        bala.angulo = bala.angulo - 1
                elif event.key == K_RIGHT:
                    if bala.veloc < 100 and bala.disparar == False:
                        bala.veloc = bala.veloc + 1
                elif event.key == K_LEFT:
                    if bala.veloc > 10 and bala.disparar == False:
                        bala.veloc = bala.veloc - 1
                elif event.key == K_SPACE:
                    bala.disparar = True
                elif event.key == K_ESCAPE:
                    sys.exit()

        if bala.disparar == True:
            # al tiempo anterior le sumamos lo transcurrido
            bala.tiempo = bala.tiempo + (tick / 1000.0)

        # Actualizar la posición e información
        bala.update()
        text = "Velocidad: %3d (m/s)   Angulo: %d   x=%d m   y=%d m" % (
            bala.veloc, bala.angulo, bala.xreal, bala.yreal)
        mensaje = fuente.render(text, 1, (255, 255, 255))

        # Re dibujar los elementos en pantalla
        screen.fill((30, 145, 255))
        screen.blit(mensaje, (15, 5))
        pygame.draw.line(screen, (255, 255, 255), (0, 25), (640, 25), 2)
        pygame.draw.circle(screen, (0, 0, 0), (int(bala.x), int(bala.y)), 10)
        # actualizamos la pantalla
        pygame.display.flip()


if __name__ == "__main__":
    main()

Si se fijan ahora iniciamos un reloj (modulo time) clock = pygame.time.Clock() y luego al comienzo del while True registramos cuanto tiempo (en milisegundos) han pasado desde la llamada anterior del clock.tick (en la parte anterior del tutorial explique que tick devuelve el tiempo que ha pasado entre llamadas), por ello hacemos: tick = clock.tick(60)

Observación: Use tick = clock.tick(60) pero es igual de valido (y funciona de la misma manera) si se usa tick = clock.tick() ya que ambas devuelven el tiempo trascurrido y en este caso la sincronización del movimiento de los objetos en el juego depende del tiempo (y no del framerate)

El principal motivo para haber usado clock.tick(60) es que de esta manera se controla el framerate (a la vez que se obtiene cuantos milisegundos han pasado), así si tienen un equipo muy potente, podemos limitar como corre el juego y que no ocupe todo los recursos del equipo al ejecutarse (cosa que se agradece). Para que se hagan una idea al usar clock.tick() el juego estaba usando los dos nucleos de mi CPU al 100% y alcanzaba unos frames bestiales (y que no eran necesarios), en cambio clock.tick(60) el movimiento era igual de fluido y el procesador estaba al funcionando al mínimo.

Volviendo al tema, ya que en el tick esta almacenado el tiempo que ha pasado entre llamadas, ahora simplemente se comprueba si se ha disparado la bala y si es así hay que sumar el tiempo trascurrido al que se tenia registrado (que inicialmente era 0 y que en cada ciclo del juego va aumentando), o sea esto:

if bala.disparar == True:
    bala.tiempo = bala.tiempo + (tick / 1000.0)

Nota: Se divide por 1000.0 para transformar el tiempo del tick desde milisegundos a segundos (ya que la velocidad esta dada en m/seg). Se usa 1000.0 en vez de 1000 para que los resultados sean decimales (punto flotante).

Ahora en la clase del proyectil, se modifica el método update para que calcule la posición del proyectil, de la siguiente manera:

    def update(self):
        "actualizar la posición del proyectil"
        self.velocx = self.veloc * math.cos(math.radians(self.angulo))
        self.velocy = self.veloc * math.sin(math.radians(self.angulo))

        if self.disparar == True:
            # esta en movimiento, hay que actualizar la posición
            self.xreal = (0 + self.velocx * self.tiempo)
            self.yreal = (0 + self.velocy * self.tiempo +
                (-9.8 * (self.tiempo ** 2)) / 2)
            # Corregir la posición en el eje vertical
            self.x = self.xreal
            self.y = HEIGHT - self.yreal

Primero se calcula la componente de la velocidad en el eje x (self.velocx) e eje y (self.velocy), para ello se multiplica la velocidad (self.veloc) por el coseno (math.cos) y seno (math.sin) de angulo respectivamente. Eso si el angulo inicial lo tenemos en grados (sexagesimal) y las funciones math.sin y math.cos trabajan en radianes, por lo que usamos la función math.radians para pasar de grados a radianes (aunque también podríamos haber trabajado desde un comienzo en radianes, pero eso le hubiera quitado la gracia al ejemplo).

Luego para calcular la posición teórica de la bala usamos las ecuaciones que se mencionaron en la explicación física, o sea:

Que aplicadas en nuestro código quedan:

self.xreal = (0 + self.velocx * self.tiempo)
self.yreal = (0 + self.velocy * self.tiempo + (-9.8 * (self.tiempo ** 2)) / 2)

y posteriormente corregimos la posición para que se ajuste al sentido de los ejes que usa pygame; la posición en el eje x se deja igual self.x = self.xreal y la posición en el eje y se invierte self.y = HEIGHT – self.yreal

Por ultimo en la entrada del teclado se pone una comprobación extra para que no se puedan modificar los datos mientras el proyectil esta en movimiento.

Bueno eso es todo por ahora, pueden descargar todos estos ejemplos desde aquí (o buscarlo en el repositorio de github)

En la siguiente parte vamos a crear el clásico juego (estilo Shoot ‘em up) de la nave que va disparando y eliminando a los enemigos que aparecen en pantalla

Por ejemplo al hacer una búsqueda en google:

from urllib import urlopen
pag = urlopen("http://www.google.com/search?q=python")
print pag.read()

[...]<H1>Forbidden</H1>Your client does not have permission to get URL <code>/search?q=python</code> from this server.[...]

Ahora si abrimos el interprete en modo interactivo y hacemos:

>>> from urllib import URLopener
>>> URLopener.version
'Python-urllib/1.17'

Para cambiarlo por otro valor, consultamos la documentacion de python que nos dice:

To override this functionality, programmers can create a subclass of URLopener or FancyURLopener, then assign an instance of that class to the urllib._urlopener variable before calling the desired function.

Con esto en mente hacemos una pequeña clase que hace el cambio, en donde le señalamos un nuevo user agent (en el ejemplo voy a usar el de IE7, aunque si quieren otros pueden buscar por aquí), quedando el ejemplo de esta manera:

from urllib import FancyURLopener

class MyOpener(FancyURLopener):
    version = 'Mozilla/5.0 (Windows; U; MSIE 7.0; Windows NT 6.0; en-US)'

myopener = MyOpener()
pag = myopener.open("http://www.google.com/search?q=python")
print pag.read()

[...]Results <b>1</b> - <b>10</b> of about <b>36,400,000</b> for <b>python</b> [...]

Claro que se puede usar con cualquier otro metodo de urllib, como por ejemplo con retrieve (para descargar la pagina con los resultados de la búsqueda, en vez de ver el html):

from urllib import FancyURLopener

class MyOpener(FancyURLopener):
    version = 'Mozilla/5.0 (Windows; U; MSIE 7.0; Windows NT 6.0; en-US)'

myopener = MyOpener()
myopener.retrieve("http://www.google.com/search?q=python", "resultados.html")

Divertido, ¿o no?

En esta parte trataremos los siguientes puntos:

• Crear una función para cargar imágenes
• Como crear sprites (los sprites son personajes, objetos, etc. dentro del juego)
• Sincronización de elementos en los videojuegos (¿que son frames por segundo?)
• Controlar un sprite con el teclado
• Controlar un sprite con el mouse
• Colisiones entre elementos (sprites)
• Inteligencia artificial (o la falta de esta)
• reproducción de sonidos (al cumplirse alguna condición)

Para este tutorial me voy a basar en el primer juego que escribí en pygame hace mucho tiempo (que por cierto tenia algunos errores), el cual a su vez se basaba en un ejemplo de linuxjuegos (aun más antiguo). En resumen voy reescribir el juego, simplificándolo y de paso voy a explicar como funciona:

Paso 1: Creando lo básico (y una función para cargar imágenes)

Lo primero es crear la ventana y una función para cargar las imágenes.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos el fondo
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)

    # el bucle principal del juego
    while True:
        #actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        pygame.display.flip()

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()


if __name__ == "__main__":
    main()

Creamos una función para cargar imágenes por comodidad, así se facilita cargar distintos tipos de imágenes a la vez que realiza los convert() según corresponda. La función trabaja de la siguiente manera: toma tres parámetros el nombre, el directorio donde se encuentra la imagen y si tiene o no un canal alpha (el color transparente del los png). Luego con esa información (directorio + nombre imagen) crea la ruta de la imagen y intenta abrirla con un try que es como “espera, voy a probar abrir la imagen… y si algo falla (except), avisa y termina el programa”. Después de eso revisa si la imagen tiene un cana alpha (if alpha == True), en ese caso realiza el .convert_alpha(), en caso contrario realiza un simple .convert() . Finalmente devuelve la superficie (“surface”) que se crea al cargar la imagen.

Luego en la función principal del juego se carga la imagen del fondo y se muestra en pantalla. Si se fijan hay una variable llamada IMG_DIR, esta indica el nombre del directorio donde se encuentran las imágenes.

Nota: usaremos estas imágenes en el tutorial:

bola.png

paleta.png

fondo.jpg (hacer click para agrandar)

Paso 2: Creando sprites

En el tutorial anterior ya hable algo de los sprites y les recomende leer esto (que explica los conceptos básicos de los videojuegos). Ahora vamos a profundizar en los sprites.

Un sprite es básicamente cualquier cosa que aparezca en nuestro juego (personajes, objetos, etc.) la cual tiene asociada informacion (como su posición, tamaño, etc.). En pygame es costumbre hacer una clase para cada sprite, de tal manera que la clase contenga la información relevante de ese sprite.

En este caso vamos a crear la clase Pelota, que va a contener todos los datos de la pelota usada en el juego. Esta primera versión de la pelota, solo rebotará indistintamente en las cuatro murallas de nuestra pantalla. Veamos el código:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    bola = Pelota()

    # el bucle principal del juego
    while True:
        #actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        pygame.display.flip()

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()


if __name__ == "__main__":
    main()

Ahora dentro de la clase Pelota() vemos que hereda los metodos de la clase padre pygame.sprite.Sprite, luego en el def __init__(self): se define que se hará cuando se llama al instanciar la clase. (una explicación mas completa por aquí). En nuestro caso se le dice primero que inicie pygame.sprite.Sprite (algo un poco raro pero obligatorio), luego en self.image cargamos la imagen (algo conocido, ya que lo hemos hecho antes).

Nota: self se usa para referirse la clase actual en la que se está, en otras palabras para una clase es como referirse a si misma (algo común en las clases)

Con self.image.get_rect() se obtiene un objeto rectangulo (rect) con las dimensiones y posición de la imagen (en este caso se usa sobre self.image, o sea la imagen de la bola) y este rectángulo se lo asignamos a self.rect. Esto resulta bastante útil, ya que nos permite dejar de preocuparnos por las dimensiones de la imagen por si luego decidimos cambiarlas, además de obtener algunos extras que se señalan a continuación:

Ahora el rectangulo creado con get_rect() nos permite usar varios varios atributos virtuales que se pueden usar para mover o alinear el rectángulo (y que usaremos a continuación). Entre ellos:

• top, left, bottom, right
• topleft, bottomleft, topright, bottomright
• midtop, midleft, midbottom, midright
• center, centerx, centery
• size, width, height
• w,h

Ahora con self.rect.centerx y self.rect.centery le indicamos a pygame que el centro de nuestra imagen (centerx, centery) quede exactamente en la mitad de la pantalla (o sea centramos la imagen)

Por ultimo en self.speed se establece la velocidad con que se mueva la pelota en el eje x y en el eje y (en la siguiente parte se vera para que lo vamos a usar)

Intermedio: un poco de teoría, sincronización en los videojuegos

Antes de continuar, hay que mencionar algo sobre la forma de sincronizar los videojuegos, lo cual es necesario, ya que si llegamos y ejecutamos nuestro videojuego en un computador antiguo, por ejemplo en un Pentium II, es posible que el videojuego se vea muy lento, en cambio si lo ejecutamos en un computador más potente (de ultima generación), el juego se verá tan rápido que será imposible jugar.

Hay dos formas de sincronización:

Sincronización por Framerate o Frames per Second (FPS): En este caso se refiere a la frecuencia con que se ejecuta el ciclo principal de un videojuego en un segundo (mientras más alto, más fluidez).

Básicamente se va obteniendo el tiempo que ha trascurrido desde el inicio del ciclo, se hacen las acciones del juego y cuando pasen los FPS especificados, se actualiza/refresca la pantalla. Así se logra una fluidez constante sin importar en que equipo se ejecute

Este es uno de los metodos mas extendidos (especialmente en juegos en 2D). Claro que este método tiene sus ventajas y desventajas:

• A favor: ya que limitamos la cantidad máxima de FPS que puede lograr el juego, este debería verse de la misma forma en cualquier computador en donde se corra, ya que si el equipo es muy potente solo funcionara a los FPS especificados (pese a que puede ir mas rápido)
• En contra: al usar este método en computadores más rápidos (que el pc donde se desarrollo) el juego se verá fluido, pero si lo ejecutamos en una máquina con un procesador mucho más antiguo del que usamos para desarrollarlo, lo más probable es que se vea bastante lento (por algo hay requerimientos mínimos)

Sincronización por Tiempo: En este caso se sincroniza en base al tiempo (por lo que no importan los FPS) moviéndose de igual manera los objetos sin importar en que equipo se ejecute el juego (ya que el movimiento depende del tiempo transcurrido).Ya que lo que se hace es calcular la posición de un objeto en función del tiempo transcurrido.

Este método se usa bastante en videojuegos 3D, ya que el framerate varía mucho en cada ciclo

• A favor: Los objetos/sprites se mueven siempre a la misma velocidad, sin importar cuantos FPS se alcancen (ya que su movimiento es en función del tiempo), por lo cual no hay que preocuparse de controlar el framerate
• En contra: Pese a que los objetos se mueven siempre a la misma velocidad, en un computador más lento el desplazamiento no se verá fluidamente, por ejemplo en caso (extremo) de que se demore el juego 1 segundo en cada ciclo, cada vez que se deba mover un objeto este se desplazara grandes distancias (ya que el tiempo entre actualizaciones/ciclos en donde se refrezca la pantalla es grande), produciéndose un salto muy notorio

Si en el primer método (FPS) queríamos mover un objeto 8 pixeles, haríamos lo siguiente:

x = x + 8

En cambio si lo hacemos en base al tiempo tendríamos:

x = x + (velocidad)*(tiempo)

O sea física básica, en donde por ejemplo si se desplaza el objeto a una velocidad de 0.008, y el ciclo demora 1 segundo en ejecutarse (1000ms), el nuevo incremento será de:

x = x + 0.008*1000
x = x + 8

Ok, volvamos con nuestro juego.

Parte 3: Moviendo la pelota (y creando un reloj)

Volviendo al juego (el cual va a usar el método de los FPS), vamos a crear dentro de la clase Pelota una función update, que se encargará de hacer avanzar la bola y que seta rebote cuando haya llegado a los límites de la pantalla.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))

# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    bola = Pelota()

    clock = pygame.time.Clock()

    # el bucle principal del juego
    while True:
        clock.tick(60)
        bola.update()

        #actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        pygame.display.flip()

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()


if __name__ == "__main__":
    main()

Los dos if sirven para comprobar si la pelota alcanzo los bordes de la pantalla, si esto ocurre que comience a moverse en sentido contrario (por ejemplo si llego a topar el borde derecho, la pelota comenzara a moverse a la izquierda, lo mismo para los otros bordes)

La función move_ip(x,y) mueve de forma relativa el sprite por pantalla, esto es, subirá o bajará x pixel y avanzará retrocederá y pixel. (en este caso utilizara la velocidad que definimos anteriormente para la bola, moviendola 3pixeles hacia la derecha y abajo)

Ahora en la función principal del juego tenemos una linea que inicia la clase bola = Pelota() y luego de esto una linea que crea un reloj que controle el tiempo del juego clock = pygame.time.Clock(), el cual se ejecuta justo antes de iniciar el bucle principal del juego.

Luego se esto en la función principal hacemos clock.tick(60), lo cual sirve para poner el reloj a un paso de 60 FPS, esto se hace para que nunca se pase de 60 frames por segundo, así no importará si estamos ejecutando esto en un pentium II o en una supercomputadora, la velocidad siempre será como máximo de 60 frames por segundo.

Finalmente con bola.update() se actualiza la posición de la pelota y luego se redibuja la pantalla

Clock.tick es bastante curioso, si se usa sin argumentos (o sea clock.tick()) devuelve el tiempo que ha pasado (en milisegundos) desde la ultima vez que se llamo (o sea funciona como un reloj), pero si se usa con un argumento, que es el framerate (por ejemplo clock.tick(60)), la función esperará el tiempo necesario para mantener al juego corriendo a la velocidad solicitada, o sea en el ejemplo el juego nunca correrá a más de 60 frames/cuadros por segundo (sirve para controlar el framerate).

Eso si este método no es muy exacto, pero casi no usa CPU, si se quiere algo mas exacto hay que usar Clock.tick_busy_loop (más información en la documentación de pygame)

Parte 4: Creando la paleta (control con teclado)

No hay grandes cambios, lo primero que se hace es crear una clase que contenga la paleta y en la función principal hay que revisar si se ha pulsado alguna de las teclas indicadas (y actuar de acuerdo a ella). El código queda:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))


class Paleta(pygame.sprite.Sprite):
    "Define el comportamiento de las paletas de ambos jugadores"

    def __init__(self, x):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("paleta.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.centery = SCREEN_HEIGHT / 2

    def humano(self):
        # Controlar que la paleta no salga de la pantalla
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    bola = Pelota()
    jugador1 = Paleta(40)

    clock = pygame.time.Clock()

    # el bucle principal del juego
    while True:
        clock.tick(60)

        # Actualizamos los obejos en pantalla
        jugador1.humano()
        bola.update()

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    jugador1.rect.centery -= 5
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 5
                elif event.key == K_ESCAPE:
                    sys.exit(0)
            elif event.type == pygame.KEYUP:
                if event.key == K_UP:
                    jugador1.rect.centery += 0
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 0

        #actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        screen.blit(jugador1.image, jugador1.rect)
        pygame.display.flip()


if __name__ == "__main__":
    main()

Se define la clase paleta de manera analoga a la clase pelota, la única diferencia es que el def __init__(self, x) recibe como argumento adicional la coordenada x de la paleta (así con la misma clase se puede cargar una paleta a la izquierda y otra a la derecha), en cuanto a la coordenada y (en eje vertical), esta clase deja centrada la paleta (verticalmente)

Después dentro de la clase se define un: def humano(self), que simplemente es lo que hace la paleta cuando es controlada por un jugador (humano), en este caso lo único que hace es que si alcanza el borde superior o inferior en el eje y (eje vertical), deje de moverse, para que no se salga de pantalla (algo no muy grato)

En la función principal del juego, se inicia la clase jugador1 = Paleta(25) para crear la paleta controlada por el jugador (el 25 es para que la paleta quede a 25 píxeles del borde izquierdo) y un poco más adelante se le indica que esa paleta se controlada por una persona (humana) jugador1.humano(), el resto es actualizar la pantalla.

Dentro del bucle se comprueba los eventos (en la parte de for event in pygame.event.get():), así cada vez que se pulsa una tecla (del teclado) se obtiene un evento pygame.KEYDOWN y cada vez que se suelta una tecla se produce un evento pygame.KEYUP. Esos eventos devuelven el valor de la tecla pulsada (se puede revisar los posibles valores en la documentación)

Así que simplemente se revisa dentro del evento pygame.KEYDOWN que tecla se pulso, si se trata de la tecla flecha hacia arriba (K_UP) la paleta se desplaza 5 píxeles hacia arriba y si se trata de la tecla flecha hacia abajo (K_DOWN) se desplaza 5 píxeles hacia abajo. En el caso de que puse la tecla K_ESCAPE simplemente se termina el programa

Una revisión similar se hace cuando se sueltan las teclas (pygame.KEYUP) en donde se deja de mover la paleta. En este juego no tiene mucho sentido hacer esto (ya que por defecto la paleta esta quieta) pero en otros juegos puede servir, por eso lo puse (pese a no ser necesario).

Dentro de pygame.key existe el método get_pressed() que devuelve una lista con todas las teclas pulsadas, usar esto puede ser mas simple que ir comprobando una por una las teclas pero tiene como inconveniente que:

• no hay forma de conocer el orden de las teclas pulsadas
• las pulsaciones muy rápidas de teclas pueden pasar desapercibidas

Parte 5: mejorando el control con el teclado (y el mouse)

Si se fijaron el código anterior tiene un problema, al mantener pulsada una tecla (flecha hacia arriba o abajo) el programa solo mueve la paleta una vez (solo registra una vez el evento), en vez de mantenerse moviendo la paleta hasta que se suelte la tecla. Además falta poder controlar la paleta con el mouse.

Para lo primero, hay que indicarle a pygame que active la repetición de teclas, lo cual se hace con la función pygame.key.set_repeat(), esta toma dos argumentos: el primero establece el tiempo de retraso (el número de milisegundos) que tienen que pasar para detectar/enviar el primer evento y el segundo argumento (el intervalo) es el numero de milisegundos que pasan entre cada envío del evento.

Para conocer el estado del mouse, hay que usar pygame.mouse, para ello lo primero que haremos es que el cursor del mouse no se vea dentro de la pantalla (o sea que solo aparezca fuera de ella) seo lo hacemos con pygame.mouse.set_visible(False)

Luego dentro de nuestro bucle, registramos la posición del mouse con pos_mouse = pygame.mouse.get_pos(), que nos devuelve una tupla con las coordenadas (x, y) en donde esta el puntero del mouse, las que quedan almacenadas en pos_mouse. Luego usamos mov_mouse = pygame.mouse.get_rel() para obtener cuanto se ha movido el mouse desde la ultima consulta que realizo get_rel() (esto tambien es una tupla, del tipo (x,y) que devueve la distancia que se ha movido),en caso de que el puntero del mouse no se haya movido devlvera un (0,0).

elif mov_mouse[1] != 0:
   jugador1.rect.centery = pos_mouse[1]

Avanzamos un poco y en la parte en donde comprobamos los eventos, usamos un if mov_mouse[1] != 0:, con esto el deciomos que si la coordenada y de la tupla que devuelve get_rel() es distinta de 0, mueva la paleta a la posición en donde esta el mouse (jugador1.rect.centery = pos_mouse[1])

Entonces nuestro codigo queda como:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))


class Paleta(pygame.sprite.Sprite):
    "Define el comportamiento de las paletas de ambos jugadores"

    def __init__(self, x):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("paleta.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.centery = SCREEN_HEIGHT / 2

    def humano(self):
        # Controlar que la paleta no salga de la pantalla
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    bola = Pelota()
    jugador1 = Paleta(40)

    clock = pygame.time.Clock()
    pygame.key.set_repeat(1, 25)  # Activa repeticion de teclas
    pygame.mouse.set_visible(False)

    # el bucle principal del juego
    while True:
        clock.tick(60)
        # Obtenemos la posicon del mouse
        pos_mouse = pygame.mouse.get_pos()
        mov_mouse = pygame.mouse.get_rel()

        # Actualizamos los obejos en pantalla
        jugador1.humano()
        bola.update()

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    jugador1.rect.centery -= 5
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 5
                elif event.key == K_ESCAPE:
                    sys.exit(0)
            elif event.type == pygame.KEYUP:
                if event.key == K_UP:
                    jugador1.rect.centery += 0
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 0
            # Si el mouse no esta quieto mover la paleta a su posicion
            elif mov_mouse[1] != 0:
                jugador1.rect.centery = pos_mouse[1]

        # actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        screen.blit(jugador1.image, jugador1.rect)
        pygame.display.flip()


if __name__ == "__main__":
    main()

Parte 6: Colisiones

Hasta ahora al encontrarse la pelota con la paleta, simplemente esta pasa por detras sin rebotar en la paleta, eso occure porque no hemos especificado que tiene que pasar cuando se producen colisiones, o sea cuando dos sprites chocan.

Para esto dentro de la clase de uno de los sprites hay que crear un método que compruebe si este sprite ha chocado con otros, por conveniencia lo vamos a colocar en la clase Pelota (ya que esta es la que rebota en las otras cosas).

En la clase Pelota definimos def colision(self, objetivo): el cual comprueba si la pelota ha chocado con algo (el segundo argumento es el objeto con el cual esperamos que choque).

Para saber si dos sprites/objetos han chocado usamos pygame.sprite.colliderect(objeto1, objeto2) este comprueba si el rectángulo del objeto1 entra en contacto con el rectángulo del objeto2, retornando True en caso de que entren en contacto. Luego simplemente cambiamos la dirección de la pelota

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))

    def colision(self, objetivo):
        if self.rect.colliderect(objetivo.rect):
            self.speed[0] = -self.speed[0]


class Paleta(pygame.sprite.Sprite):
    "Define el comportamiento de las paletas de ambos jugadores"

    def __init__(self, x):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("paleta.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.centery = SCREEN_HEIGHT / 2

    def humano(self):
        # Controlar que la paleta no salga de la pantalla
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    bola = Pelota()
    jugador1 = Paleta(40)

    clock = pygame.time.Clock()
    pygame.key.set_repeat(1, 25)  # Activa repeticion de teclas
    pygame.mouse.set_visible(False)

    # el bucle principal del juego
    while True:
        clock.tick(60)
        # Obtenemos la posicon del mouse
        pos_mouse = pygame.mouse.get_pos()
        mov_mouse = pygame.mouse.get_rel()

        # Actualizamos los obejos en pantalla
        jugador1.humano()
        bola.update()

        # Comprobamos si colisionan los objetos
        bola.colision(jugador1)

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    jugador1.rect.centery -= 5
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 5
                elif event.key == K_ESCAPE:
                    sys.exit(0)
            elif event.type == pygame.KEYUP:
                if event.key == K_UP:
                    jugador1.rect.centery += 0
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 0
            # Si el mouse no esta quieto mover la paleta a su posicion
            elif mov_mouse[1] != 0:
                jugador1.rect.centery = pos_mouse[1]

        # actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        screen.blit(jugador1.image, jugador1.rect)
        pygame.display.flip()


if __name__ == "__main__":
    main()

Parte 7: Comportamiento del oponente (crear al enemigo)

Ahora vamos a crear al enemigo, para esto vamos a modificar la clase Paleta, agregando el método cpu (que sera el segundo jugador controlado por el computador)

def cpu(self, objetivo):
    self.rect.centery = objetivo.rect.centery
    if self.rect.bottom >= SCREEN_HEIGHT:
        self.rect.bottom = SCREEN_HEIGHT
    elif self.rect.top <= 0:
        self.rect.top = 0

Básicamente definimos dentro de la clase Paleta un def cpu(self, objetivo): en donde se le dice a la paleta que siga la posición de la pelota (o sea que se mueva junto con ella) haciendo un self.rect.centery = objetivo.rect.centery (o sea la posición vertical de la paleta es igual a la posición vertical de la pelota), además comprobamos que la paleta no se salga de la pantalla

El resto es crear y mostrar la paleta del jugador 2 (que es controlado por el computador), que es análogo a lo hecho anteriormente, quedando:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))

    def colision(self, objetivo):
        if self.rect.colliderect(objetivo.rect):
            self.speed[0] = -self.speed[0]


class Paleta(pygame.sprite.Sprite):
    "Define el comportamiento de las paletas de ambos jugadores"

    def __init__(self, x):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("paleta.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.centery = SCREEN_HEIGHT / 2

    def humano(self):
        # Controlar que la paleta no salga de la pantalla
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0

    def cpu(self, objetivo):
        self.rect.centery = objetivo.rect.centery
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0

# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    bola = Pelota()
    jugador1 = Paleta(40)
    jugador2 = Paleta(SCREEN_WIDTH - 40)

    clock = pygame.time.Clock()
    pygame.key.set_repeat(1, 25)  # Activa repeticion de teclas
    pygame.mouse.set_visible(False)

    # el bucle principal del juego
    while True:
        clock.tick(60)
        # Obtenemos la posicon del mouse
        pos_mouse = pygame.mouse.get_pos()
        mov_mouse = pygame.mouse.get_rel()

        # Actualizamos los obejos en pantalla
        jugador1.humano()
        jugador2.cpu(bola)
        bola.update()

        # Comprobamos si colisionan los objetos
        bola.colision(jugador1)
        bola.colision(jugador2)

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    jugador1.rect.centery -= 5
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 5
                elif event.key == K_ESCAPE:
                    sys.exit(0)
            elif event.type == pygame.KEYUP:
                if event.key == K_UP:
                    jugador1.rect.centery += 0
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 0
            # Si el mouse no esta quieto mover la paleta a su posicion
            elif mov_mouse[1] != 0:
                jugador1.rect.centery = pos_mouse[1]

        # actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        screen.blit(jugador1.image, jugador1.rect)
        screen.blit(jugador2.image, jugador2.rect)
        pygame.display.flip()


if __name__ == "__main__":
    main()

Muy lindo el juego, pero esto tiene un problema; de la manera en que el jugador 2 esta programado es invencible, ya que el oponente siempre llega a la pelota (ya que se mueve junto a ella)

Parte 8: Sonidos básicos

Ahora vamos por los sonidos, quedando el código de esta manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"
SONIDO_DIR = "sonidos"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


def load_sound(nombre, dir_sonido):
    ruta = os.path.join(dir_sonido, nombre)
    # Intentar cargar el sonido
    try:
        sonido = pygame.mixer.Sound(ruta)
    except pygame.error, message:
        print "No se pudo cargar el sonido:", ruta
        sonido = None
    return sonido

# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self, sonido_golpe, sonido_punto):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]
        self.sonido_golpe = sonido_golpe
        self.sonido_punto = sonido_punto

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
            self.sonido_punto.play()  # Reproducir sonido de punto
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))

    def colision(self, objetivo):
        if self.rect.colliderect(objetivo.rect):
            self.speed[0] = -self.speed[0]
            self.sonido_golpe.play()  # Reproducir sonido de rebote


class Paleta(pygame.sprite.Sprite):
    "Define el comportamiento de las paletas de ambos jugadores"

    def __init__(self, x):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("paleta.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.centery = SCREEN_HEIGHT / 2

    def humano(self):
        # Controlar que la paleta no salga de la pantalla
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0

    def cpu(self, objetivo):
        self.rect.centery = objetivo.rect.centery
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0

# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    pygame.mixer.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    sonido_golpe = load_sound("tennis.ogg", SONIDO_DIR)
    sonido_punto = load_sound("aplausos.ogg", SONIDO_DIR)

    bola = Pelota(sonido_golpe, sonido_punto)
    jugador1 = Paleta(40)
    jugador2 = Paleta(SCREEN_WIDTH - 40)

    clock = pygame.time.Clock()
    pygame.key.set_repeat(1, 25)  # Activa repeticion de teclas
    pygame.mouse.set_visible(False)

    # el bucle principal del juego
    while True:
        clock.tick(60)
        # Obtenemos la posicon del mouse
        pos_mouse = pygame.mouse.get_pos()
        mov_mouse = pygame.mouse.get_rel()

        # Actualizamos los obejos en pantalla
        jugador1.humano()
        jugador2.cpu(bola)
        bola.update()

        # Comprobamos si colisionan los objetos
        bola.colision(jugador1)
        bola.colision(jugador2)

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    jugador1.rect.centery -= 5
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 5
                elif event.key == K_ESCAPE:
                    sys.exit(0)
            elif event.type == pygame.KEYUP:
                if event.key == K_UP:
                    jugador1.rect.centery += 0
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 0
            # Si el mouse no esta quieto, mover la paleta a su posicion
            elif mov_mouse[1] != 0:
                jugador1.rect.centery = pos_mouse[1]

        # actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        screen.blit(jugador1.image, jugador1.rect)
        screen.blit(jugador2.image, jugador2.rect)
        pygame.display.flip()


if __name__ == "__main__":
    main()

Lo primero que se se hace es crear una función que cargue los sonidos load_sound, es análoga a la función para cargar imágenes. Para abrir el archivo usamos el modulo pygame.mixer.Sound abriendo el sonido de la forma sonido = pygame.mixer.Sound(ruta)

Luego en el bucle principal del juego hay que iniciar el modulo mixer (que se encarga de los sonidos), haciendo pygame.mixer.init(). Luego simplemente se cargan los sonidos usando la función que se definio anterioremente, o sea:

sonido_golpe = load_sound("tennis.ogg", SONIDO_DIR)
sonido_punto = load_sound("aplausos.ogg", SONIDO_DIR)

Los cuales se le pasan luego a la clase pelota haciendo bola = Pelota(sonido_golpe, sonido_punto). Dentro de la clase pelota estos sonidos se almacenan en self.sonido_golpe y self.sonido_punto

Luego en la clase de la pelota usando Sound.play() se reproducen los sonidos. Así en el método colision() se le indica que si la pelota colisiona con una paleta reproduzca el archivo “tennis.ogg” (que se guardo en self.sonido_golpe) haciendo self.sonido_golpe.play() y en el método update() al llegar a los bordes izquierdo y derecho de la pantalla se reproduce unos aplausos haciendo self.sonido_punto.play()

Parte 9: Mejorando el juego (y modificar al oponente)

Nuestro juego tiene los siguientes problemas:

1. Al actualizar la pantalla, tenemos que cargar uno por uno los sprites (lo que no es muy ordenado), así que es mejor agruparlos
2. El oponente es invencible…
3. al marcar un punto, la bola debería volver al centro

Para lo primero es bastante fácil, simplemente juntamos los sprites de la forma todos = pygame.sprite.RenderPlain(bola, jugador1, jugador2) y luego los mostramos todos de una vez haciendo todos.draw(screen)

RenderPlain y RenderClear son alias para Group (se mantienen por compatibilidad), por lo tanto se manipulan igual que Group

Ok, ahora mejoramos al oponente (o más bien hay que modificarlo para que no sea invencible) quedando así:

def cpu(self, pelota):
    self.speed = [0, 2.5]
    if pelota.speed[0] >= 0 and pelota.rect.centerx >= SCREEN_WIDTH / 2:
        if self.rect.centery > pelota.rect.centery:
            self.rect.centery -= self.speed[1]
        if self.rect.centery < pelota.rect.centery:
            self.rect.centery += self.speed[1]

No es muy diferente de la versión anterior, pero en este caso se define una velocidad (que en el eje y es de 2.5, lo cual es menor a lo 3 de la pelota) y luego se comprueba que la pelota se mueva a la derecha (hacia la paleta) con pelota.speed[0] >= 0 y que la pelota haya pasado la mitad de la pantalla pelota.rect.centerx >= SCREEN_WIDTH / 2, si ambas condiciones se cumplen se comienza a mover la paleta (en caso contrario se queda quieta)

Ahora si se cumplen las condiciones para que se mueva la paleta, se compara la posición de la paleta con la pelota: si la pelota esta mas arriba que la paleta, esta ultima se mueve hacia arriba, por otro lado si la pelota esta abajo de la paleta, esta se mueve hacia abajo.

Con esto el oponente ya no es invencible, debido a que:

1. solo se mueve si la pelota se acerca a el y a pasado la mitad de la pantalla, por lo que el resto del tiempo esta quieto (y por lo tanto la posición de la paleta y la pelota no coinciden siempre)
2. la paleta se mueve mas lento que la pelota, por lo cual en tramos largos no es capaz de alcanzar a la pelota

Combinando ambas, el computador puede perder (pese a que la superficie de la paleta es mayor a la pelota)

Nota: esto no es Inteligencia artificial como tal, sino que es más cercano a un comportamiento predeterminado

Para el ultimo problema, simplemente en la parte en donde le actualiza la bola, luego de reproducir el sonido, reiniciamos la posición de la bola.

La versión final del juego queda de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/04/07/tutorial-pygame-3-un-videojuego/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"
SONIDO_DIR = "sonidos"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print "Error, no se puede cargar la imagen: ", ruta
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha == True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


def load_sound(nombre, dir_sonido):
    ruta = os.path.join(dir_sonido, nombre)
    # Intentar cargar el sonido
    try:
        sonido = pygame.mixer.Sound(ruta)
    except pygame.error, message:
        print "No se pudo cargar el sonido:", ruta
        sonido = None
    return sonido

# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self, sonido_golpe, sonido_punto):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]
        self.sonido_golpe = sonido_golpe
        self.sonido_punto = sonido_punto

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
            self.sonido_punto.play()  # Reproducir sonido de punto
            self.rect.centerx = SCREEN_WIDTH / 2
            self.rect.centery = SCREEN_HEIGHT / 2
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))

    def colision(self, objetivo):
        if self.rect.colliderect(objetivo.rect):
            self.speed[0] = -self.speed[0]
            self.sonido_golpe.play()  # Reproducir sonido de rebote


class Paleta(pygame.sprite.Sprite):
    "Define el comportamiento de las paletas de ambos jugadores"

    def __init__(self, x):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("paleta.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.centery = SCREEN_HEIGHT / 2

    def humano(self):
        # Controlar que la paleta no salga de la pantalla
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0

    def cpu(self, pelota):
        self.speed = [0, 2.5]
        if pelota.speed[0] >= 0 and pelota.rect.centerx >= SCREEN_WIDTH / 2:
            if self.rect.centery > pelota.rect.centery:
                self.rect.centery -= self.speed[1]
            if self.rect.centery < pelota.rect.centery:
                self.rect.centery += self.speed[1]


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    pygame.mixer.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Ejemplo de un Pong Simple")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    sonido_golpe = load_sound("tennis.ogg", SONIDO_DIR)
    sonido_punto = load_sound("aplausos.ogg", SONIDO_DIR)

    bola = Pelota(sonido_golpe, sonido_punto)
    jugador1 = Paleta(40)
    jugador2 = Paleta(SCREEN_WIDTH - 40)

    clock = pygame.time.Clock()
    pygame.key.set_repeat(1, 25)  # Activa repeticion de teclas
    pygame.mouse.set_visible(False)

    # el bucle principal del juego
    while True:
        clock.tick(60)
        # Obtenemos la posicon del mouse
        pos_mouse = pygame.mouse.get_pos()
        mov_mouse = pygame.mouse.get_rel()

        # Actualizamos los obejos en pantalla
        jugador1.humano()
        jugador2.cpu(bola)
        bola.update()

        # Comprobamos si colisionan los objetos
        bola.colision(jugador1)
        bola.colision(jugador2)

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    jugador1.rect.centery -= 5
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 5
                elif event.key == K_ESCAPE:
                    sys.exit(0)
            elif event.type == pygame.KEYUP:
                if event.key == K_UP:
                    jugador1.rect.centery += 0
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 0
            # Si el mouse no esta quieto, mover la paleta a su posicion
            elif mov_mouse[1] != 0:
                jugador1.rect.centery = pos_mouse[1]

        # actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        todos = pygame.sprite.RenderPlain(bola, jugador1, jugador2)
        todos.draw(screen)
        pygame.display.flip()


if __name__ == "__main__":
    main()

Bueno eso es todo por ahora, pueden descargar todos estos ejemplos desde aquí (o buscarlo en el repositorio de github)

Lo unico que le faltaria al juego es un sistema de puntuaciones, pero para eso primero hay que aprender como mostrar texto con pygame, lo cual es uno de los temas a tratar en la siguiente parte de este tutorial (la parte 4).

• Como crear una ventana
• El bucle principal de un videojuego (o como saber cuando hay que terminar el juego)
• Usar una imagen como fondo
• Mostrar una imagen y mover la imagen en la pantalla

A continuación la explicación completa

Paso 1: Creando una ventana

Primero Importamos los módulos y definimos dos variables globales (por metodología se suelen poner en mayúsculas) que son resolución de la pantalla del juego.

Luego hay que crear la ventana, para ello dentro de la función main() usamos pygame.display.set_mode y pygame.display.set_caption, que establecen el tamaño de la ventana y el titulo de esta respectivamente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/03/25/tutorial-pygame-2-ventana-e-imagenes/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 2")


if __name__ == "__main__":
    main()

Ahora lo ejecutamos y sorpresa… se crea la ventana pero inmediatamente se cierra, eso ocurre porque no hemos definido el bucle o loop principal del juego

Paso 2: el bucle principal del juego

Los juegos generalmente ejecutan un bucle infinito (su bucle principal), lo cual permite que el juego continúe corriendo hasta la que se se cumpla una condición que lo termine (como por ejemplo que el jugador pierda todas sus vidas o se rinda), mas o menos lo que muestra este diagrama:

En nuestro caso el bucle principal se continuara ejecutando hasta que el jugador cierre el ventana (o sea que se quede esperando hasta que se haga click en le botón para cerrar la ventana). Entonces el código del paso anterior queda de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/03/25/tutorial-pygame-2-ventana-e-imagenes/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 2")

    # el bucle principal del juego
    while True:
        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()


if __name__ == "__main__":
    main()

Lo que hace es simple, una vez dentro del bucle, recorre la lista que devuelve pygame.event.get() (es una lista con todos los eventos que registra pygame, como por ejemplo cuando uno presiona una tecla), si dentro de esa lista esta el evento pygame.QUIT (o sea cerrar la ventana) el programa ejecuta la orden sys.exit() (que termina la ejecución del programa y es parte del modulo sys, por eso lo importamos), en caso contrario (que aun no se produzca ese evento) seguirá esperando.

En loserjuegos esta la documentación de referencia de pygame traducida, entre ella la lista de los eventos

Paso 3: Cargando el fondo y una imagen

Primero para cargar las imágenes usamos pygame.image.load(), con ello se crea un objeto que contiene la superficie de la imagen (aun no la muestra). Luego de esto hay que indicar las posiciones de esta imagen, para lo cual se usa blit(imagen, (coordenada_x, coordenada_y))

Puedes pensar en la ventana de pygame como un plano en 2 ejes, con una pequeña diferencia: el origen (coordenadas 0,0) se encuentra en la esquina superior izquierda de la ventana. Por lo tanto en valor de las coordenadas en el eje x (horizontal) va aumentando (y es positivo) mientras se avanza a la derecha, mientras que en el eje y (vertical) el valor va aumentando (y es positivo) a medida que se avanza hacia abajo (o sea lo contrario de lo que se acostumbra, para el eje y)

Para que quede más claro, un esquema en que muestra en que posición cargaremos las imágenes (Nota: pygame siempre usa como referencia la esquina superior izquierda de las imágenes)

Ahora que ya sabemos sobre coordenadas, vamos a insertar un fondo y una imagen en nuestra ventana, usaremos las siguientes:

fondo.jpg (hacer clic para agrandar)

tux.png (hacer clic para agrandar)

Vamos con el código:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/03/25/tutorial-pygame-2-ventana-e-imagenes/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 2")

    # cargamos el fondo y una imagen (se crea objetos "Surface")
    fondo = pygame.image.load("fondo.jpg").convert()
    tux = pygame.image.load("tux.png").convert_alpha()

    # Indicamos la posicion de las "Surface" sobre la ventana
    screen.blit(fondo, (0, 0))
    screen.blit(tux, (550, 200))
    # se muestran lo cambios en pantalla
    pygame.display.flip()

    # el bucle principal del juego
    while True:
        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()


if __name__ == "__main__":
    main()

Si se fijan al cargar el fondo se uso fondo = pygame.image.load(“fondo.jpg”).convert() mientras que para la imagen de tux se uso tux = pygame.image.load(“tux.png”).convert_alpha(). Esto se debe a que el fondo no necesita tener un color trasparente (un canal alpha) ya que es la imagen que esta bajo todas las demás, en cambio el sprite de nuestro pingüino si necesita tener un color trasparente (que convenientemente ya esta definido en el png , lo hice a propósito cuando lo cree) o de lo contrario al cargar la imagen del pingüino se vería un feo rectángulo a su alrededor

Si quieren saber más sobre sprites, resoluciones y similares les recomiendo que lean este articulo sobre los conceptos básicos para programar un videojuego (pongan ojo en la parte de los sprites)

Luego se hizo screen.blit(fondo, (0, 0)) y screen.blit(tux, (550, 200)), con esto se le indica que cargue la imagen del fondo justo en la coordenada (0,0) para que cubra toda la pantalla (cualquier otro valor hubiera dejado el fondo desplazado) y en el caso de tux se le indica que lo cargue a la derecha

Paso 4: Moviendo la imagen

Ahora vamos a hacer que tux se mueva a la izquierda, para ello, simplemente a su posición en el eje x le vamos a restar -1 en cada ciclo del bucle principal. Para ello modificamos el código para que quede de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/03/25/tutorial-pygame-2-ventana-e-imagenes/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 2")

    # cargamos el fondo y una imagen (se crea objetos "Surface")
    fondo = pygame.image.load("fondo.jpg").convert()
    tux = pygame.image.load("tux.png").convert_alpha()

    tux_pos_x = 550
    tux_pos_y = 200

    # Indicamos la posicion de las "Surface" sobre la ventana
    screen.blit(tux, (tux_pos_x, tux_pos_y))
    screen.blit(fondo, (0, 0))
    # se muestran lo cambios en pantalla
    pygame.display.flip()

    # el bucle principal del juego
    while True:
        # le restamos 1 a la coordenada x de tux
        # asi se mueve un poquito a la izquierda
        tux_pos_x = tux_pos_x - 1
        screen.blit(tux, (tux_pos_x, tux_pos_y))
        # se muestran lo cambios en pantalla
        pygame.display.flip()

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()


if __name__ == "__main__":
    main()

y el resultado fue un fallo gigantesco:

Explicación: lo que paso es que se nos olvido borrar al pingüino de la pantalla antes de moverlo a su nueva posición, por lo que veremos en realidad un “rastro” del movimiento mientras dibujamos continuamente al pingüino en nuevas posiciones. Además nunca le pusimos limite al movimiento del pingüino, por lo que una vez que alcanzo el borde de la pantalla, siguió moviéndose hacia la izquierda hacia el infinito y mas allá…

Paso 5 (final): Refrescando/borrando la pantalla

La solución mas fácil para borrar el “rastro” que se deja al moverse, es simplemente redibujar toda la pantalla (fondo incluido) en cada ciclo del juego, por lo tanto dentro del while, después de actualizar la posición del pingüino, se redibuja tota la pantalla usando blit() y pygame.display.flip()

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: X11/MIT license http://www.opensource.org/licenses/mit-license.php
# http://pythonmania.wordpress.com/2010/03/25/tutorial-pygame-2-ventana-e-imagenes/

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("tutorial pygame parte 2")

    # cargamos el fondo y una imagen (se crea objetos "Surface")
    fondo = pygame.image.load("fondo.jpg").convert()
    tux = pygame.image.load("tux.png").convert_alpha()

    tux_pos_x = 550
    tux_pos_y = 200

    # Indicamos la posicion de las "Surface" sobre la ventana
    screen.blit(tux, (tux_pos_x, tux_pos_y))
    screen.blit(fondo, (0, 0))
    # se muestran lo cambios en pantalla
    pygame.display.flip()

    # el bucle principal del juego
    while True:
        # le restamos 1 a la coordenada x de tux y comprobamos
        # que no alcance el borde de la pantalla
        tux_pos_x = tux_pos_x - 1
        if tux_pos_x < 1:
            tux_pos_x = 550

        # Redibujamos todos los elementos de la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(tux, (tux_pos_x, tux_pos_y))
        # se muestran lo cambios en pantalla
        pygame.display.flip()

        # Posibles entradas del teclado y mouse
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()


if __name__ == "__main__":
    main()

Además después de actualizar la tux_pos_x se coloco un if, de tal manera de que si esa posición es 0 o negativa (o sea esta fuera de la pantalla), la tux_pos_x tome un valor de 550 (550 + 90px que mide de ancho la imagen de tux = 640 px, o sea que la imagen se muestre al borde derecho de la pantalla)

Bueno eso es todo por ahora, pueden descargar todos estos ejemplos desde aquí (o buscarlo en el repositorio de github).

En el próximo tutorial explicaremos como controlar el movimiento de una imagen (con el teclado), colisiones y reproducir algunos sonidos. Pueden encontrar esta segunda parte aquí

Saludos.

Primero, ¿que es pygame?

Lo primero que hay que pygame es una biblioteca multimedia (que trabaja sobre las librerías SDL) que permiten la creación de videojuegos en dos dimensiones de una manera sencilla.

Las SDL (Simple DirectMedia Layer) son un conjunto de bibliotecas que proporcionan funciones básicas para realizar operaciones de dibujado 2D, gestión de efectos de sonido, música, carga y gestión de imágenes (y son importantes ya que pygame trabaja sobre ellas). Básicamente es una librería similar a OpenGL o DirectX (solo en la parte 2D), diseñada para ser más fácil de usar que estas otras (además OpenGL solo se encarga de la parte gráfica, en cambio SDL incluye otras cosas como son los sonidos )

Tal como les dije anteriormente usando pygame vamos a programar algunos videojuegos. No esperen programar un juego inmenso en 3D con gráficas espectaculares y que necesite equipos potentes para ser usado. Mas bien lo que vamos a obtener son juegos en 2D similares a los de consolas como supernintendo, portátiles como el GBA, nintendoDS (sin la parte táctil), etc. Para que se hagan una idea de como son los juegos programados con pygame, algunos juegos como frets on fire, SolarWolf o pydance usan pygame para su desarrollo. Pueden encontrar mas ejemplos en el sitio de pygame

Volviendo al tema Pygame se encarga de manejar la parte más complicada dentro de la programación de un videojuego, o se se encarga de cargar y mostrar las imágenes (en formatos como PNG, BMP, PCX, TGA,…), sonido (formatos OGG, MP3, MIDI,…), vídeos, las ventanas del juego y monitoriza los dispositivos de entrada (como mouse, teclado y joystick) de una manera bastante sencilla. Por lo que básicamente uno se tiene que preocupar por la programación del juego en si

Requisitos previos (recomendados)

• Tener instalado python y pygame (obvio). Ambas están disponibles para varios sistemas (como Windows, GNU/Linux, Mac, etc.) así que los juegos creados pueden ser multiplataforma
• Conocimiento básico de python, por lo menos como se definen funciones y clases
• Conocimientos básicos de matemáticas y física, lo que resulta útil al programar juegos en general (con lo que aprendiste de niño es mas que suficiente). Básicamente es algo de física clásica como los conceptos de velocidad, aceleración, etc. y de matemáticas como los conceptos de puntos, coordenadas en el espacio, etc.

Primeros pasos

Lo primero hay que hay que hacer es importar el modulo de pygame, lo cual se hace simplemente como:

import pygame
from pygame.locals import *

La segunda linea es opcional (pero muy recomendada), ya se utiliza para importar una serie de constantes que tiene pygame (como las teclas del teclado)

Ahora en general nuestro código en pygame tendrá una estructura como esta:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Importacion de los módulos
import pygame
from pygame.locals import *
# y cualquier otro modulo usado

# ----------------------------------------------
# Constantes, como anchos y largo de pantalla, etc.
# ----------------------------------------------

# ----------------------------------------------
# Clases y Funciones utilizadas (lo explicare en la siguiente parte)
# ----------------------------------------------

def main():
    pygame.init()
    # La clase o función principal que crea o ejecuta el juego
    # Contiene principalmente loop del juego (el alma de este)

if __name__ == "__main__":
    main()

Si te fijas en la linea 18 se hace un pygame.init(), esto es para que se inicie pygame y es necesario ejecutarlo antes de empezar a usar pygame (por eso fue incluido al inicio de la función principal del juego). Si no te gusta incluir el pygame.init() en la función del juego, otro buen lugar es incluirlo inmediatamente después del if __name__ == “__main__”: (antes de llamar a la función main())

¿Y ahora que?

Continua leyendo las siguientes entradas sobre el tema, en donde se explica como crear ventanas, personajes, insertar sonidos, etc. Que son las siguientes:

Parte 2: Creando una ventana, cargando imágenes y moviéndolas al interior de la ventana: En esta segunda parte veremos:

• Como crear una ventana
• el bucle principal de un videojuego (o como saber cuando hay que terminar el juego)
• Usar una imagen como fondo
• mostrar una imagen y moverla en la pantalla

Parte 3: Creando un videojuego (el clasico pong): En esta parte veremos:

• Crear una función para cargar imágenes
• Como crear sprites (los sprites son personajes, objetos, etc. dentro del juego)
• sincronización en los videojuegos (¿que son frames por segundo?)
• controlar un sprite con el teclado
• controlar un sprite con el mouse
• colisiones entre elementos (sprites)
• Inteligencia artificial (o la falta de esta)
• reproducción de sonidos (al cumplirse alguna condición)

Parte 4: manejando texto: El nombre lo dice todo, una explicación de como mostrar texto en pantalla.

Referencias:

Principalmente la documentación de pygame, que esta traducida en loserjuegos o si quieren una copia de esta traducción en un pdf (para consultar off-line)

Si alguien quiere el código de los ejemplos, este esta en github: http://github.com/dbfuentes/tutorial-pygame

Tenemos dos casos:

1. Hay que realizar algún cambio pequeño, por ejemplo corregir algún bug que tenga el paquete (nueva revisión del paquete) o aplicar algún parche. Este cambio lo realizas tú, no el desarrollador del programa (o sea no es una nueva versión del programa, sino que son cambios específicos del paquete)
2. El desarrollador ha lanzado una nueva versión del programa, por lo que tenemos nuevas fuentes (y necesitamos crear un paquete nuevo para esta versión)

Primer caso: nueva revisión del paquete

En este caso no ha cambiado el programa fuente, sino que se crea una nueva revisión en donde se corrigen bugs o se agrega algún parche al paquete.

Supongamos que teníamos ya creado el paquete para foo-0.7.2 (foo_0.7.2-1_all.deb y el directorio en donde creamos el paquete es: ~/sandbox/foo-0.7.2) y ahora se encontró un bug por lo que tenemos que crear una nueva revisión del paquete (foo_0.7.2-2_all.deb)

Los pasos son:

• entrar al directorio en donde creamos el paquete deb (por ejemplo si el directorio debianizado estaba en ~/sandbox/foo-0.7.2, por lo que hay que entrar en el)
• En el terminal escribe:

export DEBFULLNAME="tu nombre"
export DEBEMAIL="tu@email.com"

• Añadir una nueva revisión en el fichero de cambios (debian/changelog), la manera mas fácil de hacerlo es con:

dch -i

• Abrir el debian/changelog y en la nueva entrada (que creamos con dch) hay que incluir una breve descripción del error y su solución en la entrada.

Si agregas un Closes: #12345 al final de los cambios y estas subiendo el paquete a un repositorio oficial (como el de debian o ubuntu) el informe del error numero 12345 será automágicamente cerrado en el sistema de seguimiento de bugs de la distribución

• Modifica el código fuente o los archivos que sean necesarios para corregir el bug (y si se necesario aplica algún parche)
• Revisa el resto de los archivos, básicamente tienes que revisar (y hacer en caso de que sea necesario) los pasos desde el numero 3 al 6 del tutorial anterior para que se pueda crear correctamente el paquete.
• Una vez que ya se hayan hechos los cambios necesario, hay que crear el paquete haciendo:

dpkg-buildpackage -rfakeroot

• Ahora hay que verificar el paquete, hay que comprobar que:

1. Que tiene los ficheros necesarios y ninguno más (lesspipe Nombre_paquete.deb)
2. Que cumple la policy de Debian, con lintian(lintian Nombre_paquete.deb)
3. Que instala correctamente (con dpkg -i o gdebi)

• Limpiamos los directorios borrando todos los archivos innecesarios, haciendo:

fakeroot debian/rules clean

Listo ya tienes tu nuevo paquete foo_0.7.2-2_all.deb

Nota: es importante limpiar, ya que mas adelante podríamos volver a modificar el paquete (o crear uno nuevo) y para ello el directorio tiene que quedar limpio

Segundo caso: nueva versión del programa

Supongamos que teníamos ya creado el paquete para foo-0.8.5, y ahora ha salido la versión foo-0.9.1, tenemos que hacer lo siguiente:

• Ingresar al directorio padre en donde teníamos el paquete de la versión anterior (por ejemplo si el directorio debianizado estaba en ~/sandbox/foo-0.8.5 hay que ingresar a ~/sandbox/)
• Descarga las nuevas fuentes (en el ejemplo foo-0.9.1.tar.gz) y verifica los cambios en el código fuente para saber que es lo nuevo, o sea lee changelog, NEWS, README y cualquier otra documentación. Además ve las diferencias con la versión anterior (busca cualquier cosa que pudiera parecer sospechosa o cambios puedan generar algún problema)
• Ahora a las nuevas fuentes hay renombrarlas al formato adecuado para las fuentes, o sea nombre_version.orig.tar.gz (por ejemplo si el archivo fuente es foo-0.9.1.tar.gz, tiene que quedar como foo_0.9.1.orig.tar.gz) y pon el archivo ese archivo un directorio por encima del antiguo árbol de fuentes (por ejemplo tiene que quedar en ~/sandbox/foo_0.9.1.orig.tar.gz)
• En el terminal escribe:

export DEBFULLNAME="tu nombre"
export DEBEMAIL="tu@email.com"

• Entra en el antiguo directorio (en este caso ~/sandbox/foo-0.8.5) y ejecuta:

uupdate -u ../foo_0.9.1.orig.tar.gz

• Ahora tendrás un nuevo directorio (~/sandbox/foo-0.9.1) en donde estarán las nuevas fuentes, a las cuales automagicamente se le agregaron los archivos del directorio debian (que fueron creados a partir de la versión anterior).
• Entra en ~/sandbox/foo-0.9.1 y modifica el debian/changelog para completar los cambios (uupdate ya creo una entrada en el debian/changelog sólo tienes que completar la información en caso que falte algo)
• Revisa el resto de los archivos, básicamente tienes que revisar (y hacer en caso de que sea necesario) los pasos desde el numero 3 al 6 del tutorial anterior para que se pueda crear correctamente el paquete. Probablemente los archivos ya estén creados y solo tienes que revisar si necesitan algún cambio o si se necesita algún extra
• Una vez que ya se hayan hechos los cambios necesario, hay que crear el paquete haciendo:

dpkg-buildpackage -rfakeroot

• Ahora hay que verificar el paquete, hay que comprobar que:

1. Que tiene los ficheros necesarios y ninguno más (lesspipe Nombre_paquete.deb)
2. Que cumple la policy de Debian, con lintian(lintian Nombre_paquete.deb)
3. Que instala correctamente (con dpkg -i o gdebi)

• Limpiamos los directorios borrando todos los archivos innecesarios, haciendo:

fakeroot debian/rules clean

es importante limpiar, ya que mas adelante podríamos volver a modificar el paquete (o crear uno nuevo), así que es bueno dejar los directorios en buenas condiciones

• Listo ya tienes tu nuevo paquete

Volviendo al tema principal, en resumen vamos a hacer un intento de navegador web, en donde tendremos una barra de direcciones (un entry de gtk) y abajo va a mostrar la pagina que le indiquemos.

Primero instalamos pywebkit, de debian basta con hacer un:

# apt-get install python-webkit libwebkit-dev

O sino lo bajan desde su sitio

Luego creamos un navegador muy simple:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Escrito por Daniel Fuentes B.
# Licencia: BSD <http://www.opensource.org/licenses/bsd-license.php>

import pygtk
pygtk.require("2.0")
import gtk
import webkit

class Browser:
    # Ventana del programa
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_position(gtk.WIN_POS_CENTER)
        self.window.set_default_size(800, 600)
        self.window.connect("destroy", self.on_quit)

        # Un vBox, en la parte de arriba hay una caja para ingresar
        # la direccion web, y abago se muestra la pagina
        vbox = gtk.VBox()

        # La parte de la entrada de la url
        self.url_text = gtk.Entry()
        self.url_text.connect('activate', self.url_text_activate)

        # La parte en donde se muestra la pagina que se visita (con scroll incluido)
        self.scroll_window = gtk.ScrolledWindow()
        self.webview = webkit.WebView()
        self.scroll_window.add(self.webview)

        # Unimos todo en el vBox
        vbox.pack_start(self.url_text, fill=True, expand=False)
        # El expand=False al empaquetarlo es para que el entry no ocupe media pantalla
        vbox.pack_start(self.scroll_window, True, True)
        self.window.add(vbox)
        self.window.show_all()

    # Definimos las señales y demas cosas de la ventana:
    def url_text_activate(self, entry):
    # al activar el entry (por ejemplo al hacer enter), se obtiene el
    # texto de la entry (la url) y se activa la funcion que abre la url
        self.open_url(entry.get_text())

    def on_quit(self, widget):
        gtk.main_quit()

    # La funcion magica que abre la url que se le pasa 
    def open_url(self, url):
        "Funcion que carga la pagina elegida"
        # cambia el titulo de la ventana
        self.window.set_title("Ejemplo pywebkitgtk - %s" % url)
        # mostramos la direccion de la pagina abierta en el entry
        self.url_text.set_text(url)
        # abre la pagina
        self.webview.open(url)

if __name__ == "__main__":
    browser = Browser()
    # abrimos la pagina de inicio (opcional)
    browser.open_url("http://code.google.com/p/pywebkitgtk/") 
    gtk.main()

El codigo se entiende por si mismo. Si se dan cuenta casi todo el código se para crear la ventana con pygtk (tal como fue explicado hace mucho tiempo en la introducción a pygtk que escribí), siendo la unica parte que involucra a webkit la parte en donde se define open_url (más o menos a partir de la linea 50)

Y les dejo una captura del ejemplo funcionando:

Si alguien se interesa en la web del proyecto hay un navegador mucho más funcional o puede revisar este blog

Una de las soluciones a esto es usar threads (hilos), pero NO “de la manera normal” como es usan, ya que si se hace de forma normal, los widgets no se comportan siempre como es debido y a veces los threads ni siquiera funcionan.

La solución es usar los métodos gtk.gdk.threads_init(), gtk.gdk.threads_enter() y gtk.gdk.threads_leave() de la siguiente forma:

• Al inicio de código hay que poner gtk.gdk.threads_init() para indicarle a la aplicación que se van a usar hilos en la interfaz gráfica (linea 13 del ejemplo)
• Luego en la parte del código que que hace el trabajo pesado (y que posiblemente congele la aplicación de manera temporal) hay que poner el gtk.gdk.threads_enter() antes de esas líneas y gtk.gdk.threads_leave() después de esas lineas (lineas 25 y 33 del ejemplo)

Ahora veamos el ejemplo (con los correspondientes comentarios), mas adelante lo explico con mas detalles:

#!/usr/bin/env python

# Escrito por Daniel Fuentes B.
# Licencia: BSD <http://www.opensource.org/licenses/bsd-license.php>

import pygtk
pygtk.require("2.0")
import gtk
import os
import threading

# iniciamos los thead (los iniciamos, aun no lo usamos)
gtk.gdk.threads_init()

comando = "find /var"

# Esta funcion hace el trabajo "pesado", luego es llamada desde la ventana
def salida_comando(salida_texto, buffer_texto, comando):
    output = os.popen(comando)
    while True:
        linea = output.readline()
        if not linea:
            break
        # Comienza el trababjo pesado, asi que entramos en un thread
        gtk.gdk.threads_enter()
        # Se inserta la siguiente linea de la salida del proceso y luego se
        # coloca el cursor al final del textview (se mueve el scroll)
        iter = buffer_texto.get_end_iter()
        buffer_texto.place_cursor(iter)
        buffer_texto.insert(iter, linea)
        salida_texto.scroll_to_mark(buffer_texto.get_insert(), 0.1)
        # Finaliza el trabajo pesado, asi que salimos del thread
        gtk.gdk.threads_leave()

# Clase con la ventana principal.
class MainWindow:
    def  __init__(self):
        # Definimos la ventana inicial
        ventana = gtk.Window(gtk.WINDOW_TOPLEVEL)
        ventana.set_title("Ejemplo de threading en gtk")
        ventana.resize(450,300)
        ventana.connect("destroy", gtk.main_quit)
        
        # Creamos una caja vertical con un espacio entre widgets de 5px y con
        # la propiedad homogeneo en False. Luego agragamos las widgets al vbox
        vbox = gtk.VBox(False, 5)
        
        # Una simple etiqueta que se muestra en la parte superior de la ventana
        etiqueta = gtk.Label("Resultado del comando:")
        
        # Creamos un textview que tenga un auto scroll, o sea que se desplace
        # solo al aparecer nuevo texto que sobrepase la pantalla
        # en este textview se mostrara la salida del comando ejecutado
        scrollwin = gtk.ScrolledWindow()
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        salida_texto = gtk.TextView()
        buffer_texto = salida_texto.get_buffer()
        scrollwin.add(salida_texto)
        
        # creamos un boton, el que iniciara el comando al hacer click en el
        boton = gtk.Button("iniciar programa")
        boton.connect("clicked", self.on_boton_clicked, salida_texto, buffer_texto, comando)
        
        # Empacamos el textview con scroll y el boton dentro del vbox
        vbox.pack_start(etiqueta, False, False, 0)
        vbox.pack_start(scrollwin)
        vbox.pack_start(boton, False)
        
        # y luego unimos el vbox la ventana pricipal y la mostramos
        ventana.add(vbox)
        ventana.show_all()

    def on_boton_clicked(self, widget, salida_texto, buffer_texto, comando):
        # Este boton es el lanza el hilo (threading) al hacer click sobre el
        hilo = threading.Thread(target=salida_comando, args=(salida_texto, buffer_texto, comando))
        hilo.start()

if __name__ == "__main__":
    MainWindow()  
    gtk.main()

Lo que hace el programa es ejecutar un comando “find /var” y luego muestra la salida de este en la ventana

La clase MainWindow crea la ventana de pygtk, es muy parecida al primer ejemplo que vimos en el tutorial de introducción a pygtk, el único detalle es que al hacer click en el boton (on_boton_clicked) se inicia un thread (hilo) que ejecuta la función salida_comando con los correspondientes argumentos.

En cuanto a la salida_comando es una función que ejecuta un comando (usando os.popen) tal como si uno lo escribiera en un terminal y luego toma el texto que resulta de ejecutar el comando y lo muestra en el textview de nuestra ventana. Esta funcion contiene la parte del código que hace el trabajo pesado, por esto tiene los gtk.gdk.threads_enter() y gtk.gdk.threads_leave()

Y así se ve la ventana funcionando:

Claro que esta no es la única forma de hacerlo, o sino miren en las faqs de pygtk

#!/usr/bin/env python

from random import choice

longitud = 18
valores = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ<=>@#%&+"

p = ""
p = p.join([choice(valores) for i in range(longitud)])
print p

bastante simple, en longitud se le indica la longitud de la contraseña (en este caso 18 letras) y en valores son las posibles letras con las que se formaran la contraseña (allí cada uno escoge ).

Nota: puede ser recomendable omitir el 1,l,O,0 porque a veces se confunden y omitir algunas letras para que por azar no se creen palabras ofensivas.