pygameAan de slag met pygame


Opmerkingen

Pygame is een Python- wrapper voor SDL - een platformonafhankelijke C-bibliotheek voor het besturen van multimedia - geschreven door Pete Shinners. Dit betekent dat u met behulp van pygame videogames of andere multimediatoepassingen in Python kunt schrijven die ongewijzigd op elk van de ondersteunde platforms van SDL (Windows, Unix, Mac, beOS en andere) worden uitgevoerd.


Deze sectie geeft een overzicht van wat pygame is en waarom een ontwikkelaar het misschien wil gebruiken.

Het moet ook alle grote onderwerpen binnen pygame vermelden en een link naar de gerelateerde onderwerpen bevatten. Omdat de documentatie voor pygame nieuw is, moet u mogelijk eerste versies van die gerelateerde onderwerpen maken.

versies

| Versie | ==============> | Releasedatum |
| Pygame 1.9.0 | ========> | 1 augustus 2009 |
| Pygame 1.8.1 | ========> | 30 juli 2008 |
| Pygame 1.8.0 | ========> | 29 maart 2008 |
| Pygame 1.7.1 | ========> | 16 augustus 2005 |
| Pygame 1.6.2 | ========> | - |
| Pygame 1.6 | =========> | 23 oktober 2003 |
| Pygame 1.5 | =========> | 30 mei 2002 |
| Pygame 1.4 | =========> | 30 januari 2002 |
| Pygame 1.3 | =========> | 19 december 2001 |
| Pygame 1.2 | =========> | 4 september 2001 |
| Pygame 1.1 | =========> | 23 juni 2001 |
| Pygame 1.0 | =========> | 5 april 2001 |
| Pygame 0.9 | =========> | 13 februari 2001 |
| Pygame 0.5 | =========> | 6 januari 14, 2001 |
| Pygame 0.4 | =========> | 14 december 2000 |
| Pygame 0.3 | =========> | 20 nov. 2000 |
| Pygame 0.2 | =========> | 3 nov. 2000 |
| Pygame 0.1 | =========> | 28 okt. 2000 |

Een eenvoudig 'spel'


Importeren en initialiseren

Elke module moet worden geïmporteerd en pygame is geen uitzondering. Hoewel we de functie pygame.init() moeten aanroepen om alle geïmporteerde modules in pygame correct te initialiseren. Als we dit vergeten, werken sommige modules niet. De functie retourneert ook een tupel van alle geslaagde en mislukte initialisaties (er treedt geen fout op als een module niet kan worden geïnitialiseerd).

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

Maak benodigdheden

We moeten ook een display maken. Pygame heeft al een (verborgen) display gemaakt, dus het enige wat we moeten doen is de modus van het display instellen (in dit voorbeeld stellen we alleen de resolutie in). Het is ook een goed idee om een klok te maken om ervoor te zorgen dat ons programma op een vaste snelheid wordt bijgewerkt (anders zou het op verschillende snelheid lopen, afhankelijk van hoe snel de computer is).

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.
 

Voor een beetje leesbaarheid later in onze code maken we twee kleurconstanten, die een tuple rood, groen en blauw (RGB) vertegenwoordigen. De waarden gaan van 0 (geen licht) tot 255 (volledig licht).

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

In pygame gebruiken we meestal een Surface om het uiterlijk van een object weer te geven en een Rect (rechthoek) om de positie van een object weer te geven. Een Surface is als een blanco vel papier dat kleuren of afbeeldingen bevat. Als je een klasse maakt, moet je de attributen image en rect noemen, omdat veel functies deze attributen zullen zoeken en gebruiken. Dergelijke klassen zouden profiteren door erven de pygame.sprite.Sprite klasse voor redenen die u kunt lezen op hier .

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

De gamelus

Nu hebben we alles klaar voor onze gamelus. Dit is een lus die voor de hele game loopt, waar we gebeurtenissen afhandelen en het scherm en de posities van onze objecten bijwerken.

Eerst zorgen we ervoor dat onze lus op een bepaalde FPS wordt uitgevoerd . We hebben de FPS gedefinieerd en onze klok in het begin van het programma gemaakt. De volgende code zorgt ervoor dat ons programma genoeg tijd slaapt om onze lus het aantal te laten herhalen dat we onze FPS hebben gedefinieerd. In dit voorbeeld 60 keer per seconde.

clock.tick(FPS)
 

Dan zullen we evenementen afhandelen. Een gebeurtenis is in feite een gebruikersactie, zoals het verplaatsen van de muis of het indrukken van een toets. Pygame zal al deze gebeurtenissen registreren in een wachtrij die we krijgen door pygame.event.get() aan te roepen. We kunnen dit herhalen en controleren of er een evenement is dat we graag willen behandelen. Gebeurtenissen type eigenschap die we kunnen controleren met constanten in de pygame module om te bepalen welk type gebeurtenis is.

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.
 

