Erstelle ein Pong-Spiel mit Python und Pygame | Programmierungstutorial

Einführung

In diesem Projekt lernst du, wie du ein Pong-Spiel mit Python und der Pygame-Bibliothek erstellen kannst. Pong ist ein klassisches Zwei-Spieler-Arcade-Spiel, in dem die Spieler Paddel steuern, um einen Ball aneinander vorbeizuschlagen.

Um dieses Projekt zu absolvieren, musst du die folgenden Schritte befolgen. Wir beginnen mit dem Erstellen der Projekt-Dateien und dem Einrichten des Spiel-Fensters. Dann definieren wir die Farben und setzen die Paddel und den Ball auf. Schließlich bewegen wir die Paddel und den Ball, behandeln Kollisionen und zeichnen die Spiel-Elemente.

👀 Vorschau

Pong-Spiel-Vorschau-Screenshot

🎯 Aufgaben

In diesem Projekt wirst du lernen:

Wie du die Projekt-Dateien erstellst
Wie du das Spiel-Fenster einrichtest
Wie du die Paddel und den Ball einrichtest
Wie du die Spielvariablen einrichtest
Wie du die Spiel-Schleife einrichtest
Wie du die Paddel bewegst
Wie du den Ball bewegst
Wie du Ball-Kollisionen behandelst
Wie du die Punkte aktualisierst und den Ball zurücksetzt
Wie du Power-Up-Kollisionen und -Bewegung behandelst
Wie du die Spiel-Elemente zeichnest
Wie du die Punktezahl zeichnest
Wie du die Anzeige aktualisierst
Wie du die Bilder pro Sekunde (FPS) setzt
Wie du das Spiel beendest

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

Die Pygame-Bibliothek verwenden, um ein Spiel-Fenster zu erstellen
Spieleobjekte wie Paddel und einen Ball einrichten und bewegen
Kollisionen zwischen Spieleobjekten behandeln
Spielpunkte aktualisieren und anzeigen
Die Bilder pro Sekunde (FPS) für das Spiel setzen
Das Spiel richtig beenden

Erstelle die Projekt-Dateien

Erstelle in deinem bevorzugten Code-Editor oder IDE eine Datei namens pong_game.py. Dies wird die Hauptdatei sein, in der du den Code für das Pong-Spiel schreibst.

cd ~/project
touch pong_game.py
sudo pip install pygame

Stelle das Spiel-Fenster ein

Im pong_game.py-Datei importiere die erforderlichen Bibliotheken am Anfang des Codes:

import pygame
import random

Initialisiere dann Pygame, indem du pygame.init() aufrufst:

## Initialisiere Pygame
pygame.init()

Als Nächstes richte das Spiel-Fenster ein, indem du die Breite, Höhe und die Bilder pro Sekunde (FPS) definierst:

## Richte das Spiel-Fenster ein
WIDTH = 800
HEIGHT = 400
FPS = 60

Definiere die Farben, die im Spiel verwendet werden:

## Definiere Farben
SCHWARZ = (0, 0, 0)
WEISS = (255, 255, 255)
BLAU = (0, 0, 255)
ORANGE = (255, 165, 0)
HINTERGRUNDFARBE = (50, 50, 50)

Erstelle das Spiel-Fenster, setze den Fenstertitel und erstelle ein Clock-Objekt, um die Bildrate zu steuern:

## Richte das Spiel-Fenster ein
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pong-Spiel")
clock = pygame.time.Clock()

Stelle die Schläger und den Ball ein

Definieren Sie die Eigenschaften der Paddles, wie Breite, Höhe, Geschwindigkeit und Farbe:

## Set up the paddles
PADDLE_WIDTH = 10
PADDLE_HEIGHT = 60
PADDLE_SPEED = 5
PADDLE_COLOR = WHITE

Erstellen Sie zwei Paddle-Objekte mit dem pygame.Rect() Konstruktor und positionieren Sie sie in der Mitte jeder Seite des Spielfensters:

