pygame Tutorial
Empezando con pygame

Observaciones

Versiones

Un simple 'juego'

Importar e inicializar

Cada módulo necesita ser importado 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, funcionarí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 un poco de legibilidad 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 desde 0 (sin luz) a 255 (luz completa).

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

En pygame usualmente 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 asignar un nombre a la imagen de los atributos y rect, ya que muchas funciones buscarán y usarán esos atributos. Estas 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 de juego

Ahora tenemos todo listo para nuestro bucle de juego. Este es un bucle 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 bucle se ejecute en un FPS determinado. Definimos el FPS y creamos nuestro reloj al comienzo del programa. El siguiente código asegurará que nuestro programa se duerma lo suficiente como para que nuestro bucle repita la cantidad que definimos como nuestro FPS . En este ejemplo, 60 veces por segundo.

clock.tick(FPS)

Entonces 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 obtendremos 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 de tipo que podemos comparar con las constantes en el módulo de 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 hacia abajo. En ese caso, el evento tiene una clave de atributo 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 podríamos querer borrar nuestra pantalla de la representación anterior. Lo hacemos llenando toda la pantalla con negro (elimine el código para ver por qué queremos borrarlo). Entonces tenemos que blit nuestra imagen a la pantalla. Bitting esencialmente significa copiar la imagen a otra superficie (en nuestro caso, la pantalla). Por último volteamos o actualizamos la pantalla.

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

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

Ahora tenemos un juego básico! Bastante aburrido, sí, ¡pero lo esencial está ahí! Combine esto con su conocimiento actual de Python y debería poder crear algo increíble.

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 cuándo presionamos la tecla y no cuando presionamos la tecla hacia abajo. Para solucionar esto podríamos introducir una variable de velocidad . Podemos crear una clase de jugador para mantenerla más organizada. Para evitar el movimiento dependiente del cuadro (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 deben mejorarse sobre este código. Te recomiendo que leas el tutorial de pygame y esta charla de Richard Jones para más información.

Instalando pygame

En las ventanas

1. Vaya a http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - un sitio no oficial que proporciona paquetes de Python de código abierto para la distribución oficial de CPython por Christoph Gohlke .

2. Descargue el archivo .whl .whl apropiado de acuerdo con su versión de python instalada. (El archivo se llama algo así como pygame - <pygame version> - <python version> - win32.whl )

3. correr

    pip install your-pygame-package.whl
   

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

4. Comprueba si puedes importar pygame como un módulo de python

   import pygame
   

   Si no recibe un error, ha instalado correctamente pygame en su computadora :)

En linux

1. Abre tu terminal y corre

   sudo apt-get install python-pygame
   

   Nota: Esto instalará pygame para python2

2. Intenta importar pygame dentro

   import pygame
   

   Si no recibe un error, ha instalado correctamente pygame en su sistema Linux :)

En macOS

Hay dos formas de instalarlo en mac:

Método 1

Ve a la página de descargas de Pygame y descarga 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 usa Homebrew para instalar Python 2.7.12 y Pygame:

brew install python; brew install homebrew/python/pygame

Ahora ejecuta Python en tu terminal e intenta import pygame . Si no dice nada, se instala con éxito.

Importación de pygame y dibujo en una pantalla.

Empezando

Debes 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

La configuración de un nombre para la ventana de pygame requiere la siguiente sintaxis:

pygame.display.set_caption('Name')

Sobre la pantalla

• El punto (0,0) se encuentra 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 arriba y positivas en la parte inferior. ( Nota : esto se considera si los puntos se toman del origen).

Actualizando la pantalla

Los cambios que realice en la pantalla, por ejemplo, llenándolos de color o dibujando en ella, ¡no se muestran de inmediato!
Así que ¿cómo se hace?
Tienes que llamar a esta función:

pygame.display.update()

Colores

La coloración 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, con 255 más brillantes y 0 más oscuros

Dibujo

1. Dibujar lineas

   pygame.draw.lines(screen, color, closed, pointlist, thickness)
   

2. Dibujar rectángulo

   pygame.draw.rect(screen, color, (x,y,width,height), thickness)
   

3. Dibujar circulo

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

Poner 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()

Dibujando 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()