pygame Handledning
Komma igång med pygame

Anmärkningar

versioner

Ett enkelt "spel"

Importera och initialisera

Varje modul måste importeras och pygame är inget undantag. Även om vi måste kalla funktionen pygame.init() för att alla importerade moduler i pygame ska initialiseras ordentligt. Om vi glömmer detta fungerar vissa moduler inte. Funktionen returnerar också en tupel av alla framgångsrika och misslyckade initialiseringar (det kommer inte att ge ett fel om en modul inte initialiseras).

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))

Skapa nödvändigheter

Vi måste också skapa en skärm. Pygame har redan skapat en (dold) skärm, så allt vi behöver göra är att ställa in skärmens läge (i det här exemplet ställer vi bara in upplösningen). Det är också en bra idé att skapa en klocka för att se till att vårt program uppdateras med en fast hastighet (annars skulle den köras med olika hastigheter beroende på hur snabb datorn är).

screen = pygame.display.set_mode((720, 480))  # Notice the tuple! It's not 2 arguments.
clock = pygame.time.Clock()
FPS = 60  # This variable will define how many frames we update per second.

För lite läsbarhet senare i vår kod skapar vi två färgkonstanter, som representerar en tupel av Röd, Grön och Blå (RGB). Värdena går från 0 (inget ljus) till 255 (fullt ljus).

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

I pygame använder vi vanligtvis en yta för att representera ett objekts utseende, och en rekt (rektangel) för att representera ett objekts position. En yta är som ett tomt pappersark som innehåller färger eller bilder. Om du gör en klass bör du namnge attributen bild och rekt eftersom många funktioner kommer att leta efter och använda dessa attribut. Sådana klasser skulle gynnas genom att ärva pygame.sprite.Sprite klassen av skäl som du kan läsa om här .

rect = pygame.Rect((0, 0), (32, 32))  # First tuple is position, second is size.
image = pygame.Surface((32, 32))  # The tuple represent size.
image.fill(WHITE)  # We fill our surface with a nice white color (by default black).

Spelet slingan

Nu har vi allt inställt för vår spelslinga. Detta är en slinga som kommer att köras för hela spelet, där vi hanterar händelser och uppdaterar skärmen och positionerna för våra objekt.

Först ser vi till att vår slinga körs på en given FPS . Vi definierade FPS och skapade vår klocka i början av programmet. Följande kod kommer att se till att vårt program sover tillräckligt med tid för att vår slinga ska upprepa det belopp som vi definierade att vår FPS ska vara. I detta exempel 60 gånger per sekund.

clock.tick(FPS)

Då ska vi hantera händelser. En händelse är i princip en användaråtgärd, till exempel att flytta musen eller trycka på en knapp. Pygame registrerar alla dessa händelser i en kö som vi får genom att ringa pygame.event.get() . Vi kan upprepa detta och kontrollera om det finns en händelse som vi vill hantera. Händelser har en typ attribut som vi kan kontrollera mot konstanter i pygame modulen för att avgöra vilken typ av händelse det är.

for event in pygame.event.get():
    if event.type == pygame.QUIT:  # The user pressed the close button in the top corner of the window.
        quit()
        # Close the program. Other methods like 'raise SystemExit' or 'sys.exit()'.
        # Calling 'pygame.quit()' won't close the program! It will just uninitialize the modules.

Vi kan också kontrollera if event.type == pygame.KEYDOWN att se om användaren har tryckt ned en knapp. I så fall händelsen har ett attribut nyckel som vi kan kontrollera att se vilken nyckel den representerar.

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        quit()
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_w:
            rect.move_ip(0, -2)  # Changes the rect's position.
        elif event.key == pygame.K_s:
            rect.move_ip(0, 2)
        elif event.key == pygame.K_a:
            rect.move_ip(-2, 0)
        elif event.key == pygame.K_d:
            rect.move_ip(2, 0)

Nu måste vi visa vår bild. Först kanske vi vill rensa vår skärm från tidigare rendering. Vi gör det genom att fylla hela skärmen med svart (ta bort koden för att se varför vi vill rensa den). Sedan måste vi BLIT vår bilden till skärmen. Blitting betyder i huvudsak att kopiera bilden till en annan yta (i vårt fall skärmen). Slutligen vänder eller uppdaterar vi skärmen.

När vi blittrar visar vi faktiskt inte något för användaren. Föreställ dig det som datorn på ena sidan och användaren på den andra. Datorn drar ( blits ) på sin sida av skärmen, vänder den mot användaren och upprepar sedan.

screen.fill(BLACK)
screen.blit(image, rect)
pygame.display.update()  # Or 'pygame.display.flip()'.

Nu har vi ett grundläggande spel! Ganska tråkigt, ja, men det väsentliga är det! Kombinerat detta med din nuvarande Python-kunskap och du borde kunna skapa något fantastiskt.

Komplett kod

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))


screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60  # Frames per second.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
# RED = (255, 0, 0), GREEN = (0, 255, 0), BLUE = (0, 0, 255).

rect = pygame.Rect((0, 0), (32, 32))
image = pygame.Surface((32, 32))
image .fill(WHITE)  

while True:
    clock.tick(FPS)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                rect.move_ip(0, -2)
            elif event.key == pygame.K_s:
                rect.move_ip(0, 2)
            elif event.key == pygame.K_a:
                rect.move_ip(-2, 0)
            elif event.key == pygame.K_d:
                rect.move_ip(2, 0)

    screen.fill(BLACK)
    screen.blit(image, rect)
    pygame.display.update()  # Or pygame.display.flip()

Lite förbättrad spelmekanik