paddle1 = pygame.Rect(0, HEIGHT / 2 - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT)
paddle2 = pygame.Rect(
    WIDTH - PADDLE_WIDTH, HEIGHT / 2 - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT
)

Richten Sie die Eigenschaften des Balls ein, wie Breite, Höhe, Geschwindigkeit und Farbe:

## Set up the ball
BALL_WIDTH = 10
BALL_HEIGHT = 10
BALL_SPEED_X = 3
BALL_SPEED_Y = 3
BALL_COLOR = WHITE

Erstellen Sie ein Ball-Objekt mit dem pygame.Rect() Konstruktor und positionieren Sie es in der Mitte des Spielfensters:

ball = pygame.Rect(
    WIDTH / 2 - BALL_WIDTH / 2, HEIGHT / 2 - BALL_HEIGHT / 2, BALL_WIDTH, BALL_HEIGHT
)

Setzen Sie die Anfangsgeschwindigkeit des Balls in x- und y-Richtung zufällig:

ball_speed_x = BALL_SPEED_X * random.choice((1, -1))
ball_speed_y = BALL_SPEED_Y * random.choice((1, -1))

Richten Sie die Power-ups ein, wie Breite, Höhe, Geschwindigkeit und Farbe:

## Set up the power-ups
POWERUP_WIDTH = 10
POWERUP_HEIGHT = 10
POWERUP_SPEED = 2
POWERUP_COLOR = ORANGE

powerup = pygame.Rect(
    WIDTH / 2 - POWERUP_WIDTH / 2,
    HEIGHT / 2 - POWERUP_HEIGHT / 2,
    POWERUP_WIDTH,
    POWERUP_HEIGHT,
)
powerup_speed_x = POWERUP_SPEED * random.choice((1, -1))
powerup_speed_y = POWERUP_SPEED * random.choice((1, -1))
powerup_active = False

Stelle die Spielvariablen ein

Richte die Variablen ein, um die Spielerpunkte zu verfolgen, erstelle ein Spielschrift-Objekt und definiere die Farbe für die Punktanzeige:

## Richte die Spielvariablen ein
score1 = 0
score2 = 0
game_font = pygame.font.SysFont(None, 48)
SCORE_COLOR = WEISS

Stelle die Spielschleife ein

Erstelle eine boolesche Variable running und setze sie auf True, um die Spielschleife zu starten:

## Einrichten der Spielschleife
running = True
while running:

Innerhalb der Spielschleife verarbeite die Ereignisse, indem du durch die aufgetretenen Ereignisse iterierst:

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

Bewege die Schläger

Innerhalb der Spielschleife überprüfe auf Tastatureingaben, um die Paddel zu bewegen:

    ## Bewege die Paddel
    keys = pygame.key.get_pressed()
    if keys[pygame.K_w] and paddle1.y > 0:
        paddle1.y -= PADDLE_SPEED
    if keys[pygame.K_s] and paddle1.y < HEIGHT - PADDLE_HEIGHT:
        paddle1.y += PADDLE_SPEED
    if keys[pygame.K_UP] and paddle2.y > 0:
        paddle2.y -= PADDLE_SPEED
    if keys[pygame.K_DOWN] and paddle2.y < HEIGHT - PADDLE_HEIGHT:
        paddle2.y += PADDLE_SPEED

Bewege den Ball

Innerhalb der Spielschleife aktualisiere die Position des Balls:

    ## Bewege den Ball
    ball.x += ball_speed_x
    ball.y += ball_speed_y

Behandle Kollisionen des Balls

Innerhalb der Spielschleife behandle Kollisionen des Balls mit den Paddeln und den Wänden:

    ## Kollision des Balls mit den Paddeln
    if ball.colliderect(paddle1) or ball.colliderect(paddle2):
        ball_speed_x *= -1

    ## Kollision des Balls mit den Wänden
    if ball.y > HEIGHT - BALL_HEIGHT or ball.y < 0:
        ball_speed_y *= -1

Aktualisiere die Punkte und setze den Ball zurück

