Comenzando con pygame

Un simple ‘juego’


Importar e inicializar

Cada módulo debe importarse y pygame no es una excepción. Aunque necesitamos llamar a la función pygame.init() para que todos los módulos importados en pygame se inicialicen correctamente. Si olvidamos esto, algunos módulos no funcionarán. La función también devuelve una tupla de todas las inicializaciones exitosas y fallidas (no generará un error si un módulo no se inicializa).

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))

Crear necesidades

También necesitamos crear una pantalla. Pygame ya ha creado una pantalla (oculta), por lo que todo lo que tenemos que hacer es configurar el modo de la pantalla (en este ejemplo, solo configuramos la resolución). También es una buena idea crear un reloj para asegurarse de que nuestro programa se actualice a una velocidad fija (de lo contrario, se ejecutaría a una velocidad diferente según la velocidad de la computadora).

screen = pygame.display.set_mode((720, 480))  # Notice the tuple! It's not 2 arguments.
clock = pygame.time.Clock()
FPS = 60  # This variable will define how many frames we update per second.

Para facilitar la lectura más adelante en nuestro código, crearemos dos constantes de color, que representan una tupla de rojo, verde y azul (RGB). Los valores van de 0 (sin luz) a 255 (luz completa).

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

En pygame generalmente usamos una Superficie para representar la apariencia de un objeto y un Rect (rectángulo) para representar la posición de un objeto. Una Superficie es como una hoja de papel en blanco que contiene colores o imágenes. Si está creando una clase, debe nombrar los atributos image y rect ya que muchas funciones buscarán y usarán esos atributos. Tales clases se beneficiarían al heredar la clase pygame.sprite.Sprite por razones que puede leer aquí.

rect = pygame.Rect((0, 0), (32, 32))  # First tuple is position, second is size.
image = pygame.Surface((32, 32))  # The tuple represent size.
image.fill(WHITE)  # We fill our surface with a nice white color (by default black).

El bucle del juego

Ahora tenemos todo listo para nuestro bucle de juego. Este es un ciclo que se ejecutará durante todo el juego, donde manejamos eventos y actualizamos la pantalla y las posiciones de nuestros objetos.

Primero nos aseguraremos de que nuestro ciclo se ejecute en un FPS dado. Definimos el FPS y creamos nuestro reloj al comienzo del programa. El siguiente código se asegurará de que nuestro programa duerma el tiempo suficiente para que nuestro ciclo repita la cantidad que definimos para nuestro FPS. En este ejemplo, 60 veces por segundo.

clock.tick(FPS)

Luego nos encargaremos de los eventos. Un evento es básicamente una acción del usuario, como mover el mouse o presionar una tecla. Pygame registrará todos estos eventos en una cola que obtenemos llamando a pygame.event.get(). Podemos iterar sobre esto y verificar si hay un evento que nos gustaría manejar. Los eventos tienen un atributo tipo que podemos comparar con las constantes en el módulo pygame para determinar qué tipo de evento es.

for event in pygame.event.get():
    if event.type == pygame.QUIT:  # The user pressed the close button in the top corner of the window.
        quit()
        # Close the program. Other methods like 'raise SystemExit' or 'sys.exit()'.
        # Calling 'pygame.quit()' won't close the program! It will just uninitialize the modules.

También podemos verificar if event.type == pygame.KEYDOWN para ver si el usuario ha presionado una tecla. En ese caso, el evento tiene un atributo clave que podemos verificar para ver qué clave representa.

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        quit()
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_w:
            rect.move_ip(0, -2)  # Changes the rect's position.
        elif event.key == pygame.K_s:
            rect.move_ip(0, 2)
        elif event.key == pygame.K_a:
            rect.move_ip(-2, 0)
        elif event.key == pygame.K_d:
            rect.move_ip(2, 0)

Ahora necesitamos mostrar nuestra imagen. Primero, es posible que queramos borrar nuestra pantalla del renderizado anterior. Lo hacemos llenando toda nuestra pantalla de negro (quitar el código para ver por qué queremos borrarlo). Luego necesitamos blit nuestra imagen a la pantalla. Blitting esencialmente significa copiar la imagen a otra superficie (en nuestro caso, la pantalla). Por último, volteamos o actualizamos la pantalla.

Cuando estamos haciendo blit, en realidad no estamos mostrando nada al usuario. Imagínelo como la computadora por un lado y el usuario por el otro. La computadora dibuja (blits) en su lado de la pantalla, voltea hacia el usuario y luego repite.

screen.fill(BLACK)
screen.blit(image, rect)
pygame.display.update()  # Or 'pygame.display.flip()'.

¡Ya tenemos un juego básico! Bastante aburrido, sí, ¡pero lo esencial está ahí! Combina esto con tu conocimiento actual de Python y deberías poder crear algo asombroso.


Código completo

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))


screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60  # Frames per second.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
# RED = (255, 0, 0), GREEN = (0, 255, 0), BLUE = (0, 0, 255).

rect = pygame.Rect((0, 0), (32, 32))
image = pygame.Surface((32, 32))
image .fill(WHITE)  

while True:
    clock.tick(FPS)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                rect.move_ip(0, -2)
            elif event.key == pygame.K_s:
                rect.move_ip(0, 2)
            elif event.key == pygame.K_a:
                rect.move_ip(-2, 0)
            elif event.key == pygame.K_d:
                rect.move_ip(2, 0)

    screen.fill(BLACK)
    screen.blit(image, rect)
    pygame.display.update()  # Or pygame.display.flip()

Mecánica de juego ligeramente mejorada