Observera att programmet kontrollerar när vi trycker på knappen och inte när vi håller ner knappen. För att fixa detta kan vi införa en hastighetsvariabel . Vi kan skapa en spelarklass för att hålla den mer organiserad. För att undvika ramberoende rörelse (om vi skulle ändra FPS till 30 föremålen skulle röra sig med halva hastigheten) introducerar vi tidsberoende rörelse genom att överföra tiden mellan fästingar till våra rörliga objekt.

import pygame

successes, failures = pygame.init()
print("Initializing pygame: {0} successes and {1} failures.".format(successes, failures))

screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)


class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.image.fill(WHITE)
        self.rect = self.image.get_rect()  # Get rect of some size as 'image'.
        self.velocity = [0, 0]

    def update(self):
        self.rect.move_ip(*self.velocity)


player = Player()
running = True
while running:
    dt = clock.tick(FPS) / 1000  # Returns milliseconds between each call to 'tick'. The convert time to seconds.
    screen.fill(BLACK)  # Fill the screen with background color.

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                player.velocity[1] = -200 * dt  # 200 pixels per second
            elif event.key == pygame.K_s:
                player.velocity[1] = 200 * dt
            elif event.key == pygame.K_a:
                player.velocity[0] = -200 * dt
            elif event.key == pygame.K_d:
                player.velocity[0] = 200 * dt
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_w or event.key == pygame.K_s:
                player.velocity[1] = 0
            elif event.key == pygame.K_a or event.key == pygame.K_d:
                player.velocity[0] = 0

    player.update()

    screen.blit(player.image, player.rect)
    pygame.display.update()  # Or pygame.display.flip()

print("Exited the game loop. Game will quit...")
quit()  # Not actually necessary since the script will exit anyway.

Det finns fortfarande många saker som bör förbättras med den här koden. Jag skulle rekommendera dig att läsa pygame handledning och detta tal av Richard Jones mer på djupet.

Installera pygame

På fönster

1. Navigera till http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - en inofficiell webbplats som tillhandahåller fönsterbinarier av open source-pythonpaket för den officiella CPython- distributionen av Christoph Gohlke .

2. Ladda ner lämplig pygame .whl fil enligt din installerade pythonversion. (Filen heter något som pygame - <pygame version> - <python version> - win32.whl )

3. Springa

    pip install your-pygame-package.whl
   

   inuti din terminal, bash eller konsol.
   Obs: om pip inte hittas i PATH försök att köra python -m pip install your-pygame-package.whl

4. Kontrollera om du kan importera pygame som en pythonmodul

   import pygame
   

   Om du inte får något fel har du installerat pygame korrekt på din dator :)

På linux

1. Öppna din terminal och kör

   sudo apt-get install python-pygame
   

   Obs: Detta kommer att installera pygame för python2

2. Försök att importera pygame inuti

   import pygame
   

   Om du inte får något fel har du installerat pygame korrekt på ditt Linux-system :)

På macOS

Det finns två sätt att installera det på mac:

Metod 1

Gå till nedladdningssidan för Pygame och ladda ner Mac-installationsprogrammet. Kör det, och det bör installera Pygame på din Mac.

Metod 2

Installera Homebrew :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Använd sedan Homebrew för att installera Python 2.7.12 och Pygame:

brew install python; brew install homebrew/python/pygame

import pygame nu Python i din terminal och prova att import pygame . Om det inte säger någonting, installeras det framgångsrikt.

Importera pygame och rita på en skärm

Komma igång

Du måste göra följande för att komma igång med Pygame:

import pygame

Detta öppnar ett fönster i storlek 640.480 och lagrar det i en variabel som kallas skärm.

Ställa in ett fönsternamn

För att ställa in ett namn för pygamfönstret krävs följande syntax:

pygame.display.set_caption('Name')

Om skärmen

• Punkten (0,0) är längst upp till vänster på skärmen.
• x-koordinaterna ökar från vänster till höger, y-koordinaterna ökar från topp till botten. Det är den högra sidokoordinaterna på det kartesiska planet är positivt och vänster sida är negativt. på botten. ( Obs : Detta beaktas om punkterna tas från ursprunget.)

Uppdatering av skärmen

Ändringar du gör på skärmen - t.ex. fylla den med färg eller rita på den, dyker inte upp omedelbart!
Så hur gör man det?
Du måste ringa den här funktionen:

pygame.display.update()

Färger

Färgningen i pygame fungerar i RGB-läge.
Koden för färgläggning är:

color_Name = (r,g,b)

• R står för rött.
• G står för grönt
• B står för blått.
• Alla tre bör vara heltal mellan 0 och 255, med 255 som ljusast och 0 som mörkaste

Teckning

1. Att rita linjer

   pygame.draw.lines(screen, color, closed, pointlist, thickness)
   

2. Att rita rektangel

   pygame.draw.rect(screen, color, (x,y,width,height), thickness)
   

3. Att rita cirkel

   pygame.draw.circle(screen, color, (x,y), radius, thickness)
   

Ställa in allt i en slinga

För att skapa en slinga använder du följande kod:

running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()

Rita en rektangel på pygamfönster (kod)

import pygame
background_colour = (255,255,255) # White color
(width, height) = (300, 200) # Screen size
color=(0,0,0) #For retangle
screen = pygame.display.set_mode((width, height)) #Setting Screen
pygame.display.set_caption('Drawing') #Window Name
screen.fill(background_colour)#Fills white to screen
pygame.draw.rect(screen, color, (100,50,30,40), 1) #Drawing the rectangle
pygame.display.update()

#Loop
running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()