pygame
Zeichnen auf dem Bildschirm

Syntax

• pygame.draw.rect (Oberfläche, Farbe, Rechteck, Breite = 0)
• pygame.draw.polygon (Oberfläche, Farbe, Punktliste, Breite = 0)
• pygame.draw.circle (Fläche, Farbe, Position, Radius, Breite = 0)
• pygame.draw.ellipse (Oberfläche, Farbe, Rechteck, Breite = 0)
• pygame.draw.arc (Fläche, Farbe, Rect, Startwinkel, Stoppwinkel, Breite = 1)
• pygame.draw.line (Oberfläche, Farbe, Start_Pos, End_Pos, Breite = 1)
• pygame.draw.lines (Fläche, Farbe, geschlossen, Punktliste, Breite = 1)
• pygame.draw.aaline (Oberfläche, Farbe, Startpos, Endpos, Mischung = 1)
• pygame.draw.aalines (Fläche, Farbe, geschlossen, Punktliste, Überblendung = 1)

Parameter

Zeichnen mit dem Draw-Modul

Pygame hat ein Modul, pygame.draw , das Funktionen enthält, mit denen Formen direkt auf eine Oberfläche pygame.draw werden können.

Verwendung des Moduls

Um das Modul verwenden zu können, müssen Sie zunächst Pygame korrekt importieren und initialisieren und einen Modus für die Anzeige einstellen. Es ist praktisch, Farbkonstanten im Voraus zu definieren, damit Ihr Code lesbarer und schöner wird. Alle Funktionen benötigen eine Oberfläche zum Zeichnen, ein Argument für Farbe und Position, bei dem es sich entweder um einen Pygame-Rect oder um eine 2-Element-Ganzzahl / Float-Sequenz handelt (der pygame.draw.circle nimmt aus undefinierten Gründen nur Ganzzahlen an).

Beispiel

Der folgende Code zeigt alle verschiedenen Funktionen, wie sie verwendet werden und wie sie aussehen. Wir initialisieren Pygame und definieren einige Konstanten vor den Beispielen.

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) 

Die schwarze Farbe ist die Standardfarbe der Fläche und repräsentiert den Teil der Fläche, auf den nicht gezeichnet wurde. Die Parameter jeder Funktion werden unten unter Parameter beschrieben .

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

Polygon

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)

Kreis

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)

Die Löcher sind eine unglückliche Folge des Zeichenalgorithmus von 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())

Die Löcher sind eine unglückliche Folge des Zeichenalgorithmus von Pygame.

Bogen

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.

Linie

size = (50, 50)

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

Linien

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)

Antialiasing-Leitung

size = (50, 50)

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

Antialiasing-Linien

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)

Versuch es

Um es selbst auszuprobieren: Kopieren Sie eines der obigen Code-Snippets und den Code in einer leeren Datei, ändern Sie das Namensbild in den Namen der Oberfläche, die Sie blitfen möchten, und experimentieren Sie.

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

Oberflächen

In Pygame verwenden Sie normalerweise Oberflächen, um das Erscheinungsbild von Objekten darzustellen, und Rechtecke, um deren Positionen darzustellen. Eine Oberfläche ist wie ein leeres Blatt Papier, das Farben oder Bilder enthält. Es gibt zwei Möglichkeiten, eine Oberfläche zu erstellen: Leer von Grund auf oder durch Laden eines Bildes.

Erstellen Sie eine Oberfläche

Um eine Fläche zu erstellen, benötigen Sie mindestens ihre Größe. Dies ist eine 2-Element-Ganzzahlsequenz aus Breite und Höhe, die die Größe in Pixel darstellt.

Sie können beim Erstellen einer Oberfläche auch zusätzliche Argumente übergeben, um die Bittiefe, Masken und zusätzliche Funktionen als Alpha-Pixel pro Pixel zu steuern und / oder das Bild im Videospeicher zu erstellen. Dies ist jedoch außerhalb des Anwendungsbereichs dieses Beispiels.

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