Tenga en cuenta que el programa verifica cuando presionamos la tecla y no cuando la mantenemos presionada. Para arreglar esto podríamos introducir una variable velocidad. Podemos crear una clase de jugador para mantenerlo más organizado. Para evitar el movimiento dependiente del marco (si cambiáramos el FPS a 30, los objetos se moverían a la mitad de la velocidad), introducimos el movimiento dependiente del tiempo al pasar el tiempo entre tics a nuestros objetos móviles.

import pygame

successes, failures = pygame.init()
print("Initializing pygame: {0} successes and {1} failures.".format(successes, failures))

screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)


class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.image.fill(WHITE)
        self.rect = self.image.get_rect()  # Get rect of some size as 'image'.
        self.velocity = [0, 0]

    def update(self):
        self.rect.move_ip(*self.velocity)


player = Player()
running = True
while running:
    dt = clock.tick(FPS) / 1000  # Returns milliseconds between each call to 'tick'. The convert time to seconds.
    screen.fill(BLACK)  # Fill the screen with background color.

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                player.velocity[1] = -200 * dt  # 200 pixels per second
            elif event.key == pygame.K_s:
                player.velocity[1] = 200 * dt
            elif event.key == pygame.K_a:
                player.velocity[0] = -200 * dt
            elif event.key == pygame.K_d:
                player.velocity[0] = 200 * dt
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_w or event.key == pygame.K_s:
                player.velocity[1] = 0
            elif event.key == pygame.K_a or event.key == pygame.K_d:
                player.velocity[0] = 0

    player.update()

    screen.blit(player.image, player.rect)
    pygame.display.update()  # Or pygame.display.flip()

print("Exited the game loop. Game will quit...")
quit()  # Not actually necessary since the script will exit anyway.

Todavía hay muchas cosas que deberían mejorarse en este código. Te recomiendo que leas el tutorial de pygame y esta charla de Richard Jones para profundizar más.

Instalando pygame

en las ventanas

  1. Vaya a http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame: un sitio no oficial que proporciona archivos binarios de Windows de paquetes de Python de código abierto para el [CPython] oficial (https://en.wikipedia .org/wiki/CPython) distribuido por Christoph Gohlke.

  2. Descargue el archivo pygame .whl apropiado de acuerdo con su versión de python instalada. (El archivo tiene un nombre similar a pygame -<versión de pygame> - <versión de python>- win32.whl)

  3. Ejecutar

     pip install your-pygame-package.whl
    

dentro de su terminal, bash o consol.
Nota: si pip no se encuentra en RUTA intente ejecutar python -m pip install your-pygame-package.whl

  1. Compruebe si puede importar pygame como un módulo de python

    import pygame
    

Si no obtiene un error, ha instalado Pygame correctamente en su computadora :)

en linux

  1. Abre tu terminal y ejecuta

    sudo apt-get install python-pygame
    

Nota: Esto instalará pygame para python2 2) Intenta importar pygame dentro

   import pygame

Si no obtiene un error, ha instalado Pygame correctamente en su sistema Linux :)

en mac OS

Hay dos formas de instalarlo en mac:

Método 1

Vaya a la página de descargas de Pygame y descargue el instalador de mac. Ejecútalo y debería instalar Pygame en tu Mac.

Método 2

Instalar Homebrew:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Luego use Homebrew para instalar Python 2.7.12 y Pygame:

brew install python; brew install homebrew/python/pygame

Ahora ejecute Python en su terminal e intente importar pygame. Si no dice nada, está instalado correctamente.

Importar pygame y dibujar en una pantalla

Empezando

Debe hacer lo siguiente para comenzar con Pygame:

import pygame

Esto abre una ventana de tamaño 640,480 y la almacena en una variable llamada pantalla.

Configuración de un nombre de ventana

Configurar un nombre para la ventana de pygame requiere la siguiente sintaxis:

pygame.display.set_caption('Name')

Acerca de la pantalla

  • El punto (0,0) está en la esquina superior izquierda de la pantalla.
  • Las coordenadas x aumentan de izquierda a derecha, las coordenadas y aumentan de arriba a abajo. Es decir, las coordenadas del lado derecho en el plano cartesiano son positivas y el lado izquierdo es negativo. Sin embargo, las coordenadas del lado superior en el plano cartesiano son negativas en la parte superior y positivo en la parte inferior. (Nota: Esto se considera si los puntos se toman desde el origen).

Actualización de la pantalla

Los cambios que realice en la pantalla, p. llenándolo de color o dibujando en él, ¡no aparezca inmediatamente! Así que ¿cómo se hace? Tienes que llamar a esta función:

pygame.display.update()

Colores

El coloreado en pygame funciona en modo RGB. El código para colorear es:

color_Name = (r,g,b)
  • R significa rojo.
  • G significa verde
  • B significa azul.
  • Los tres deben ser números enteros entre 0 y 255, siendo 255 el más brillante y 0 el más oscuro

Dibujo

  1. Para dibujar líneas

     pygame.draw.lines(screen, color, closed, pointlist, thickness)
    
  2. Para dibujar un rectángulo

     pygame.draw.rect(screen, color, (x,y,width,height), thickness)
    
  3. Para dibujar un círculo

    pygame.draw.circle(screen, color, (x,y), radius, thickness)
    

Configurando todo en un bucle

Para hacer un bucle usa el siguiente código:

running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()

Dibujar un rectángulo en la ventana de pygame (código)

import pygame
background_colour = (255,255,255) # White color
(width, height) = (300, 200) # Screen size
color=(0,0,0) #For retangle
screen = pygame.display.set_mode((width, height)) #Setting Screen
pygame.display.set_caption('Drawing') #Window Name
screen.fill(background_colour)#Fills white to screen
pygame.draw.rect(screen, color, (100,50,30,40), 1) #Drawing the rectangle
pygame.display.update()

#Loop
running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()