Rennspiel mit Pygame

Einführung

In diesem Projekt lernst du, wie du mithilfe der Pygame-Bibliothek ein einfaches Rennspiel erstellen kannst. Das Spiel umfasst ein Spielerauto und mehrere Feindautos. Das Spielerauto kann mit den Pfeiltasten nach links und rechts bewegt werden, während die Feindautos den Bildschirm hinunter bewegen. Ziel ist es, so lange wie möglich Kollisionen mit den Feindautos zu vermeiden. Das Spiel wird einen Game-Over-Bildschirm anzeigen, wenn eine Kollision auftritt, und dem Spieler ermöglichen, das Spiel neu zu starten, indem er die Taste "R" drückt.

👀 Vorschau

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Wie du das Spielfenster einrichtest und die erforderlichen Bibliotheken importierst
• Wie du Farben definierst und Autobilder lädst
• Wie du das Spielerauto definierst
• Wie du die Feindautos definierst
• Wie du Game-Over-Variablen und Schriftarten definierst
• Wie du die Spiel-Logik implementierst
• Wie du den Game-Over-Bildschirm anzeigst
• Wie du das Spiel beendest

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

• Die Pygame-Bibliothek verwenden, um ein Spielfenster zu erstellen
• Bilder in einem Spiel zu laden und anzuzeigen
• Kollisionen zwischen Spielobjekten zu behandeln
• Eine Spielschleife für kontinuierliches Spielen zu implementieren
• Benutzer-Eingaben zu verarbeiten, um Spielobjekte zu steuern
• Text auf dem Bildschirm mit dem Font-Modul von Pygame anzuzeigen

Erstellen der Projekt-Dateien

1. Erstelle eine neue Datei namens racing_game.py.

cd ~/project
touch racing_game.py

Einrichten des Spielfensters und Importieren der erforderlichen Bibliotheken

import pygame
import random

## Initialisiere Pygame
pygame.init()

## Einrichten des Spielfensters
window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Racing Game")

In diesem Schritt importieren wir die pygame-Bibliothek und initialisieren sie. Anschließend legen wir das Spielfenster mit einer Breite von 800 Pixeln und einer Höhe von 600 Pixeln fest. Wir setzen auch die Fensterüberschrift auf "Racing Game".

Installiere die pygame-Bibliothek, indem du folgenden Befehl im Terminal ausführst:

sudo pip install pygame

Definieren von Farben und Laden von Autobildern

## Definiere Farben
background_color = (30, 30, 30)
player_car_color = (255, 255, 255)
enemy_car_color = (255, 0, 0)
text_color = (255, 255, 255)

## Lade Autobilder
player_car_img = pygame.image.load("player_car.png").convert_alpha()
enemy_car_img = pygame.image.load("enemy_car.png").convert_alpha()

In diesem Schritt definieren wir einige Farben, die im Spiel verwendet werden: background_color, player_car_color, enemy_car_color und text_color. Wir laden auch die Bilder für das Spielerauto und das Feindauto mit der pygame.image.load()-Funktion.

Die Bilder player_car.png und enemy_car.png befinden sich im Verzeichnis ~/project.

Definiere das Spielerauto

## Definiere das Spielerauto
player_car_width = player_car_img.get_width()
player_car_height = player_car_img.get_height()
player_car_x = window_width // 2 - player_car_width // 2
player_car_y = window_height - player_car_height - 10
player_car_speed = 5

In diesem Schritt definieren wir die Eigenschaften des Spielerautos: player_car_width und player_car_height werden auf die Maße des Spielerautobilds gesetzt. player_car_x und player_car_y repräsentieren die Anfangsposition des Spielerautos auf dem Bildschirm. player_car_speed bestimmt, wie schnell das Spielerauto sich bewegen kann.

Definiere die Feindautos

## Definiere die Feindautos
enemy_cars = []
num_enemy_cars = 3
enemy_car_width = 80
enemy_car_height = 160
for _ in range(num_enemy_cars):
    enemy_car_x = random.randint(0, window_width - enemy_car_width)
    enemy_car_y = random.randint(-window_height, -enemy_car_height)
    enemy_car_speed = random.randint(2, 5)
    enemy_cars.append({"x": enemy_car_x, "y": enemy_car_y, "speed": enemy_car_speed})

In diesem Schritt definieren wir die Eigenschaften der Feindautos: enemy_cars ist eine Liste, die die Feindauto-Objekte speichern wird. num_enemy_cars bestimmt die Anzahl der Feindautos im Spiel. enemy_car_width und enemy_car_height repräsentieren die Maße des Feindautobilds. Wir verwenden eine Schleife, um für jedes Feindauto zufällige Positionen und Geschwindigkeiten zu generieren und sie zur enemy_cars-Liste hinzuzufügen.

Definiere Variablen und Schriftart für das Spielende

## Definiere Variablen für das Spielende
game_over = False
font = pygame.font.Font(None, 50)
game_over_text = font.render("Game Over", True, text_color)
restart_text = font.render("Press R to Restart", True, text_color)

