Fügen Sie Ihren PyGame-Spielen eine Scrolling-Kamera hinzu

Eine gemeinsame Funktion, die Sie in vielen Spielen finden werden, ist eine scrollende Kamera, die Ihnen folgt, während Sie sich durch die Spielwelt bewegen. Dieser Effekt kann Ihrem Spiel Tiefe und Realismus verleihen und das gesamte Spielerlebnis verbessern.

Es gibt viele verschiedene Möglichkeiten, eine Scroll-Kamera in PyGame zu implementieren, also stellen Sie sicher, dass Sie ihre Unterschiede verstehen.

Erstellen eines einfachen Spiels

Bevor es losgeht, Installieren Sie Pip auf Ihrem Gerät und verwenden Sie den folgenden Befehl, um das PyGame-Modul zu installieren:

pip installiere pygame

Jetzt können Sie ein einfaches Spiel mit einem Spielerrechteck und zwei statischen Plattformen erstellen. Der Spieler kann sich mit den Pfeiltasten nach links und rechts bewegen.

Darin finden Sie den vollständigen Code für das Projekt GitHub-Repository.

Beginnen Sie mit dem Importieren des Pygame-Moduls. Initialisieren Sie es dann und erstellen Sie das Spielfenster mit der

pygame.display.set_mode() Funktion. Legen Sie dann die Beschriftung des Fensters fest und erstellen Sie die clock-Objekt, um die Framerate zu verwalten.

importieren Pygame
pygame.init()
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600
screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("Mein einfaches Spiel")
Uhr = pygame.time. Uhr()
HINTERGRUND_FARBE = (255, 255, 255)

Richten Sie als Nächstes den Player und die statischen Plattformen ein. Definieren Sie die Größe des Players und seine Ausgangsposition.

PLAYER_WIDTH = 50
PLAYER_HEIGHT = 50
player_x = WINDOW_WIDTH // 2 - PLAYER_WIDTH // 2
player_y = WINDOW_HEIGHT - PLAYER_HEIGHT - 20
PLAYER_SPEED = 10
RECTANGLE_COLOR_1 = (255, 0, 0)
RECTANGLE_COLOR_2 = (0, 0, 255)
Rechteck_1 = Pygame. Rechteck(200, 200, 100, 100)
Rechteck_2 = Pygame. Rechteck(500, 300, 150, 50)

Erstellen Sie dann eine Spielschleife, die Ereignisse verarbeitet und den Bildschirm aktualisiert. Suchen Sie in der Schleife nach Ereignissen wie dem Beenden des Spiels oder dem Bewegen des Spielers mit den Pfeiltasten.

währendWAHR:
# Ereignisse behandeln
für Fall In pygame.event.get():
Wenn event.type == Pygame. AUFHÖREN:
 pygame.quit()
 aufhören()
# Zeichnen Sie den Hintergrund
 screen.fill (BACKGROUND_COLOR)
# Zeichnen Sie die statischen Rechtecke
 pygame.draw.rect (Bildschirm, RECTANGLE_COLOR_1, Rechteck_1)
 pygame.draw.rect (Bildschirm, RECTANGLE_COLOR_2, Rechteck_2)
# Zeichne den Spieler
 player_rect = Pygame. Rect (player_x, player_y, PLAYER_WIDTH,
 PLAYER_HEIGHT)
 pygame.draw.rect (Bildschirm, (0, 0, 0), player_rect)
# Aktualisieren Sie die Anzeige
 pygame.display.update()
# Begrenzen Sie die Bildrate
 Uhr.Tick (30)

Einrichten der Kamera

Nachdem Sie nun ein einfaches Spiel mit einem Spielerrechteck und zwei statischen Plattformen haben, können Sie mit der Arbeit an der Kamera beginnen. In PyGame ist die Kamera im Wesentlichen nur ein Versatz, der auf alle Objekte wirkt, die Sie auf den Bildschirm zeichnen. Das bedeutet, wenn Sie die Kamera nach links bewegen, scheint sich alles auf dem Bildschirm nach rechts zu bewegen.

Um die Kamera einzurichten, müssen Sie zuerst eine Variable definieren, die den X-Offset der Kamera enthält. Rufen Sie diese Variable auf Kamera_Offset_x und auf 0 initialisieren.

