Python R2


Juegos en Python (con pygame)


Hace unos años, compre un producto llamado “DIV Studio Game” y la verdad es que mi experiencia fue muy mala. Nunca terminé de familiarizar con su IDE, ni siquiera con sus librerías, la verdad no me parecían intuitivas, ni fáciles. Ese fue mi único contacto con la programación de videos juegos.
Luego después de todos estos años encontré pygame y quedé atónito con lo poco que se podía empezar a programar un juego.

¿Qué es pygame?

Pygame es un conjunto de Módulos de Python para la programación de videos juegos en 2 dimensiones. Funciona con la interfase SDL, que es una biblioteca multiplataforma para el manejo de la programación gráfica.
Para empezar a usarlo tendremos que bajarlo de su pagina oficial http://www.pygame.org/.

Programando con pygame

Pygame se encargara de gestionar toda la parte multimedia de nuestro juego como pueden ser el manejo de imágenes, el sistema de sonido, operaciones relacionadas con el gestor de ventanas, eventos de nuestro juego, temporizadores, colisiones, etc.
Casi todos los videos juego responden a una misma lógica básica. Esta lógica seria:

  • Iniciar pygame.
  • Iniciamos nuestra ventana.
  • Comenzamos un bucle infinito.
  • Choquemos los eventos y actuamos según corresponda.

Un ejemplo diminuto de esta lógica pygame1.py

#!/usr/bin/python
# Nombre : pygame1.py
import pygame
import sys

pygame.init;
pygame.display.set_mode((320,240))

while True:
    for e  in pygame.event.get():
        if e.type == pygame.QUIT: #si llega el evento QUIT
            sys.exit(0)          #Sale del sistema

El evento pygame. QUIT es cuando un usuario intenta cerrar la ventana. Si no hacemos esto la ventana no responderá a este vento y nunca se cerrara. Como pasa en el ejemplo pygame2.py que solo sale al tocar la tecla “s” no saldrá de la ventana.

#!/usr/bin/python
# Nombre : pygame2.py
import pygame
import sys

pygame.init; #inicializa pygame
pygame.display.set_mode((320,240)) #inicializamos video

while True: #bucle infinito
    for e  in pygame.event.get():
        if e.type == pygame.KEYUP: #si solto alguna tecla
            if e.key == pygame.K_s: sys.exit(0)
            # cuando suelte la tecla "s"

En este ejemplo también se puede observar otro evento llamado KEYUP que ocurre cuando un usuario suelta una tecla y también se observa cuando como se obtiene la tecla en cuestión mediante “e.key”.

También podremos ponerle un fondo a nuestro ejemplo. De la forma siguiente:

#!/usr/bin/python
# Nombre : pygame3.py

import pygame
import sys

pygame.init; #inicializa pygame

screen = pygame.display.set_mode((320,240),pygame.FULLSCREEN)

fondo = pygame.image.load("img/2145_1101395673.png")

while True: #bucle infinito
    #recorremos los eventos recividos
    for e  in pygame.event.get():
        if e.type == pygame.KEYUP: #si solto alguna tecla
            if e.key == pygame.K_s: sys.exit(0)
            # cuando suelte la tecla "s"
    screen.blit(fondo,(0,0))
    pygame.display.flip()

El fondo lo cargamos con pygame.image.load y luego lo dibujamos en memoria mediante “blit”. Para imprimirlo en pantalla luego con “pygame.display.flip()”.

Nosotros le pondremos a nuestro juego una pelota que podamos manejar mediante las flechas del teclado. Esto lo podemos ver en el ejemplo pygame4.py

#!/usr/bin/python
# Nombre : pygame4.py
import pygame
import sys

from pygame.locals import *

class Pelotas (pygame.sprite.Sprite):
    def __init__(self,img):
        self.image = pygame.image.load(img)
        self.rect = self.image.get_rect()
        self.rect.move_ip(0,0)

    def update(self):
        keys = pygame.key.get_pressed()
        if keys[K_RIGHT] : self.rect.x += 2
        if keys[K_LEFT]  : self.rect.x -= 2
        if keys[K_UP]  : self.rect.y -= 2
        if keys[K_DOWN]: self.rect.y += 2

pygame.init;
screen = pygame.display.set_mode((320,240))

pelota = Pelotas("img/ball.png")

while True: #bucle infinito
    for e  in pygame.event.get(): #recorremos los eventos recividos
        if e.type == pygame.KEYUP: #si solto alguna tecla
            if e.key == pygame.K_s: sys.exit(0) # cuando suelte la tecla "s"
    pelota.update()
    screen.fill((0,0,0)) #restablecemos el color del fondo
    screen.blit(pelota.image,pelota.rect)
    pygame.display.flip()

Comentario del “pygame4.py”: Lo primero que hacemos es definir una clase Pelotas que hereda de pygame.sprite.Sprite. ¿Qué son los sprite? Un sprite es simplemente una figura o imagen de dimensiones no muy grandes, que puede desplazarse por la pantalla. Y en nuestro caso será una pelota que la podremos mover mediante las flechas, para esto redefinimos el metodo “update” y dentro del mismo, obtenemos las teclas pulsadas por medio de la función pygame.key.get_pressed(), que nos devuelve una lista con el estado de todas las teclas. Luego lo chequeamos según la posición de cada tecla en la lista que nos devolvió dicha función. También vemos en esta clase que redefinimos el constructor para asignarle la propiedad “image” y la propiedad “rec”.

  • Image: es la imagen propiamente dicha que usa el sprite.
  • Rec: es el rectángulo de dicha imagen.