In diesem Schritt definieren wir die Variablen, die mit dem Spielende-Bildschirm zusammenhängen: game_over ist eine boolesche Variable, die angibt, ob das Spiel beendet ist oder nicht. font ist ein Pygame-Schriftartobjekt mit einer Größe von 50. Wir rendern den Text "Game Over" und den Text "Press R to Restart" mit der Schriftart und speichern sie in den Variablen game_over_text und restart_text.

Spielschleife

## Spielschleife
running = True
clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_r and game_over:
                game_over = False
                player_car_x = window_width // 2 - player_car_width // 2
                player_car_y = window_height - player_car_height - 10
                for enemy_car in enemy_cars:
                    enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
                    enemy_car["y"] = random.randint(-window_height, -enemy_car_height)

    if not game_over:
        ## Spiellogik-Code kommt hier...

        ## Aktualisiere das Fenster
        window.fill(background_color)
        window.blit(player_car_img, (player_car_x, player_car_y))
        for enemy_car in enemy_cars:
            window.blit(enemy_car_img, (enemy_car["x"], enemy_car["y"]))
    else:
        ## Code für den Spielende-Bildschirm kommt hier...

    pygame.display.update()
    clock.tick(60)

In diesem Schritt setzen wir die Spielschleife mit einer while-Schleife auf. Die Schleife läuft solange die Variable running True ist. Wir verarbeiten die Ereignisse wie das Beenden des Spiels und das Neustarten des Spiels, indem wir die Ereignistypen und Tasten überprüfen. Wenn das Spiel nicht beendet ist, wird der Code innerhalb des if not game_over-Blocks ausgeführt, der die Spiellogik und das Zeichnen des Spielerautos und der Feindautos auf dem Bildschirm umfasst. Wenn das Spiel beendet ist, wird der Code innerhalb des else-Blocks ausgeführt, der den Spielende-Bildschirm anzeigt. Schließlich aktualisieren wir die Anzeige und setzen die Framerate auf 60 Bilder pro Sekunde.

Spiellogik-Code

if not game_over:
    ## Bewege das Spielerauto
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_car_x > player_car_speed:
        player_car_x -= player_car_speed
    if (
        keys[pygame.K_RIGHT]
        and player_car_x < window_width - player_car_width - player_car_speed
    ):
        player_car_x += player_car_speed

    ## Bewege die Feindautos
    for enemy_car in enemy_cars:
        enemy_car["y"] += enemy_car["speed"]
        if enemy_car["y"] > window_height:
            enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
            enemy_car["y"] = random.randint(-window_height, -enemy_car_height)
            enemy_car["speed"] = random.randint(2, 5)

        ## Überprüfe auf Kollision
        if player_car_y < enemy_car["y"] + enemy_car_height:
            if (
                player_car_x < enemy_car["x"] + enemy_car_width
                and player_car_x + player_car_width > enemy_car["x"]
            ):
                game_over = True

In diesem Schritt implementieren wir den Spiellogik-Code innerhalb der Spielschleife. Wir überprüfen auf Benutzereingaben, um das Spielerauto nach links und rechts zu bewegen. Wir aktualisieren die Positionen der Feindautos und überprüfen, ob eine Kollision zwischen dem Spielerauto und den Feindautos aufgetreten ist. Wenn eine Kollision auftritt, setzen wir die Variable game_over auf True.

Code für den Spielende-Bildschirm

else:
    ## Spielende-Bildschirm
    window.fill(background_color)
    game_over_rect = game_over_text.get_rect(
        center=(window_width // 2, window_height // 2 - 50)
    )
    restart_rect = restart_text.get_rect(
        center=(window_width // 2, window_height // 2 + 50)
    )
    window.blit(game_over_text, game_over_rect)
    window.blit(restart_text, restart_rect)

In diesem Schritt implementieren wir den Code für den Spielende-Bildschirm innerhalb der Spielschleife. Wir zeigen den Spielende-Text und den Neustart-Text auf dem Bildschirm mit der window.blit()-Funktion an. Der Text wird mithilfe der get_rect()- und center-Eigenschaften mittig auf dem Bildschirm platziert.

Beende das Spiel

## Beende das Spiel
pygame.quit()

In diesem letzten Schritt beenden wir das Spiel und schließen das Pygame-Fenster, wenn die Spielschleife beendet wird.

Jetzt können Sie das Spiel mit dem folgenden Befehl ausführen:

python racing_game.py

Zusammenfassung

Herzlichen Glückwunsch! Sie haben erfolgreich ein einfaches Rennspiel mit der Pygame-Bibliothek erstellt. Das Spiel umfasst ein Spielerauto, das nach links und rechts bewegt werden kann, sowie mehrere Feindautos. Das Ziel ist es, so lange wie möglich Kollisionen mit den Feindautos zu vermeiden. Das Spiel verfügt auch über einen Spielende-Bildschirm und die Möglichkeit, das Spiel neu zu starten, indem man die Taste "R" drückt. Halten Sie an der Übung und dem Experimentieren, um Ihre Fähigkeiten im Bereich der Spielentwicklung zu verbessern.