pygame Tutorial
Erste Schritte mit Pygame

Bemerkungen

Versionen

Ein einfaches "Spiel"

Importieren und initialisieren

Jedes Modul muss importiert werden und Pygame ist keine Ausnahme. Obwohl wir die Funktion pygame.init() aufrufen müssen, damit alle importierten Module in pygame ordnungsgemäß initialisiert werden. Wenn wir das vergessen, funktionieren einige Module nicht. Die Funktion gibt auch ein Tupel aller erfolgreichen und fehlgeschlagenen Initialisierungen zurück (es wird kein Fehler ausgegeben, wenn ein Modul nicht initialisiert werden kann).

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

Notwendigkeiten schaffen

Wir müssen auch eine Anzeige erstellen. Pygame hat bereits eine (verborgene) Anzeige erstellt, also müssen wir nur den Modus der Anzeige einstellen (in diesem Beispiel stellen wir nur die Auflösung ein). Es ist auch eine gute Idee, eine Uhr zu erstellen, um sicherzustellen, dass unser Programm mit einer festen Geschwindigkeit aktualisiert wird.

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.

Zur besseren Lesbarkeit in unserem Code erstellen wir später zwei Farbkonstanten, die ein Tupel aus Rot, Grün und Blau (RGB) darstellen. Die Werte reichen von 0 (kein Licht) bis 255 (Volllicht).

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

In pygame verwenden wir in der Regel eine Oberfläche das Aussehen eines Objekts darzustellen, und ein Rect (Rechteck) , um die Position eines Objekts zu repräsentieren. Eine Oberfläche ist wie ein leeres Blatt Papier, das Farben oder Bilder enthält. Wenn Sie eine Klasse erstellen, sollten Sie die Attribute image benennen und korrigieren, da viele Funktionen diese Attribute suchen und verwenden. Solche Klassen würden durch Vererben der Nutzen pygame.sprite.Sprite aus Gründen Klasse Sie lesen können 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).

Die Spielschleife

Jetzt haben wir alles für unsere Spielschleife eingestellt. Dies ist eine Schleife, die sich über das gesamte Spiel erstreckt. Hier werden Ereignisse behandelt und der Bildschirm und die Positionen unserer Objekte aktualisiert.

Zuerst stellen wir sicher, dass unsere Schleife bei einem bestimmten FPS ausgeführt wird . Wir haben die FPS definiert und unsere Uhr zu Beginn des Programms erstellt. Der folgende Code stellt sicher, dass unser Programm genug Zeit einnimmt, damit unsere Schleife den Betrag wiederholt, den wir als FPS definiert haben. In diesem Beispiel 60 Mal pro Sekunde.

clock.tick(FPS)

Dann kümmern wir uns um Ereignisse. Ein Ereignis ist im Wesentlichen eine Benutzeraktion, z. B. Bewegen der Maus oder Drücken einer Taste. Pygame registriert alle diese Ereignisse in einer Warteschlange, die wir durch Aufruf von pygame.event.get() . Wir können hierüber iterieren und prüfen, ob es ein Ereignis gibt, das wir bearbeiten möchten. Events haben ein type - Attribut , das wir gegen Konstanten im pygame Modul überprüfen , um festzustellen , welche Art von Veranstaltung es sich handelt.

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.

Wir können auch prüfen, if event.type == pygame.KEYDOWN zu sehen, ob der Benutzer eine Taste gedrückt hat. In diesem Fall hat das Ereignis einen Attributschlüssel , die wir überprüfen können , um zu sehen , welche Taste sie darstellt.

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)

Jetzt müssen wir unser Bild anzeigen. Zuerst möchten wir vielleicht den Bildschirm vom vorherigen Rendering löschen. Dazu füllen wir den gesamten Bildschirm mit Schwarz (entfernen Sie den Code, um zu sehen, warum wir ihn löschen möchten). Dann müssen wir unser Bild auf dem Bildschirm blitten. Blitting bedeutet im Wesentlichen, das Bild auf eine andere Oberfläche (in unserem Fall den Bildschirm) zu kopieren. Zuletzt drehen wir den Bildschirm um oder aktualisieren ihn .

Wenn wir blöken, zeigen wir dem Benutzer eigentlich nichts an. Stellen Sie sich das als den Computer auf der einen Seite und den Benutzer auf der anderen Seite vor. Der Computer zeichnet ( blits ) auf seiner Bildschirmseite, dreht den Benutzer in Richtung des Benutzers und wiederholt ihn dann.

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

Jetzt haben wir ein Grundspiel! Ziemlich langweilig, ja, aber das Wesentliche ist da! Kombiniert dies mit Ihrem aktuellen Python-Wissen und Sie sollten in der Lage sein, etwas Großartiges zu schaffen.

Code vervollständigen

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

Leicht verbesserte Spielmechanik

Beachten Sie, dass das Programm prüft, wann wir die Taste drücken, und nicht, wenn wir die Taste gedrückt halten. Um dies zu beheben, könnten wir eine Geschwindigkeitsvariable einführen. Wir können eine Spielerklasse erstellen, um sie besser zu organisieren. Um eine rahmenabhängige Bewegung zu vermeiden (wenn wir die FPS auf 30 ändern würden, würden sich die Objekte mit der halben Geschwindigkeit bewegen), führen wir eine zeitabhängige Bewegung ein, indem wir die Zeit zwischen den Ticks an unsere beweglichen Objekte übergeben.

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.

Es gibt noch viele Dinge, die an diesem Code verbessert werden sollten. Ich würde dir empfehlen, das Pygame- Tutorial und diesen Vortrag von Richard Jones zu lesen, um mehr darüber zu erfahren.

Pygame installieren

An den Fenstern

1. Navigieren Sie zu http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - einer inoffiziellen Website, die Windows-Binärdateien von Open Source-Python-Paketen für die offizielle CPython- Distribution von Christoph Gohlke bereitstellt.

2. Laden Sie die entsprechende Pygame- .whl Datei entsprechend Ihrer installierten Python-Version herunter. (Die Datei hat einen Namen wie pygame - <pygame version> - <python version> - win32.whl )

3. Lauf

    pip install your-pygame-package.whl
   

   in Ihrem Terminal, Bash oder Consol.
   Hinweis: Wenn pip nicht in PATH , führen Sie python -m pip install your-pygame-package.whl

4. Prüfen Sie, ob Sie Pygame als Python-Modul importieren können

   import pygame
   

   Wenn Sie keine Fehlermeldung erhalten, haben Sie pygame korrekt auf Ihrem Computer installiert :)

Auf linux

1. Öffne dein Terminal und renne

   sudo apt-get install python-pygame
   

   Hinweis: Dadurch wird pygame für python2 installiert

2. Versuchen Sie, Pygame nach innen zu importieren

   import pygame
   

   Wenn Sie keine Fehlermeldung erhalten, haben Sie pygame korrekt auf Ihrem Linux-System installiert :)

Auf MacOS

Es gibt zwei Möglichkeiten, es auf einem Mac zu installieren:

Methode 1

Gehen Sie zur Pygame-Downloadseite und laden Sie das Mac-Installationsprogramm herunter. Starten Sie es und es sollte Pygame auf Ihrem Mac installieren.

Methode 2

Homebrew installieren:

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

Dann verwenden Sie Homebrew, um Python 2.7.12 und Pygame zu installieren:

brew install python; brew install homebrew/python/pygame

Führen Sie nun Python in Ihrem Terminal aus und versuchen Sie, import pygame . Wenn es nichts sagt, wird es erfolgreich installiert.

Pygame importieren und auf einer Anzeige zeichnen

Fertig machen

Sie müssen folgendes tun, um mit Pygame zu beginnen:

import pygame

Dies öffnet ein Fenster der Größe 640,480 und speichert es in einer Variablen namens Bildschirm.

Einrichten eines Fensternamens

Das Einrichten eines Namens für das Pygame-Fenster erfordert die folgende Syntax:

pygame.display.set_caption('Name')

Über den Bildschirm

• Der Punkt (0,0) befindet sich in der oberen linken Ecke des Bildschirms.
• x-Koordinaten nehmen von links nach rechts zu, y-Koordinaten steigen von oben nach unten. Das heißt, die Koordinaten der rechten Seite der kartesischen Ebene sind positiv und die linke Seite ist negativ unten ( Hinweis : Dies wird berücksichtigt, wenn die Punkte vom Ursprung abgerufen werden.)

Aktualisieren des Bildschirms

Änderungen, die Sie am Bildschirm vornehmen, z. B. mit Farbe füllen oder darauf zeichnen, werden nicht sofort angezeigt!
Wie soll ich das machen?
Sie müssen diese Funktion aufrufen:

pygame.display.update()

Farben

Die Farbgebung in Pygame funktioniert im RGB-Modus.
Der Code zum Färben lautet:

color_Name = (r,g,b)

• R steht für rot.
• G steht für grün
• B steht für Blau.
• Alle drei sollten Ganzzahlen zwischen 0 und 255 sein, wobei 255 am hellsten und 0 am dunkelsten ist

Zeichnung

1. Linien zeichnen

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

2. Rechteck zeichnen

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

3. Kreis zeichnen

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

Alles in eine Schleife setzen

Um eine Schleife zu erstellen, verwenden Sie den folgenden Code:

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

Zeichnen eines Rechtecks ​​im Pygame-Fenster (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()