# Stellen Sie den Kamera-Offset ein
camera_offset_x = 0

Aktualisieren Sie als Nächstes die Positionen aller Objekte, die Sie auf den Bildschirm zeichnen, um den Kameraversatz zu berücksichtigen. Sie können dies tun, indem Sie die hinzufügen Kamera_Offset_x Wert auf die X-Position jedes Objekts. Beispielsweise können Sie die Position des Spielers wie folgt aktualisieren:

# Zeichne den Spieler
player_rect = Pygame. Rect (player_x + camera_offset_x, player_y, PLAYER_WIDTH,
 PLAYER_HEIGHT)
pygame.draw.rect (Bildschirm, (0, 0, 0), player_rect)

Ebenso können Sie die Positionen der statischen Plattformen wie folgt aktualisieren:

# Zeichnen Sie die statischen Rechtecke
rechteck_1_zeichnen_pos = rechteck_1.bewegung (kamera_offset_x, 0)
pygame.draw.rect (Bildschirm, RECTANGLE_COLOR_1, Rectangle_1_draw_pos)

rechteck_2_zeichnen_pos = rechteck_2.bewegung (kamera_offset_x, 0)
pygame.draw.rect (Bildschirm, RECTANGLE_COLOR_2, Rechteck_2_draw_pos)

Bewegen der Kamera mit Tastatureingaben

Nachdem Sie die Kamera eingerichtet haben, können Sie damit beginnen, sie zu bewegen. Eine Möglichkeit, dies zu tun, besteht darin, die Kamera als Reaktion auf Tastatureingaben zu bewegen. Sie können beispielsweise die Kamera nach links bewegen, wenn der Spieler die linke Pfeiltaste drückt.

Fügen Sie dazu den folgenden Code in die Ereignisschleife ein, die die Tastatureingaben verarbeitet:

Wenn event.type == Pygame. TASTE NACH UNTEN:
Wenn event.key == Pygame. K_LINKS:
 camera_offset_x -= PLAYER_SPEED
elf event.key == Pygame. K_RECHTS:
 camera_offset_x += PLAYER_SPEED

Eine andere Möglichkeit besteht darin, die x-Koordinate des Spielers auf der Tastatur zu ändern und dann den Kamera-Offset zu aktualisieren. Sie können dies folgendermaßen implementieren:

# Ereignisse behandeln
für Fall In pygame.event.get():
Wenn event.type == Pygame. AUFHÖREN:
 pygame.quit()
 aufhören()
Wenn event.type == Pygame. TASTE NACH UNTEN:
Wenn event.key == Pygame. K_LINKS:
 player_x -= PLAYER_SPEED
elf event.key == Pygame. K_RECHTS:
 player_x += PLAYER_SPEED

Dann können Sie den Kameraversatz in Bezug auf die x-Koordinate des Spielers wie folgt aktualisieren:

camera_offset_x = WINDOW_WIDTH // 2 - player_x - PLAYER_WIDTH // 2

Bewegen der Kamera mit Mauseingaben

Eine andere Möglichkeit, die Kamera zu bewegen, ist die Verwendung der Maus. Sie können dem Spieler erlauben, den Bildschirm zu verschieben, indem Sie mit der Maus klicken und ziehen.

Verfolgen Sie dazu die Position der Maus, wenn der Spieler die linke Maustaste drückt. Wenn sie die Maus bewegen, aktualisieren Sie die x-Koordinate des Spielers. Es sollte sich um die Differenz zwischen der aktuellen Mausposition und der von Ihnen verfolgten Anfangsposition ändern. mouse_start_pos.

# Ereignisse behandeln
für Fall In pygame.event.get():
Wenn event.type == Pygame. AUFHÖREN:
 pygame.quit()
 aufhören()
Wenn event.type == Pygame. MAUSTASTE NACH UNTEN:
Wenn event.button == 1:
 mouse_start_pos = pygame.mouse.get_pos()
Wenn event.type == Pygame. MAUSBEWEGUNG:
Wenn pygame.mouse.get_pressed()[0]:
 mouse_current_pos = pygame.mouse.get_pos()
 mouse_offset_x = mouse_current_pos[0] - mouse_start_pos[0]
 player_x -= mouse_offset_x
 mouse_start_pos = mouse_current_pos

Hinzufügen weiterer Kamerafunktionen