Luego en el while infinito agregamos update para que podamos tomar el control de nuestra pelota y fill para restablecer el fondo de la pantalla. El método fill recibe por parámetro un color en formato RGB por parámetro. Prueben sacarlo y ver que pasa.

Un Juego simple y completo en pygame.

En esta sección veremos como detectar cuando un sprite se choca o colisiona con otro sprite. Para esto crearemos un juego, donde halla muchas pelotas flotando por todos lados y nuestra pelota parezca en el inicio de juego en la esquina superior derecha y tengamos que trasportarla hasta la esquina inferior izquierda sin chocar con ninguna otra pelota.

Acá esta el código. pygame5.py

#!/usr/bin/python
# Nombre : pygame5.py
import pygame
import sys

from pygame.locals import *

ancho,largo = 500,400

clock = pygame.time.Clock
class Pelotas (pygame.sprite.Sprite):
    def __init__(self,img):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load(img)
        self.rect = self.image.get_rect()
        self.rect.move_ip(0,0)
        self.rectAnt = self.rect
        self.t=0

    def update(self):
        keys = pygame.key.get_pressed()
        if keys[K_RIGHT] and self.rect.x < ancho-30:
            self.rect.x += 2
        if keys[K_LEFT] and self.rect.x > 10 :
            self.rect.x -= 2
        if keys[K_UP] and self.rect.y > 10:
            self.rect.y -= 2
        if keys[K_DOWN] and self.rect.y < largo-30:
            self.rect.y += 2

        screen.blit(self.image,self.rect)
        c = len(pygame.sprite.spritecollide(self,g,False,None))
        if c >= 2:
            print "Perdiste: Uff chocaste",c
            sys.exit(0)

        if self.rect.x == ancho - 30 and self.rect.y == largo-30:
            print "Wiiii GANASTE"
            sys.exit(0)
        else:
            self.t+=1

        self.rectAnt = self.rect

class Elementos (pygame.sprite.Sprite):
    def __init__(self,img,x,y,p):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load(img)
        self.rect = self.image.get_rect()
        self.rect.move_ip(x,y)
        self.direccion = p
    def update(self):
        keys = pygame.key.get_pressed()
        self.rect.x += self.direccion[0]
        self.rect.y += self.direccion[1]

        if self.rect.x > ancho-10: self.direccion[0] = -1
        if self.rect.x < 30      : self.direccion[0] = 1
        if self.rect.y < 30      : self.direccion[1] = 1
        if self.rect.y > largo-10: self.direccion[1] = -1
        c=len(pygame.sprite.spritecollide(self,g,False,None))
        if c >= 2:
            self.direccion[0] = self.direccion[0]*(-1)
            self.direccion[1] = self.direccion[1]*(-1)
        screen.blit(self.image,self.rect)

pygame.init;

screen = pygame.display.set_mode((ancho,largo))

pelota = Pelotas("ball.jpg")
elemento1 = Elementos("ball.jpg",0,150,[1,1])
elemento2 = Elementos("ball.jpg",150,0,[1,2])
elemento3 = Elementos("ball.jpg",300,120,[3,1])
elemento4 = Elementos("ball.jpg",400,65,[1,5])
elemento5 = Elementos("ball.jpg",470,65,[1,-95])
elemento6 = Elementos("ball.jpg",450,10,[-1,3])
elemento7 = Elementos("ball.jpg",400,65,[25,5])

g = pygame.sprite.Group()
ge=pygame.sprite.Group()
g.add([pelota,elemento1,elemento2,elemento3,elemento4,elemento5,elemento6,elemento7])
ge.add([elemento1,elemento2,elemento3,elemento4,elemento5,elemento6,elemento7])

while True:
    for e  in pygame.event.get():
        if e.type == pygame.KEYUP:
            if e.key == pygame.K_s: sys.exit(0)
    screen.fill((0,0,0))
    g.update()
    pygame.time.delay(10)
    pygame.display.flip()

En este código, ya más complejo, se puede ver un juego simple pero completo. Lo primero que observamos es que se agregan, los grupos. Estos “grupos” dan la posibilidad de enviarles mensajes de una sola vez a nuestros sprite y también observamos que se crean mediante la clase “pygame.sprite.Group ()” y le podemos agregar sprite, mediante el método add.
En el while infinito podemos ver como por medio de g.update(). Le enviamos a todos el método update(). Luego hacemos un delay por medio de la función “pygame.time.delay(10)” para que el juego no valla tan rápido. En las clases podremos ver como controlamos las colisiones con otros sprite por medio de “pygame.sprite.spritecollide”.

Anuncios

2 comentarios to 'Juegos en Python (con pygame)'

Subscribe to comments with RSS o TrackBack to 'Juegos en Python (con pygame)'.

  1. Marín said,

    La verdad esto me ayudo mucho
    Gracia!

  2. Fell26256 said,

    Gracias men…..me ayudado un monton tut tute. Espero que saques algun otro.


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s


A %d blogueros les gusta esto: