Klassisches Pong-Spiel mit Python und Pygame

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

🎯 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

Erstellen der 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

Einrichten des Spiel-Fensters

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

Einrichten der Paddles und des Balls

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

Einrichten der Spielvariablen

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

Einrichten der Spielschleife

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 Paddel

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 Power-up-Kollisionen und Bewegung

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 Punkte

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

Setze die FPS

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.

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!