Neben dem Bildlauf-Kameraeffekt können Sie mehrere andere kamerabezogene Funktionen hinzufügen, um das Spielerlebnis zu verbessern. Eine solche Funktion ist ein Zoom-Kameraeffekt, der es dem Spieler ermöglicht, in die Spielwelt hinein- oder herauszuzoomen. Sie können diesen Effekt erzielen, indem Sie die Größe des Spielfensters ändern und die auf dem Bildschirm gezeichneten Objekte skalieren.

Definieren Sie dazu eine Zoomvariable, die die aktuelle Zoomstufe des Spiels speichert. Setzen Sie den Anfangswert auf 1,0, was keinen Zoom darstellt. Definieren Sie dann eine Funktion, die die skalierte Größe eines Objekts basierend auf der aktuellen Zoomstufe berechnet.

zoomen = 1.0
defget_scaled_size(Größe):
zurückkehren int (Größe * Zoom)

Aktualisieren Sie als Nächstes die Positionen und Größen der auf dem Bildschirm gezeichneten Objekte mithilfe von get_scaled_size Funktion. Beispielsweise können Sie die Position und Größe des Spielers wie folgt aktualisieren:

player_rect = Pygame. Rechteck(
 get_scaled_size (player_x + camera_offset_x),
 get_scaled_size (player_y),
 get_scaled_size (PLAYER_WIDTH),
 get_scaled_size (PLAYER_HEIGHT)
)

Aktualisieren Sie auf ähnliche Weise die Positionen und Größen der statischen Plattformen wie folgt:

Rectangle_1_draw_pos = Pygame. Rechteck(
 get_scaled_size (Rechteck_1.x + Kamera_Offset_x),
 get_scaled_size (Rechteck_1.y),
 get_scaled_size (rechteck_1.breite),
 get_scaled_size (Rechteck_1.Höhe)
)
pygame.draw.rect (Bildschirm, RECTANGLE_COLOR_1, Rectangle_1_draw_pos)
Rectangle_2_draw_pos = Pygame. Rechteck(
 get_scaled_size (Rechteck_2.x + Kamera_Offset_x),
 get_scaled_size (Rechteck_2.y),
 get_scaled_size (rechteck_2.breite),
 get_scaled_size (Rechteck_2.Höhe)
)
pygame.draw.rect (Bildschirm, RECTANGLE_COLOR_2, Rechteck_2_draw_pos)

Erhöhen oder verringern Sie die Zoomstufe um 0,1, wenn der Player drückt = oder - Schlüssel bzw. Legen Sie die neue Größe des Spielfensters basierend auf der aktuellen Zoomstufe fest. Fügen Sie dazu den folgenden Code in die Ereignisschleife ein, die die Tastatureingaben verarbeitet:

Wenn event.type == Pygame. TASTE NACH UNTEN:
Wenn event.key == Pygame. K_GLEICH:
 zoomen += 0.1
 screen = pygame.display.set_mode((
 int (WINDOW_WIDTH * Zoom),
 int (WINDOW_HEIGHT * Zoom)
 ))
elf event.key == Pygame. K_MINUS:
 zoomen -= 0.1
Wenn vergrößern < 0.1:
 zoomen = 0.1
 screen = pygame.display.set_mode((
 int (WINDOW_WIDTH * Zoom),
 int (WINDOW_HEIGHT * Zoom)
 ))

Mit dem obigen Code haben Sie unserem PyGame-Spiel erfolgreich einen Zoom-Kameraeffekt hinzugefügt. Indem Sie diese Funktion mit dem Bildlauf-Kameraeffekt kombinieren, können Sie ein dynamisches und fesselndes Spielerlebnis schaffen.

Verbesserung des Gameplays mit Kamerabewegungen

Das Hinzufügen einer Scroll-Kamera zu einem PyGame-Spiel verbessert nicht nur das visuelle Erlebnis, sondern verbessert auch das Gameplay. Es ermöglicht dem Spieler, mehr von der Spielwelt zu sehen, was ihm ein besseres Verständnis für seine Umgebung vermittelt und die Navigation erleichtert.

Sie können auch Kamerabewegungen verwenden, um Spezialeffekte zu erzeugen, wie z. B. das Vergrößern und Verkleinern oder das Schütteln des Bildschirms, um Explosionen oder Erdbeben zu simulieren.