pygame
Tekening op het scherm

Syntaxis

• pygame.draw.rect (Surface, color, Rect, width = 0)
• pygame.draw.polygon (oppervlak, kleur, puntenlijst, breedte = 0)
• pygame.draw.circle (oppervlak, kleur, pos, straal, breedte = 0)
• pygame.draw.ellipse (Surface, color, Rect, width = 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 (Surface, color, closed, pointlist, width = 1)
• pygame.draw.aaline (oppervlak, kleur, startpos, endpos, blend = 1)
• pygame.draw.aalines (oppervlak, kleur, gesloten, puntenlijst, blend = 1)

parameters

Tekenen met de tekenmodule

Pygame heeft een module, pygame.draw , die functies bevat die vormen rechtstreeks naar een Surface kunnen tekenen.

Hoe de module te gebruiken

Om de module te gebruiken, moet u eerst pygame correct importeren en initialiseren en een modus instellen voor de weergave. Het is handig om vooraf kleurconstanten te definiëren, waardoor uw code leesbaarder en mooier wordt. Voor alle functies is een Surface nodig om op te tekenen, een kleur en een positieargument dat ofwel een pygame Rect is of een geheel getal met twee elementen (de pygame.draw.circle neemt alleen gehele getallen vanwege niet-gedefinieerde redenen).

Voorbeeld

De onderstaande code toont alle verschillende functies, hoe ze worden gebruikt en hoe ze eruit zien. We initialiseren pygame en definiëren enkele constanten vóór de voorbeelden.

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) 

De zwarte kleur is de standaardkleur van Surface en vertegenwoordigt het gedeelte van de Surface waarop niet is getekend. De parameters van elke functie worden hieronder uitgelegd bij Parameters .

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

Veelhoek

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)

Cirkel

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)

De gaten zijn een ongelukkig gevolg van het tekenalgoritme van pygame.

Ovaal

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

De gaten zijn een ongelukkig gevolg van het tekenalgoritme van pygame.

Boog

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.

Lijn

size = (50, 50)

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

lijnen

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)

Lijn met anti-aliasing

size = (50, 50)

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

Antialiasing lijnen

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)

Probeer het

Om het uit te proberen voor jezelf: exemplaar één van de code snippets bovenstaande en onderstaande code in een leeg bestand, afbeelding de naam te wijzigen om de naam van het oppervlak waarop u wilt blit en experiment.

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

oppervlakken

In pygame gebruik je meestal oppervlakken om het uiterlijk van objecten weer te geven en rechthoeken om hun posities weer te geven. Een Surface is als een blanco vel papier dat kleuren of afbeeldingen bevat. Er zijn twee manieren om een Surface te maken: helemaal leeg of door een afbeelding te laden.

Maak een oppervlak

Om een Surface te maken, heb je minimaal de grootte nodig, wat een uit twee elementen bestaande gehele reeks van breedte en hoogte is, die de grootte in pixels vertegenwoordigt.

Je kunt ook extra argumenten doorgeven bij het maken van een Surface om de bitdiepte, maskers en extra functies als alpha per pixel te regelen en / of de afbeelding in het videogeheugen te maken. Dit valt echter buiten het bestek van dit voorbeeld.

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

Je kunt de module pygame.draw gebruiken om vormen op het oppervlak te tekenen of het met een kleur vullen door de methode Surface-methode fill(color) aan te roepen. Het argument kleur is een 3- of 4-element integer sequentie of pygame.Color object.

Laad een afbeelding

Vaker wel dan niet wil je je eigen afbeeldingen gebruiken in een game (sprites genoemd). Een Surface maken met je afbeelding erop is net zo eenvoudig als:

my_image = pygame.image.load(path_to_image)

Het pad naar de afbeelding kan relatief of absoluut zijn. Om de prestaties te verbeteren is het meestal verstandig om uw afbeelding naar hetzelfde pixelformaat te converteren als het scherm. Dit kan worden gedaan door de Surface-methode convert() aan te roepen, als volgt:

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

Als uw afbeelding transparantie (alfawaarden) bevat, roept u in plaats daarvan de methode convert_alpha() :

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

blitting

Oppervlakken moeten op het scherm worden weergegeven om ze te kunnen weergeven. Blitting betekent in wezen het kopiëren van pixels van de ene naar de andere Surface (het scherm is ook een Surface). Je moet ook de positie van de Surface doorgeven, wat een geheel getal met 2 elementen of een object Rect moet zijn. De bovenkant van het oppervlak wordt op de positie geplaatst.

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

Het is mogelijk om te blitsen naar andere oppervlakken dan het scherm. Om te laten zien wat er op het scherm is weergegeven, moet je pygame.display.update() of pygame.display.flip() .

Transparantie

Er worden soorten 3 transparantie ondersteund in pygame: colorkeys, Surface alphas en alpha per pixel.

Colorkeys

Maakt een kleur volledig transparant, of nauwkeuriger, waardoor een kleur gewoon niet blit is. Als je een afbeelding hebt met een zwarte rechthoek erin, kun je een kleurtoets instellen om te voorkomen dat de zwarte kleur helder wordt.

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

Een Surface kan slechts één kleurtoets hebben. Als u een andere kleurtoets instelt, wordt de vorige overschreven. Kleurtoetsen kunnen geen verschillende alfawaarden hebben, het kan alleen een kleur niet zichtbaar maken.

Surface Alpha

Maakt het hele oppervlak transparant met een alfawaarde. Met deze methode kun je verschillende alfawaarden hebben, maar dit heeft invloed op de hele Surface.

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

Alfa per pixel

Maakt elke pixel in het oppervlak transparant met een individuele alfawaarde. Dit geeft u de meeste vrijheid en flexibiliteit, maar is ook de langzaamste methode. Voor deze methode moet de Surface ook worden gemaakt als een alfa-oppervlak per pixel en moeten de kleurargumenten een vierde alfa-geheel getal bevatten.

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

De Surface tekent nu transparantie als de kleur de vierde alfawaarde bevat.

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

In tegenstelling tot de andere oppervlakken is deze standaardkleur van Surface niet zwart maar transparant. Daarom verdwijnt de zwarte rechthoek in het midden.

Combineer colorkey en Surface alpha

Colorkeys en Surface alpha kunnen worden gecombineerd, maar alpha per pixel niet. Dit kan handig zijn als je geen tragere prestaties van een Surface per pixel wilt.

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

Volledige code

Kopieer dit in een leeg bestand en voer het uit. Druk op de toetsen 1, 2, 3 of 4 om de afbeeldingen te laten verschijnen. Druk meerdere keren op 2, 3 of 4 om ze ondoorzichtiger te maken.

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