pygame
Disegnare sullo schermo

Sintassi

• pygame.draw.rect (Superficie, colore, Rettangolo, larghezza = 0)
• pygame.draw.polygon (Superficie, colore, lista puntiforme, larghezza = 0)
• pygame.draw.circle (Superficie, colore, pos, raggio, larghezza = 0)
• pygame.draw.ellipse (Superficie, colore, Rettangolo, larghezza = 0)
• pygame.draw.arc (Superficie, colore, Rect, start_angle, stop_angle, width = 1)
• pygame.draw.line (Superficie, colore, start_pos, end_pos, larghezza = 1)
• pygame.draw.lines (Superficie, colore, chiuso, lista puntiforme, larghezza = 1)
• pygame.draw.aaline (Superficie, colore, startpos, endpos, blend = 1)
• pygame.draw.aalines (Superficie, colore, chiuso, elenco punti, blend = 1)

Parametri

Disegnare con il modulo di disegno

Pygame ha un modulo, pygame.draw , che contiene funzioni che possono disegnare forme direttamente su una superficie.

Come usare il modulo

Per usare il modulo devi prima importare e inizializzare correttamente pygame e impostare una modalità per la visualizzazione. È comodo definire le costanti del colore in anticipo, rendendo il codice più leggibile e più bello. Tutte le funzioni impiegano una superficie per disegnare, un colore e un argomento di posizione che è sia un pygame Rect o una sequenza di numeri interi / float di 2 elementi (il pygame.draw.circle prenderà solo interi a causa di motivi indefiniti).

Esempio

Il codice seguente mostrerà tutte le diverse funzioni, come vengono utilizzati e come appaiono. Inizializzeremo pygame e definiremo alcune costanti prima degli esempi.

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) 

Il colore nero è il colore di default della superficie e rappresenta la parte della superficie su cui non è stata disegnata. I parametri di ciascuna funzione sono spiegati di seguito a Parametri .

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

Poligono

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)

Cerchio

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)

I buchi sono una sfortunata conseguenza dell'algoritmo di disegno di Pygame.

Ellisse

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

I buchi sono una sfortunata conseguenza dell'algoritmo di disegno di 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.

Linea

size = (50, 50)

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

Linee

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)

Linea antialias

size = (50, 50)

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

Linee antialias

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)

Provalo

Per provarlo tu stesso: copia uno dei frammenti di codice sopra e il codice sottostante in un file vuoto, cambia l' immagine del nome con il nome della superficie che vuoi miscelare e sperimentare.

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

superfici

In pygame di solito usi le Superfici per rappresentare l'aspetto degli oggetti, e Rettangoli per rappresentare le loro posizioni. Una superficie è come un foglio di carta bianco che contiene colori o immagini. Esistono due modi per creare una superficie: vuota da zero o caricando un'immagine.

Crea una superficie

Per creare una superficie è necessario almeno la sua dimensione, che è una sequenza intera di 2 elementi di larghezza e altezza, che rappresenta la dimensione in pixel.

È inoltre possibile passare argomenti aggiuntivi durante la creazione di una superficie per controllare profondità di bit, maschere e funzioni aggiuntive come alfa per pixel e / o creare l'immagine nella memoria video. Questo è al di fuori dello scopo di questo esempio però.

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

È possibile utilizzare il modulo pygame.draw per disegnare forme sulla superficie o riempirlo con un colore chiamando il fill(color) metodo Surface fill(color) . Il colore dell'argomento è una sequenza di numeri interi a 3 o 4 elementi o un oggetto pygame.Color .

Carica un'immagine

Molto spesso ti piacerebbe utilizzare le tue immagini in un gioco (chiamato sprites). Creare una superficie con la tua immagine è facile come:

my_image = pygame.image.load(path_to_image)

Il percorso dell'immagine può essere relativo o assoluto. Per migliorare le prestazioni, in genere è consigliabile convertire l'immagine nello stesso formato di pixel dello schermo. Questo può essere fatto chiamando il metodo Surface convert() , in questo modo:

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

Se l'immagine contiene trasparenza (valori alfa), si chiama invece il metodo convert_alpha() :

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

blitting

Le superfici devono essere masticate allo schermo per poterle visualizzare. Blittare significa essenzialmente copiare i pixel da una superficie all'altra (anche lo schermo è una superficie). È inoltre necessario passare la posizione di Surface, che dovrebbe essere una sequenza di numeri interi a 2 elementi o un oggetto Rect. Il topleft di Surface verrà posizionato nella posizione.

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

È possibile eseguire il blit su altre Superfici rispetto allo schermo. Per visualizzare ciò che è stato visualizzato sullo schermo, devi chiamare pygame.display.update() o pygame.display.flip() .

Trasparenza

Sono supportati i tipi 3 di trasparenza in pygame: colorkeys, alfa di Surface e alpha per pixel.

Colorkeys

Rende un colore completamente trasparente o, più esattamente, rendendo semplicemente un colore non facile. Se hai un'immagine con un rect nero all'interno puoi impostare un colorkey per evitare che il colore nero sia blitante.

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

Una superficie può avere solo una colorkey. L'impostazione di un'altra colorkey sovrascriverà la precedente. I colorkeys non possono avere valori alfa diversi, possono solo rendere un colore non visibile.

Alfa di superficie

Rende trasparente l'intera superficie con un valore alfa. Con questo metodo è possibile avere valori alfa diversi ma interesserà l'intera superficie.

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

Per pixel alfa

Rende trasparenti tutti i pixel della superficie con un valore alfa individuale. Questo ti dà la massima libertà e flessibilità, ma è anche il metodo più lento. Questo metodo richiede anche che Surface sia creato come una superficie alfa per pixel e che gli argomenti colore debbano contenere un quarto intero alfa.

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

La superficie ora disegnerà trasparenza se il colore contiene il quarto valore alfa.

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

A differenza delle altre Superfici, questo colore di default di Surface non sarà nero ma trasparente. Ecco perché il rettangolo nero nel mezzo scompare.

Combina colorkey e Surface alpha

Colorkeys e alfa di superficie possono essere combinati, ma non possono essere eseguiti per pixel alfa. Questo può essere utile se non vuoi le prestazioni più lente di una superficie per pixel.

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

Codice completo

Copia questo in un file vuoto ed eseguilo. Premere i tasti 1, 2, 3 o 4 per visualizzare le immagini. Premi 2, 3 o 4 più volte per renderli più opachi.

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