pygame
Ritning på skärmen

Syntax

• pygame.draw.rect (Yta, färg, Rekt, bredd = 0)
• pygame.draw.polygon (Yta, färg, punktlista, bredd = 0)
• pygame.draw.circle (Yta, färg, pos, radie, bredd = 0)
• pygame.draw.ellipse (Yta, färg, Rekt, bredd = 0)
• pygame.draw.arc (Yta, färg, Rect, start_angle, stop_angle, width = 1)
• pygame.draw.line (Yta, färg, start_pos, slut_pos, bredd = 1)
• pygame.draw.lines (Yta, färg, stängd, punktlista, bredd = 1)
• pygame.draw.aaline (Yta, färg, startpos, endpos, blandning = 1)
• pygame.draw.aalines (Yta, färg, stängd, punktlista, blandning = 1)

parametrar

Ritning med dragmodulen

Pygame har en modul, pygame.draw , som innehåller funktioner som kan rita former direkt till en yta.

Hur man använder modulen

För att använda modulen måste du först importera och initiera pygame korrekt och ställa in ett läge för displayen. Det är bekvämt att definiera färgkonstanter i förväg, vilket gör din kod mer läsbar och vackrare. Alla funktioner tar en yta att dra på, en färg och ett positionsargument som antingen är en pygame-rekt eller en 2-element heltal / float-sekvens ( pygame.draw.circle bara heltal på grund av odefinierade skäl).

Exempel

Koden nedan visar alla olika funktioner, hur de används och hur de ser ut. Vi initierar pygame och definierar några konstanter före exemplen.

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) 

Den svarta färgen är Surface-standardfärgen och representerar den del av ytan som inte har dragits på. Parametrarna för varje funktion förklaras nedan under Parametrar .

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)

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)

Hålen är en olycklig konsekvens av pygames ritningsalgoritm.

Ellips

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

Hålen är en olycklig konsekvens av pygames ritningsalgoritm.

Båge

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.

Linje

size = (50, 50)

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

Rader

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)

Antialiated linje

size = (50, 50)

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

Antialiated linjer

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)

Testa

För att testa det själv: kopiera en av kodavsnitten ovan och koden nedan i en tom fil, ändra namnbilden till namnet på den yta du vill spruta och experimentera.

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

ytor

I pygame använder du vanligtvis ytor för att representera utseendet på objekt och rektanglar för att representera deras positioner. En yta är som ett tomt pappersark som innehåller färger eller bilder. Det finns två sätt att skapa en yta: tom från grunden eller genom att ladda en bild.

Skapa en yta

För att skapa en yta behöver du minst dess storlek, som är en två-element heltalssekvens av bredd och höjd, som representerar storleken i pixlar.

Du kan också skicka ytterligare argument när du skapar en yta för att kontrollera bitdjup, masker och ytterligare funktioner som per-pixel alfa och / eller skapa bilden i videominnet. Detta är dock utanför ramen för detta exempel.

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

Du kan använda modulen pygame.draw att rita former på ytan, eller fylla den med en färg genom att kalla ytan för fill(color) . Argumentet färg är en 3 eller 4-elementet heltal sekvens eller en pygame.Color objekt.

Ladda en bild

Oftare än inte vill du använda dina egna bilder i ett spel (kallas sprites). Att skapa en yta med din bild på är lika enkelt som:

my_image = pygame.image.load(path_to_image)

Sökvägen till bilden kan vara relativ eller absolut. För att förbättra prestandan är det vanligtvis klokt att konvertera din bild till samma pixelformat som skärmen. Detta kan göras genom att kalla Surface-metoden convert() , så här:

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

Om din bild innehåller transparens (alfavärden) kallar du bara metoden convert_alpha() istället:

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

blitting

Ytor måste smutsas på skärmen för att kunna visa dem. Blitting betyder i huvudsak att kopiera pixlar från en yta till en annan (skärmen är också en yta). Du måste också passera positionen för ytan, som bör vara en hel-helhetssekvens eller ett Rect-objekt. Ytan på ytan placeras på platsen.

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

Det är möjligt att smita på andra ytor än skärmen. För att visa vad som har blitsat på skärmen måste du ringa pygame.display.update() eller pygame.display.flip() .

Genomskinlighet

Det finns olika typer av transparens som stöds i pygame: färgknappar, Surface alphas och per-pixel alphas.

Colorkeys

Gör en färg helt genomskinlig, eller mer exakt, vilket gör att en färg helt enkelt inte är blank. Om du har en bild med en svart rekt inne kan du ställa in en färgknapp för att förhindra att den svarta färgen blir vit.

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

En yta kan bara ha en färgnyckel. Att ställa in en annan färgnyckel kommer att skriva över den föregående. Färgknappar kan inte ha olika alfavärden, de kan bara göra en färg inte synlig.

Ytealfas

Gör hela ytan transparent med ett alfavärde. Med den här metoden kan du ha olika alfavärden men det kommer att påverka hela ytan.

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

Per-pixel alfa

Gör varje pixel i ytan transparent med ett individuellt alfavärde. Detta ger dig mest frihet och flexibilitet men är också den långsammaste metoden. Denna metod kräver också att ytan skapas som en alfa-yta per pixel, och färgargumenten måste innehålla ett fjärde alfahtal.

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

Ytan drar nu transparens om färgen innehåller det fjärde alfavärdet.

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

Till skillnad från de andra ytorna är denna ytfärgsfärg inte svart men transparent. Det är därför den svarta rektangeln i mitten försvinner.

Kombinera färgnyckel och yta alfa

Colorkeys och Surface alphas kan kombineras, men alfa per pixel kan inte. Detta kan vara användbart om du inte vill ha en långsammare prestanda för en yta per pixel.

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

Fullständig kod

Kopiera den i en tom fil och kör den. Tryck på knapparna 1, 2, 3 eller 4 för att få bilderna att visas. Tryck på 2, 3 eller 4 flera gånger för att göra dem mer ogenomskinliga.

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