pygame
Dibujo en la pantalla
Buscar..
Sintaxis
- pygame.draw.rect (Superficie, color, Rect, ancho = 0)
- pygame.draw.polygon (Superficie, color, lista de puntos, ancho = 0)
- pygame.draw.circle (Superficie, color, pos, radio, ancho = 0)
- pygame.draw.ellipse (Superficie, color, Rect, ancho = 0)
- pygame.draw.arc (Superficie, color, Rect, start_angle, stop_angle, width = 1)
- pygame.draw.line (Surface, color, start_pos, end_pos, width = 1)
- pygame.draw.lines (Superficie, color, cerrado, lista de puntos, ancho = 1)
- pygame.draw.aaline (Surface, color, startpos, endpos, blend = 1)
- pygame.draw.aalines (Surface, color, closed, pointlist, blend = 1)
Parámetros
| Parámetros | Detalles |
|---|---|
| Superficie | La superficie para dibujar la forma. |
| color | Una secuencia de 3 o 4 enteros que representan rojo, verde y azul (y alfa), cada valor oscila entre 0-255. |
| Rect | Un área rectangular donde se dibujará la forma. |
| anchura | El ancho de las líneas. La forma se rellenará si ancho = 0. |
| lista de puntos | Una lista de una cantidad arbitraria de puntos / vértices, en píxeles (x, y). |
| pos | La posición del centro del círculo, en píxeles (x, y). |
| radio | El radio de los círculos en píxeles. |
| cerrado | Si es verdadero, se dibujará una línea entre el último y el primer punto, cerrando la forma. |
| mezcla = 1 | Si es verdadero, los tonos se mezclarán con los tonos de píxeles existentes en lugar de sobrescribirlos. |
| ángulo inicial | El ángulo inicial del arco, en radianes. |
| stop_angle | El ángulo final del arco, en radianes. |
| start_pos | La posición inicial de la línea, en píxeles. |
| end_pos | La posición final de la línea, en píxeles. |
Dibujando con el módulo de dibujo.
Pygame tiene un módulo, pygame.draw , que contiene funciones que pueden dibujar formas directamente en una superficie.
| Función | Descripción |
|---|---|
| pygame.draw.rect | dibujar una forma de rectángulo |
| pygame.draw.polygon | Dibuja una forma con cualquier número de lados. |
| pygame.draw.circle | dibujar un círculo alrededor de un punto |
| pygame.draw.ellipse | dibujar una forma redonda dentro de un rectángulo |
| pygame.draw.arc | dibujar una sección parcial de una elipse |
| pygame.draw.line | dibujar un segmento de línea recta |
| pygame.draw.lines | dibujar múltiples segmentos de línea contiguos |
| pygame.draw.aaline | dibujar líneas finas antialias |
| pygame.draw.aalines | dibujar una secuencia conectada de lineas antialias |
Cómo utilizar el módulo
Para usar el módulo, primero debe importar e inicializar pygame correctamente y configurar un modo para la pantalla. Es conveniente definir de antemano las constantes de color, haciendo que su código sea más legible y hermoso. Todas las funciones toman una superficie para dibujar, un color y un argumento de posición que es un Recto de pygame o una secuencia de entero / flotante de 2 elementos (el pygame.draw.circle solo tomará enteros debido a razones indefinidas).
Ejemplo
El código a continuación mostrará todas las diferentes funciones, cómo se usan y cómo se ven. Inicializaremos pygame y definiremos algunas constantes antes de los ejemplos.
import pygame
from math import pi
pygame.init()
screen = pygame.display.set_mode((100, 100))
WHITE = pygame.Color(255, 255, 255)
RED = pygame.Color(255, 0, 0)
El color negro es el color predeterminado de la superficie y representa la parte de la superficie sobre la que no se ha dibujado. Los parámetros de cada función se explican a continuación en Parámetros .
Rect
size = (50, 50)
rect_border = pygame.Surface(size) # Create a Surface to draw on.
pygame.draw.rect(rect_border, RED, rect_border.get_rect(), 10) # Draw on it.
rect_filled = pygame.Surface(size)
pygame.draw.rect(rect_filled, RED, rect_filled.get_rect())
Polígono
size = (50, 50)
points = [(25, 0), (50, 25), (25, 50), (0, 25)] # The corner points of the polygon.
polygon = pygame.Surface(size)
pygame.draw.polygon(polygon, RED, points, 10)
polygon_filled = pygame.Surface(size)
pygame.draw.polygon(polygon_filled, RED, points)
Circulo
size = (50, 50)
radius = 25
circle = pygame.Surface(size)
pygame.draw.circle(circle, RED, (radius, radius), radius, 10) # Position is the center of the circle.
circle_filled = pygame.Surface(size)
pygame.draw.circle(circle_filled, RED, (radius, radius), radius)
Los agujeros son una consecuencia desafortunada del algoritmo de dibujo de pygame.
Elipse
size = (50, 25) # Minimize it's height so it doesn't look like a circle.
ellipse = pygame.Surface(size)
pygame.draw.ellipse(ellipse, RED, ellipse.get_rect(), 5)
ellipse_filled = pygame.Surface(size)
pygame.draw.ellipse(ellipse_filled, RED, ellipse.get_rect())
Los agujeros son una consecuencia desafortunada del algoritmo de dibujo de pygame.
Arco
size = (50, 50)
arc = pygame.Surface(size)
pygame.draw.arc(arc, RED, arc.get_rect(), 0, pi) # 0 to pi is 180° creating a half circle.
Línea
size = (50, 50)
line = pygame.Surface(size)
pygame.draw.line(line, RED, (0, 0), (50, 50)) # Start at topleft and ends at bottomright.
Líneas
size = (50, 50)
points = [(25, 0), (50, 25), (25, 50), (0, 25)]
lines = pygame.Surface(size)
pygame.draw.lines(lines, RED, False, points)
lines_closed = pygame.Surface(size)
pygame.draw.lines(lines_closed, RED, True, points)
Línea de antialias
size = (50, 50)
antialiased_line = pygame.Surface(size)
pygame.draw.aaline(antialiased_line, RED, (0, 0), (50, 50))
Líneas suavizadas
size = (50, 50)
points = [(25, 0), (50, 25), (25, 50), (0, 25)]
antialiased_lines = pygame.Surface(size)
pygame.draw.aalines(antialiased_lines, RED, False, points)
antialiased_lines_closed = pygame.Surface(size)
pygame.draw.aalines(antialiased_lines_closed, RED, True, points)
Pruébalo
Para probarlo por ti mismo: copie uno de los fragmentos de código de arriba y el código de abajo en un archivo vacío, cambie la imagen del nombre al nombre de la superficie que desea mezclar y experimentar.
import pygame
from math import pi
pygame.init()
screen = pygame.display.set_mode((100, 100))
WHITE = pygame.Color(255, 255, 255)
RED = pygame.Color(255, 0, 0)
# But code snippet here
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
quit()
screen.blit(image, (25, 25))
pygame.display.update()
Superficies
En pygame, usualmente utilizas Superficies para representar la apariencia de los objetos, y Rectángulos para representar sus posiciones. Una superficie es como una hoja de papel en blanco que contiene colores o imágenes. Hay dos formas de crear una superficie: en blanco desde cero o cargando una imagen.
Crear una superficie
Para crear una superficie, necesita un tamaño mínimo, que es una secuencia entera de ancho y alto de 2 elementos, que representa el tamaño en píxeles.
También puede pasar argumentos adicionales al crear una Superficie para controlar la profundidad de bits, máscaras y funciones adicionales como alfa por píxel y / o crear la imagen en la memoria de video. Esto está fuera del alcance de este ejemplo sin embargo.
size = width, height = (32, 32)
empty_surface = pygame.Surface(size)
Puede usar el módulo pygame.draw para dibujar formas en la superficie, o rellénelo con un color llamando al método de fill(color) la superficie fill(color) . El color del argumento es una secuencia de enteros de 3 o 4 elementos o un objeto pygame.Color .
Cargar una imagen
La mayoría de las veces, le gustaría usar sus propias imágenes en un juego (llamadas sprites). Crear una superficie con tu imagen es tan fácil como:
my_image = pygame.image.load(path_to_image)
El camino a la imagen puede ser relativo o absoluto. Para mejorar el rendimiento, generalmente es aconsejable convertir su imagen al mismo formato de píxeles que la pantalla. Esto se puede hacer llamando al método de Surface convert() , así:
my_image = pygame.image.load(path_to_image).convert()
Si su imagen contiene transparencias (valores alfa) simplemente llame al método convert_alpha() lugar:
my_image = pygame.image.load(path_to_image).convert_alpha()
Blitting
Las superficies deben estar marcadas en la pantalla para poder mostrarlas. Fundir esencialmente significa copiar píxeles de una superficie a otra (la pantalla también es una superficie). También debe pasar la posición de la superficie, que debe ser una secuencia de enteros de 2 elementos o un objeto Rect. El tope de la superficie se colocará en la posición.
screen.blit(my_image, (0, 0))
pygame.display.update() # or pygame.display.flip()
Es posible hacer blit a otras superficies que no sean la pantalla. Para mostrar lo que se ha borrado en la pantalla, debe llamar a pygame.display.update() o pygame.display.flip() .
Transparencia
Hay tipos 3 de transparencia admitidos en pygame: colorkeys, alfas de superficie y alfas de píxel.
Colorkeys
Hace que un color sea completamente transparente, o más exactamente, haciendo que un color simplemente no se vea. Si tiene una imagen con un rectángulo negro en su interior, puede establecer una combinación de colores para evitar que el color negro se vea borroso.
BLACK = (0, 0, 0)
my_image.set_colorkey(BLACK) # Black colors will not be blit.
Una superficie solo puede tener un colorkey. Configurar otro colorkey sobrescribirá el anterior. Colorkeys no puede tener valores alfa diferentes, solo puede hacer que un color no sea visible.
Alfas de superficie
Hace que toda la superficie sea transparente por un valor alfa. Con este método, puede tener diferentes valores alfa, pero afectará a toda la superficie.
my_image.set_alpha(100) # 0 is fully transparent and 255 fully opaque.
Alfa por píxel
Hace que cada píxel de la superficie sea transparente por un valor alfa individual. Esto te da la mayor libertad y flexibilidad, pero también es el método más lento. Este método también requiere que la Superficie se cree como una Superficie alfa por píxel, y los argumentos de color deben contener un cuarto entero alfa.
size = width, height = (32, 32)
my_image = pygame.Surface(size, pygame.SRCALPHA) # Creates an empty per-pixel alpha Surface.
La superficie ahora dibujará transparencia si el color contiene el cuarto valor alfa.
BLUE = (0, 0, 255, 255)
pygame.draw.rect(my_image, BLUE, my_image.get_rect(), 10)
A diferencia de las otras Superficies, este color predeterminado de la Superficie no será negro sino transparente. Es por eso que el rectángulo negro en el medio desaparece.
Combina colorkey y superficie alfa
Los alfas de Colorkey y Superficie pueden combinarse, pero no el alfa por píxel. Esto puede ser útil si no desea el rendimiento más lento de una superficie por píxel.
purple_image.set_colorkey(BLACK)
purple_image.set_alpha(50)
Codigo completo
Copie esto en un archivo vacío y ejecútelo. Presione las teclas 1, 2, 3 o 4 para que aparezcan las imágenes. Presione 2, 3 o 4 varias veces para hacerlos más opacos.
import pygame
pygame.init()
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255, 50) # This color contains an extra integer. It's the alpha value.
PURPLE = (255, 0, 255)
screen = pygame.display.set_mode((200, 325))
screen.fill(WHITE) # Make the background white. Remember that the screen is a Surface!
clock = pygame.time.Clock()
size = (50, 50)
red_image = pygame.Surface(size)
green_image = pygame.Surface(size)
blue_image = pygame.Surface(size, pygame.SRCALPHA) # Contains a flag telling pygame that the Surface is per-pixel alpha
purple_image = pygame.Surface(size)
red_image.set_colorkey(BLACK)
green_image.set_alpha(50)
# For the 'blue_image' it's the alpha value of the color that's been drawn to each pixel that determines transparency.
purple_image.set_colorkey(BLACK)
purple_image.set_alpha(50)
pygame.draw.rect(red_image, RED, red_image.get_rect(), 10)
pygame.draw.rect(green_image, GREEN, green_image.get_rect(), 10)
pygame.draw.rect(blue_image, BLUE, blue_image.get_rect(), 10)
pygame.draw.rect(purple_image, PURPLE, purple_image.get_rect(), 10)
while True:
clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_1:
screen.blit(red_image, (75, 25))
elif event.key == pygame.K_2:
screen.blit(green_image, (75, 100))
elif event.key == pygame.K_3:
screen.blit(blue_image, (75, 175))
elif event.key == pygame.K_4:
screen.blit(purple_image, (75, 250))
pygame.display.update()