Sie können das Modul pygame.draw um Formen auf der Oberfläche zu zeichnen, oder sie mit einer Farbe füllen, indem Sie die Surface-Methode fill(color) aufrufen. Das Argument Farbe ist eine 3 oder 4-Element - integer - Sequenz oder ein pygame.Color Objekt.

Laden Sie ein Bild

Meistens möchten Sie Ihre eigenen Bilder in einem Spiel verwenden (so genannte Sprites). Das Erstellen einer Oberfläche mit einem Bild ist so einfach wie folgt:

my_image = pygame.image.load(path_to_image)

Der Pfad zum Bild kann relativ oder absolut sein. Um die Leistung zu verbessern, ist es normalerweise ratsam, Ihr Bild in das gleiche Pixelformat wie der Bildschirm zu konvertieren. Dies kann durch Aufrufen der Surface-Methode convert() wie folgt geschehen:

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

Wenn Ihr Bild Transparenz enthält (Alpha-Werte), rufen Sie stattdessen einfach die Methode convert_alpha() :

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

Blitting

Oberflächen müssen auf dem Bildschirm angezeigt werden, damit sie angezeigt werden können. Blitting bedeutet im Wesentlichen das Kopieren von Pixeln von einer Oberfläche zu einer anderen (der Bildschirm ist ebenfalls eine Oberfläche). Sie müssen auch die Position der Oberfläche übergeben, die eine Ganzzahlsequenz mit 2 Elementen oder ein Rect-Objekt sein sollte. Der oberste Punkt der Fläche wird an der Position platziert.

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

Es ist möglich, andere Flächen als den Bildschirm zu blenden. Um anzuzeigen, was auf dem Bildschirm geblendet wurde, müssen Sie pygame.display.update() oder pygame.display.flip() .

Transparenz

In Pygame werden drei Arten von Transparenz unterstützt: Colorkeys, Surface-Alphas und Pixel-Alphas.

Colorkeys

Macht eine Farbe vollständig transparent oder genauer, sodass eine Farbe einfach nicht blit ist. Wenn Sie ein Bild mit einem schwarzen Rechteck im Inneren haben, können Sie einen Farbton festlegen, um zu verhindern, dass die schwarze Farbe blit wird.

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

Eine Oberfläche kann nur eine Colorkey haben. Wenn Sie einen anderen Colorkey einstellen, wird der vorherige überschrieben. Colorkeys können keine unterschiedlichen Alpha-Werte haben, sie können nur eine Farbe nicht sichtbar machen.

Oberflächen-Alphas

Macht die gesamte Oberfläche durch einen Alpha-Wert transparent. Bei dieser Methode können Sie unterschiedliche Alpha-Werte verwenden, dies wirkt sich jedoch auf die gesamte Oberfläche aus.

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

Alpha pro Pixel

Macht jedes Pixel in der Oberfläche durch einen einzelnen Alpha-Wert transparent. Dies gibt Ihnen die größte Freiheit und Flexibilität, ist aber auch die langsamste Methode. Bei dieser Methode muss die Oberfläche auch als pro-Pixel-Alpha-Oberfläche erstellt werden, und die Farbargumente müssen eine vierte Alpha-Ganzzahl enthalten.

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

Die Oberfläche zeichnet jetzt Transparenz, wenn die Farbe den vierten Alpha-Wert enthält.

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

Im Gegensatz zu den anderen Oberflächen ist diese Standardfarbe der Oberfläche nicht schwarz, sondern transparent. Deshalb verschwindet das schwarze Rechteck in der Mitte.

Kombinieren Sie Colorkey und Surface Alpha

Colorkeys und Surface-Alphas können kombiniert werden, Alpha-Pixel jedoch nicht. Dies kann nützlich sein, wenn Sie nicht die Leistung einer Oberfläche pro Pixel verringern möchten.

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

Vollständiger Code

Kopieren Sie dies in eine leere Datei und führen Sie es aus. Drücken Sie die Tasten 1, 2, 3 oder 4, um die Bilder anzuzeigen. Drücken Sie mehrmals 2, 3 oder 4, um sie undurchsichtig zu machen.

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