pygame
Dessin sur l'écran

Syntaxe

• pygame.draw.rect (Surface, couleur, Rect, width = 0)
• pygame.draw.polygon (Surface, couleur, liste de points, largeur = 0)
• pygame.draw.circle (Surface, couleur, pos, rayon, largeur = 0)
• pygame.draw.ellipse (Surface, couleur, Rect, width = 0)
• pygame.draw.arc (Surface, couleur, Rect, start_angle, stop_angle, width = 1)
• pygame.draw.line (Surface, couleur, start_pos, end_pos, width = 1)
• pygame.draw.lines (Surface, couleur, fermé, liste de points, largeur = 1)
• pygame.draw.aaline (Surface, couleur, startpos, endpos, blend = 1)
• pygame.draw.aalines (Surface, couleur, fermé, liste de points, mélange = 1)

Paramètres

Dessin avec le module de dessin

Pygame a un module, pygame.draw , qui contient des fonctions qui peuvent dessiner des formes directement sur une surface.

Comment utiliser le module

Pour utiliser le module, vous devez d'abord importer et initialiser correctement pygame et définir un mode d'affichage. Il est pratique de définir les constantes de couleur à l’avance, ce qui rend votre code plus lisible et plus beau. Toutes les fonctions prennent une surface à dessiner, une couleur et un argument de position qui sont soit un pygame Rect, soit une séquence entière / flottante à 2 éléments (le pygame.draw.circle ne prendra que des entiers pour des raisons indéfinies).

Exemple

Le code ci-dessous présentera toutes les différentes fonctions, leur utilisation et leur apparence. Nous allons initialiser pygame et définir des constantes avant les exemples.

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) 

La couleur noire est la couleur par défaut de la surface et représente la partie de la surface sur laquelle on n'a pas dessiné. Les paramètres de chaque fonction sont expliqués ci-dessous dans Paramètres .

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

Polygone

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)

Cercle

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)

Les trous sont une conséquence malheureuse de l'algorithme de dessin de pygame.

Ellipse

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

Les trous sont une conséquence malheureuse de l'algorithme de dessin de pygame.

Arc

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.

Ligne

size = (50, 50)

line = pygame.Surface(size)
pygame.draw.line(line, RED, (0, 0), (50, 50))  # Start at topleft and ends at bottomright.

Lignes

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)

Ligne anti-aliasée

size = (50, 50)

antialiased_line = pygame.Surface(size)
pygame.draw.aaline(antialiased_line, RED, (0, 0), (50, 50))

Lignes anti-aliasées

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)

Essaye le

Pour l'essayer vous-même: copiez l'un des extraits de code ci-dessus et le code ci-dessous dans un fichier vide, remplacez l' image du nom par le nom de la surface que vous souhaitez rendre visible et expérimentez.

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

Les surfaces

Dans Pygame, vous utilisez généralement les surfaces pour représenter l'apparence des objets et les rectangles pour représenter leurs positions. Une surface est comme une feuille de papier vierge contenant des couleurs ou des images. Il y a deux manières de créer une surface: vide à partir de zéro ou en chargeant une image.

Créer une surface

Pour créer une surface, il vous faut au minimum sa taille, qui est une séquence de 2 éléments de largeur et de hauteur, représentant la taille en pixels.

Vous pouvez également transmettre des arguments supplémentaires lors de la création d'une surface pour contrôler la profondeur de bits, les masques et les fonctionnalités supplémentaires en tant qu'alpha par pixel et / ou créer l'image dans la mémoire vidéo. Cela sort cependant du cadre de cet exemple.

size = width, height = (32, 32)
empty_surface = pygame.Surface(size)

Vous pouvez utiliser le module pygame.draw pour dessiner des formes sur la surface ou le remplir avec une couleur en appelant le fill(color) la méthode Surface. La couleur de l' argument est une séquence entière de 3 ou 4 éléments ou un objet pygame.Color .

Charger une image

Le plus souvent, vous souhaitez utiliser vos propres images dans un jeu (appelées sprites). Créer une surface avec votre image est aussi simple que:

my_image = pygame.image.load(path_to_image)

Le chemin vers l'image peut être relatif ou absolu. Pour améliorer les performances, il est généralement judicieux de convertir votre image au même format de pixel que l'écran. Cela peut être fait en appelant la méthode de convert() , comme ceci:

my_image = pygame.image.load(path_to_image).convert()

Si votre image contient de la transparence (valeurs alpha), il vous suffit d'appeler la méthode convert_alpha() place:

my_image = pygame.image.load(path_to_image).convert_alpha()

Blitting

Les surfaces doivent être transparentes à l'écran pour pouvoir les afficher. Blitting signifie essentiellement copier des pixels d'une Surface à une autre (l'écran est également une Surface). Vous devez également passer la position de la surface, qui doit être une séquence entière à 2 éléments ou un objet Rect. La partie supérieure de la surface sera placée à la position.

screen.blit(my_image, (0, 0))
pygame.display.update()  # or pygame.display.flip()

Il est possible de blinder d'autres surfaces que l'écran. Pour afficher ce qui a été affiché à l'écran, vous devez appeler pygame.display.update() ou pygame.display.flip() .

Transparence

Il existe trois types de transparence pris en charge dans pygame: colorkeys, alphas de surface et alphas par pixel.

Colorkeys

Donne une couleur totalement transparente, ou plus exactement, en faisant simplement une couleur qui ne soit pas blit. Si vous avez une image avec un rectangle noir à l'intérieur, vous pouvez définir un colorkey pour empêcher la couleur noire d'être blit.

BLACK = (0, 0, 0)
my_image.set_colorkey(BLACK)  # Black colors will not be blit.

Une surface ne peut avoir qu'un seul colorkey. Définir un autre colorkey remplacera le précédent. Les Colorkeys ne peuvent pas avoir de valeurs alpha différentes, elles ne peuvent que rendre une couleur invisible.

Alphas de surface

Rend toute la surface transparente par une valeur alpha. Avec cette méthode, vous pouvez avoir différentes valeurs alpha mais cela affectera toute la surface.

my_image.set_alpha(100)  # 0 is fully transparent and 255 fully opaque.

Alpha par pixel

Rend chaque pixel de la Surface transparent par une valeur alpha individuelle. Cela vous donne le plus de liberté et de flexibilité, mais c'est aussi la méthode la plus lente. Cette méthode nécessite également que la surface soit créée en tant que surface alpha par pixel et que les arguments de couleur doivent contenir un quatrième entier alpha.

size = width, height = (32, 32)
my_image = pygame.Surface(size, pygame.SRCALPHA)  # Creates an empty per-pixel alpha Surface.

La surface va maintenant dessiner la transparence si la couleur contient la quatrième valeur alpha.

BLUE = (0, 0, 255, 255)
pygame.draw.rect(my_image, BLUE, my_image.get_rect(), 10)

Contrairement aux autres surfaces, cette couleur par défaut de la surface ne sera pas noire mais transparente. C'est pourquoi le rectangle noir au milieu disparaît.

Combinaison de colorkey et de surface alpha

Colorkeys et Surface alphas peuvent être combinés, mais alpha par pixel impossible. Cela peut être utile si vous ne voulez pas les performances plus lentes d'une surface par pixel.

purple_image.set_colorkey(BLACK)
purple_image.set_alpha(50)

Code complet

Copiez ceci dans un fichier vide et lancez-le. Appuyez sur les touches 1, 2, 3 ou 4 pour faire apparaître les images. Appuyez sur 2, 3 ou 4 fois pour les rendre plus opaques.

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