Innerhalb der Spielschleife aktualisiere die Punkte und setze den Ball zurück, wenn er über das Paddle hinausgeht:

    ## Erhöhe den Score und setze den Ball zurück
    if ball.x < 0:
        score2 += 1
        ball.center = (WIDTH / 2, HEIGHT / 2)
        ball_speed_x *= random.choice((1, -1))
        ball_speed_y *= random.choice((1, -1))
    if ball.x > WIDTH:
        score1 += 1
        ball.center = (WIDTH / 2, HEIGHT / 2)
        ball_speed_x *= random.choice((1, -1))
        ball_speed_y *= random.choice((1, -1))

Behandle Kollisionen und Bewegung von Power-ups

Innerhalb der Spielschleife behandle Power-up-Kollisionen mit den Paddeln und bewege das Power-up:

    ## Power-up-Kollision mit den Paddeln
    if powerup.colliderect(paddle1) or powerup.colliderect(paddle2):
        powerup_active = True
        powerup.x = WIDTH / 2 - POWERUP_WIDTH / 2
        powerup.y = HEIGHT / 2 - POWERUP_HEIGHT / 2

    ## Power-up-Bewegung
    if powerup_active:
        powerup.x += powerup_speed_x
        powerup.y += powerup_speed_y

        if powerup.x > WIDTH - POWERUP_WIDTH or powerup.x < 0:
            powerup_speed_x *= -1
        if powerup.y > HEIGHT - POWERUP_HEIGHT or powerup.y < 0:
            powerup_speed_y *= -1

Zeichne die Spiel-Elemente

Innerhalb der Spielschleife zeichne die Paddles, den Ball, das Power-up und die Punkte auf das Spiel-Fenster:

    ## Zeichne die Spiel-Elemente
    screen.fill(BACKGROUND_COLOR)
    pygame.draw.rect(screen, PADDLE_COLOR, paddle1)
    pygame.draw.rect(screen, PADDLE_COLOR, paddle2)
    pygame.draw.ellipse(screen, BALL_COLOR, ball)
    pygame.draw.rect(screen, POWERUP_COLOR, powerup)

Zeichne die Punktzahl

Innerhalb der Spielschleife zeichne die Punkte in der oberen Mitte des Spiel-Fensters:

    ## Zeichne die Punkte
    score_text = game_font.render(f"{score1} : {score2}", True, SCORE_COLOR)
    screen.blit(score_text, (WIDTH / 2 - score_text.get_width() / 2, 10))

Aktualisiere die Anzeige

Innerhalb der Spielschleife aktualisiere die Anzeige, um die Änderungen anzuzeigen:

    ## Aktualisiere die Anzeige
    pygame.display.flip()

Stelle die FPS ein

Innerhalb der Spielschleife setze die Framerate, um die Geschwindigkeit des Spiels zu steuern:

    ## Setze die FPS
    clock.tick(FPS)

Beende das Spiel

Nach der Spielschleife füge die folgende Zeile hinzu, um Pygame zu beenden, wenn das Spiel beendet ist:

## Beende das Spiel
pygame.quit()

Wechsel zu Ihrem Desktop und führe das Projekt mit dem folgenden Befehl aus:

python pong_game.py

Jetzt können Sie das Pong-Spiel mit den Pfeiltasten und den W- und S-Tasten auf Ihrer Tastatur spielen.

Pong game screenshot

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das schrittweise Projekt zur Erstellung eines Pong-Spiels mit Python und Pygame abgeschlossen. Sie haben gelernt, wie Sie das Spiel-Fenster einrichten, die Eigenschaften der Schläger und des Balls definieren, Spielereignisse verarbeiten, die Schläger und den Ball bewegen, Kollisionen behandeln und die Spiel-Elemente zeichnen. Experimentieren Sie mit verschiedenen Modifikationen, um Ihrem Spiel eigene Verbesserungen hinzuzufügen, und haben Sie Spaß beim Spielen!

Klassisches Pong-Spiel mit Python und Pygame