We kunnen ook controleren if event.type == pygame.KEYDOWN om te zien of de gebruiker een toets heeft ingedrukt. In dat geval heeft indien een attribuut sleutel die we kunnen controleren welke toets vertegenwoordigt.

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 moeten we onze afbeelding weergeven. Als eerste willen we misschien ons scherm wissen van eerdere rendering. We doen dit door ons hele scherm met zwart te vullen (verwijder de code om te zien waarom we het willen wissen). Dan moeten we ons imago BLIT naar het scherm. Blitting betekent in wezen het kopiëren van de afbeelding naar een ander oppervlak (in ons geval het scherm). Ten slotte spiegelen of updaten we het scherm.

Als we blitsen, geven we eigenlijk niets aan de gebruiker weer. Stel je voor als de computer aan de ene kant en de gebruiker aan de andere kant. De computer tekent ( blits ) op de zijkant van het scherm, draait het naar de gebruiker en herhaalt het.

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

Nu hebben we een basisspel! Best saai, ja, maar de essentie is aanwezig! Gecombineerd met uw huidige kennis van Python en u zou iets geweldigs moeten kunnen maken.


Volledige code

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

Iets verbeterde spelmechanica

Merk op dat het programma controleert wanneer we op de toets drukken en niet wanneer we de toets ingedrukt houden. Om dit op te lossen kunnen we een snelheidsvariabele invoeren. We kunnen een spelersklasse maken om deze beter georganiseerd te houden. Om frame-afhankelijke beweging te voorkomen (als we de FPS zouden wijzigen naar 30 zouden de objecten met de helft van de snelheid bewegen), introduceren we tijdafhankelijke beweging door de tijd tussen teken door te geven aan onze beweegbare objecten.

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.
 

Er zijn nog veel dingen die aan deze code moeten worden verbeterd. Ik zou je aanraden om de pygame tutorial en deze talk van Richard Jones te lezen voor meer diepgang.

Pygame importeren en tekenen op een display

Ermee beginnen

Je moet het volgende doen om aan de slag te gaan met Pygame:

import pygame
 

Dit opent een venster met een grootte van 640.480 en slaat het op in een variabele genaamd scherm.

Een vensternaam instellen

Het instellen van een naam voor het pygame-venster vereist de volgende syntaxis:

pygame.display.set_caption('Name')
 

Over het scherm

  • Het punt (0,0) bevindt zich in de linkerbovenhoek van het scherm.
  • x coördinaten nemen toe van links naar rechts, y coördinaten nemen toe van boven naar beneden. Dat is de coördinaten aan de rechterkant op het Cartesiaanse vlak is positief en de linkerkant is negatief. De coördinaten aan de bovenkant op het Cartesiaanse vlak zijn echter negatief aan de bovenkant en positief onderaan. ( Opmerking : hiermee wordt rekening gehouden als de punten van de oorsprong worden genomen.)

Het scherm bijwerken

Wijzigingen die u in het scherm aanbrengt, bijvoorbeeld door het met kleur te vullen of erop te tekenen, worden niet onmiddellijk weergegeven!
Dus hoe doe je dat?
U moet deze functie aanroepen:

pygame.display.update()
 

kleuren

De kleuring in pygame werkt op RGB-modus.
De code voor het kleuren is:

color_Name = (r,g,b)
 
  • R staat voor rood.
  • G staat voor groen
  • B staat voor blauw.
  • Alle drie moeten gehele getallen tussen 0 en 255 zijn, waarbij 255 het helderst is en 0 het donkerst

Tekening

  1. Lijnen tekenen

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

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

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

Alles in een lus zetten

Gebruik de volgende code om een lus te maken:

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

Een rechthoek tekenen op pygame-venster (code)

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

Pygame installeren

Op ramen

  1. Navigeer naar http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - een onofficiële site met Windows-binaries van open-source python-pakketten voor de officiële CPython- distributie door Christoph Gohlke .

  2. Download het juiste pygame .whl bestand volgens uw geïnstalleerde python-versie. (Het bestand heeft zoiets als pygame - <pygame version> - <python version> - win32.whl )

  3. Rennen

     pip install your-pygame-package.whl
     

    in uw terminal, bash of consol.
    Opmerking: als pip niet wordt gevonden in PATH probeer dan python -m pip install your-pygame-package.whl

  4. Controleer of u pygame als een python-module kunt importeren

    import pygame
     

    Als je geen foutmelding krijgt, heb je pygame correct op je computer geïnstalleerd :)

Op Linux

  1. Open je terminal en ren

    sudo apt-get install python-pygame
     

    Opmerking: hiermee wordt pygame voor python2 geïnstalleerd

  2. Probeer pygame binnen te importeren

    import pygame
     

    Als je geen foutmelding krijgt, heb je pygame correct op je Linux-systeem geïnstalleerd :)

Op macOS

Er zijn twee manieren om het op Mac te installeren:

Methode 1

Ga naar de Pygame-downloadpagina en download het mac-installatieprogramma. Voer het uit en het zou Pygame op uw Mac moeten installeren.

Methode 2

Homebrew installeren:

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

Gebruik vervolgens Homebrew om Python 2.7.12 en Pygame te installeren:

brew install python; brew install homebrew/python/pygame
 

Voer nu Python uit in uw terminal en probeer import pygame te import pygame . Als er niets staat, is het met succes geïnstalleerd.