pygame
Rysowanie na ekranie

Składnia

• pygame.draw.rect (powierzchnia, kolor, prostokąt, szerokość = 0)
• pygame.draw.polygon (powierzchnia, kolor, lista punktów, szerokość = 0)
• pygame.draw.circle (powierzchnia, kolor, pozycja, promień, szerokość = 0)
• pygame.draw.ellipse (powierzchnia, kolor, prostokąt, szerokość = 0)
• pygame.draw.arc (Surface, color, Rect, start_angle, stop_angle, width = 1)
• pygame.draw.line (Surface, color, start_pos, end_pos, width = 1)
• pygame.draw.lines (powierzchnia, kolor, zamknięty, lista punktów, szerokość = 1)
• pygame.draw.aaline (Surface, color, startpos, endpos, blend = 1)
• pygame.draw.aalines (Surface, color, closed, pointlist, blend = 1)

Parametry

Rysowanie za pomocą modułu do rysowania

Pygame ma moduł pygame.draw , który zawiera funkcje, które mogą rysować kształty bezpośrednio na powierzchni.

Jak korzystać z modułu

Aby skorzystać z modułu, musisz najpierw poprawnie zaimportować i zainicjować grę i ustawić tryb wyświetlania. Wygodne jest wcześniejsze zdefiniowanie stałych kolorów, dzięki czemu kod będzie bardziej czytelny i piękniejszy. Wszystkie funkcje wymagają rysowania powierzchni, koloru i argumentu pozycji, który jest albo pygame Rect, albo 2-elementową liczbą całkowitą / liczbą zmiennoprzecinkową ( pygame.draw.circle przyjmuje liczby całkowite tylko z nieokreślonych powodów).

Przykład

Poniższy kod pokaże wszystkie różne funkcje, jak są używane i jak wyglądają. Zainicjujemy grę i zdefiniujemy niektóre stałe przed przykładami.

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) 

Kolor czarny jest domyślnym kolorem powierzchni i reprezentuje tę część powierzchni, która nie została narysowana. Parametry każdej funkcji wyjaśniono poniżej w rozdziale Parametry .

Prosto

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

Wielokąt

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)

okrąg

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)

Dziury są niefortunną konsekwencją algorytmu rysowania gry.

Elipsa

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

Dziury są niefortunną konsekwencją algorytmu rysowania gry.

Łuk

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.

Linia

size = (50, 50)

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

Linie

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)

Linia antyaliasingowa

size = (50, 50)

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

Linie antyaliasingowe

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)

Wypróbuj to

Aby samemu to wypróbować: skopiuj jeden z fragmentów kodu powyżej i poniższy kod do pustego pliku, zmień obraz nazwy na nazwę Surface, który chcesz zablokować i eksperymentować.

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

Powierzchnie

W grze pygame zwykle używasz Powierzchni do reprezentowania wyglądu obiektów, a Prostokąty do reprezentowania ich pozycji. Powierzchnia jest jak pusty arkusz papieru, który zawiera kolory lub obrazy. Istnieją dwa sposoby utworzenia powierzchni: puste od zera lub poprzez załadowanie obrazu.

Utwórz powierzchnię

Aby utworzyć powierzchnię, potrzebujesz jej minimalnego rozmiaru, który jest 2-elementową całkowitą sekwencją szerokości i wysokości, reprezentującą rozmiar w pikselach.

Możesz również przekazać dodatkowe argumenty podczas tworzenia powierzchni, aby kontrolować głębokość bitów, maski i dodatkowe funkcje, takie jak alfa piksel i / lub utworzyć obraz w pamięci wideo. Jest to jednak poza zakresem tego przykładu.

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

Możesz użyć modułu pygame.draw , aby narysować kształty na powierzchni lub wypełnić go kolorem, wywołując metodę powierzchniową fill(color) . Kolor argumentu to 3 lub 4-elementowa sekwencja liczb całkowitych lub obiekt pygame.Color .

Załaduj obraz

Najczęściej chcesz używać własnych obrazów w grze (zwanych duszkami). Tworzenie powierzchni z włączonym obrazem jest tak proste, jak:

my_image = pygame.image.load(path_to_image)

Ścieżka do obrazu może być względna lub bezwzględna. Aby poprawić wydajność, zwykle rozsądnie jest przekonwertować obraz na ten sam format pikseli co ekran. Można to zrobić, wywołując metodę powierzchniową convert() , w następujący sposób:

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

Jeśli twój obraz zawiera przezroczystość (wartości alfa), po prostu wywołaj metodę convert_alpha() zamiast:

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

Blitting

Powierzchnie muszą być przesunięte na ekran, aby można je było wyświetlić. Blitting zasadniczo oznacza kopiowanie pikseli z jednej powierzchni na drugą (ekran jest również powierzchnią). Musisz także przekazać pozycję powierzchni, która powinna być 2-elementową liczbą całkowitą lub obiektem Rect. Lewa górna część powierzchni zostanie umieszczona w tym miejscu.

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

Możliwe jest połączenie z innymi powierzchniami niż ekran. Aby wyświetlić to, co zostało zablokowane na ekranie, musisz wywołać pygame.display.update() lub pygame.display.flip() .

Przezroczystość

Istnieją trzy rodzaje przezroczystości obsługiwane w grze pygame: colorkeys, Surface Alphas i per-pixel alpha.

Colorkeys

Sprawia, że kolor jest w pełni przezroczysty, a dokładniej, dzięki czemu kolor po prostu nie jest bezbarwny. Jeśli masz obraz z czarnym prostokątem w środku, możesz ustawić kolor kluczowy, aby zapobiec rozjaśnianiu się czarnego koloru.

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

Surface może mieć tylko jeden klucz koloru. Ustawienie innego klucza koloru nadpisze poprzednie. Colorkeys nie mogą mieć różnych wartości alfa, mogą jedynie sprawić, że kolor nie będzie widoczny.

Alfa powierzchni

Sprawia, że cała powierzchnia staje się przezroczysta dzięki wartości alfa. Dzięki tej metodzie możesz mieć różne wartości alfa, ale wpłynie to na całą powierzchnię.

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

Alfa na piksel

Sprawia, że każdy piksel na powierzchni staje się przezroczysty według indywidualnej wartości alfa. Zapewnia to największą swobodę i elastyczność, ale jest również najwolniejszą metodą. Ta metoda wymaga również utworzenia powierzchni jako powierzchni alfa na piksel, a argumenty koloru muszą zawierać czwartą liczbę całkowitą alfa.

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

Powierzchnia rysuje teraz przezroczystość, jeśli kolor zawiera czwartą wartość alfa.

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

W przeciwieństwie do innych powierzchni, domyślny kolor powierzchni nie będzie czarny, ale przezroczysty. Dlatego czarny prostokąt pośrodku znika.

Połącz colorkey i Surface alfa

Colorkeys i Surface alf można łączyć, ale alfa na piksel nie. Może to być przydatne, jeśli nie chcesz wolniejszej wydajności powierzchni na piksel.

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

Pełny kod

Skopiuj to do pustego pliku i uruchom. Naciśnij klawisze 1, 2, 3 lub 4, aby wyświetlić obrazy. Naciśnij kilkakrotnie 2, 3 lub 4, aby były bardziej nieprzezroczyste.

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