Leser wie Sie helfen, MUO zu unterstützen. Wenn Sie über Links auf unserer Website einen Kauf tätigen, erhalten wir möglicherweise eine Affiliate-Provision. Weiterlesen.

Pygame bietet mehrere integrierte Funktionen zum Erkennen von Kollisionen zwischen Spielobjekten. Diese sind von unschätzbarem Wert, da es eine komplizierte Aufgabe sein kann, genau herauszufinden, wann und wie sich bewegende Objekte überlappen.

Erfahren Sie, wie Sie mit dem Pygame-Modul grundlegende Physik und Kollisionen in Ihr Spiel einfügen.

Pygames integrierte Kollisionserkennungsfunktionen

Die grundlegendste integrierte Kollisionserkennungsfunktion ist Spritecollide. Es nimmt ein Sprite, eine Gruppe von Sprites und einen booleschen Wert auf, der angibt, ob die Sprites "sterben" (entfernt) werden sollen, wenn sie kollidieren. Diese Funktion gibt eine Liste von Sprites zurück, die kollidiert sind. Hier ist ein Beispiel für die Verwendung:

collided_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, WAHR)

Eine weitere nützliche Kollisionserkennungsfunktion ist groupcollide, die zwei Gruppen von Sprites und auch einen booleschen Wert akzeptiert. Diese Funktion gibt ein Wörterbuch mit den kollidierten Sprites als Schlüssel und den Sprites, mit denen sie kollidierten, als Werte zurück. Hier ist ein Beispiel für die Verwendung:

Collision_dict = pygame.sprite.groupcollide (Gruppe1, Gruppe2, WAHR, WAHR)

Erstellen eines einfachen Plattformspiels mit der Spritecollide-Funktion

Um ein einfaches Plattformspiel mit Pygame zu erstellen, müssen Sie ein Spieler-Sprite erstellen, das der Benutzer steuern kann, und ein Plattform-Sprite, auf dem der Spieler stehen kann. Sie können die Spritecollide-Funktion verwenden, um zu erkennen, wenn das Player-Sprite mit dem Plattform-Sprite kollidiert, und zu verhindern, dass der Player durch die Plattform fällt.

Anfangen, Installieren Sie das Pygame-Modul mit Pip:

pip installiere pygame

Danach, Erstellen Sie einfache Klassen für den Player und die Plattform, die beide von der Sprite-Klasse von Pygame erben sollten. Die Player-Klasse sollte eine Aktualisierungsmethode haben, um die Position des Spielers basierend auf der Geschwindigkeit zu handhaben. Außerdem sollte es eine y_velocity-Variable haben, um den Gravitationseffekt anzuwenden. Die Platform-Klasse sollte eine __init__-Methode haben, die die Koordinaten der Plattform nimmt und eine Oberfläche mit dieser Größe erstellt.

Spielerklasse

Sie können eine Player-Klasse mit pygame.sprite erstellen. Sprite-Modul. Diese Klasse initialisiert den Player mit gegebenen x- und y-Koordinaten. Dann aktualisiert die Aktualisierungsmethode die Position des Spielers, indem sie den Wert y_velocity erhöht.

importieren Pygame
KlasseSpieler(pygame.sprite. Sprite):
def__drin__(selbst, x, y):
 super().__init__()
 self.image = Pygame. Oberfläche((32, 32))
 self.rect = self.image.get_rect (oben links = (x, y))
 self.y_velocity = 0
defaktualisieren(selbst):
 self.rect.y += self.y_velocity

Plattformklasse

Die Platform-Klasse verwendet auch das pygame.sprite. Sprite-Modul. Diese Klasse initialisiert die Plattform mit gegebenen x- und y-Koordinaten sowie einer Breite und Höhe.

KlassePlattform(pygame.sprite. Sprite):
def__drin__(selbst, x, y, Breite, Höhe):
 super().__init__()
 self.image = Pygame. Oberfläche ((Breite, Höhe))
 self.rect = self.image.get_rect (oben links = (x, y))

Die Spielschleife

Mit der Spielschleife können Sie ein Fenster mit einer Größe von 640 x 480 erstellen. Dann wird eine Schleife ausgeführt, die nach Ereignissen sucht, z. B. nach einem Quit-Befehl. Es wird auch nach Kollisionen zwischen dem Player und der Plattform suchen. Schließlich füllt es den Bildschirm mit einer weißen Farbe, zeichnet den Spieler und die Plattform und dreht dann die Anzeige um.

Spieler = Spieler(100, 300)
player_group = pygame.sprite. Gruppe()
player_group.add (Spieler)
Plattform = Plattform (50, 400, 100, 20)
platform_group = pygame.sprite. Gruppe()
platform_group.add (Plattform)


# Pygame initialisieren und Fenster erstellen
pygame.init()
screen = pygame.display.set_mode((640, 480))


# Hauptspielschleife
läuft = WAHR


während Betrieb:
für Fall In pygame.event.get():
Wenn event.type == Pygame. AUFHÖREN:
 läuft = FALSCH

 player_group.update()
 collided = pygame.sprite.spritecollide (Spieler, Plattformgruppe, FALSCH)


Wenn kollidiert:
 player.y_velocity = 0
 screen.fill ((255, 255, 255))
 player_group.draw (Bildschirm)
 platform_group.draw (Bildschirm)
 pygame.display.flip()
pygame.quit()

Unten ist die Ausgabe:

Implementierung von Schwerkraft und Sprungverhalten

Um Schwerkraft und Sprungverhalten in Ihrem Plattformspiel zu implementieren, müssen Sie Ihrem Spieler-Sprite eine y-Geschwindigkeit hinzufügen und seine y-Position in jedem Frame aktualisieren. Dazu können Sie die Update-Methode innerhalb der Player-Klasse verwenden und das folgende Code-Snippet hinzufügen:

KlasseSpieler(pygame.sprite. Sprite):
def__drin__(selbst, x, y):
 super().__init__()
 self.image = Pygame. Oberfläche((32, 32))
 self.rect = self.image.get_rect (oben links = (x, y))
 self.y_velocity = 0
defaktualisieren(selbst):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVITY # Gravitation auf die y-Geschwindigkeit anwenden

Jedes Mal, wenn Sie die Update-Methode aufrufen, wird die Spielerposition jetzt entsprechend ihrer Geschwindigkeit und Schwerkraft aktualisiert.

Um das Spieler-Sprite springen zu lassen, können Sie die Sprungaktion an eine bestimmte Taste oder Schaltfläche binden und die y-Geschwindigkeit des Spielers mit einem negativen Wert aktualisieren. Das folgende Code-Snippet ist ein Beispiel dafür, wie man springt, wenn ein Spieler die Leertaste drückt.

JUMP_VELOCITY = -10
# innerhalb der Spielschleife
Wenn event.type == Pygame. TASTE NACH UNTEN Und event.key == Pygame. K_SPACE:
 player.y_velocity = SPRUNG_GESCHWINDIGKEIT

Beachten Sie, dass Sie event.type überprüfen müssen, um sicherzustellen, dass das Ereignis ein KEYDOWN-Ereignis ist, bevor Sie den Schlüsselwert überprüfen.

Hinzufügen grundlegender Physik wie Reibung und Beschleunigung

Um Ihrem Plattformspiel grundlegende Physik wie Reibung und Beschleunigung hinzuzufügen, müssen Sie die x-Geschwindigkeit Ihres Spieler-Sprites in jedem Frame aktualisieren. Sie können der Player-Klasse x-Geschwindigkeit hinzufügen und sie auf die gleiche Weise wie die y-Geschwindigkeit aktualisieren. Um Reibung zu implementieren, können Sie die x-Geschwindigkeit des Player-Sprites in jedem Frame um einen kleinen Betrag verringern. Sie können beispielsweise das folgende Code-Snippet in die Update-Methode der Player-Klasse einfügen:

Reibung = 0.9
KlasseSpieler(pygame.sprite. Sprite):
def__drin__(selbst, x, y):
 super().__init__()
 self.image = Pygame. Oberfläche((32, 32))
 self.rect = self.image.get_rect (oben links = (x, y))
 self.y_velocity = 0
 self.x_velocity = 0
defaktualisieren(selbst):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += GRAVITY # Gravitation auf die y-Geschwindigkeit anwenden
 self.x_velocity *= REIBUNG # Wenden Sie Reibung auf die x-Geschwindigkeit an

Um die Beschleunigung zu implementieren, können Sie eine Variable, player_movement, für die horizontale Bewegung festlegen und die x-Geschwindigkeit des Player-Sprites entsprechend dem Wert von player_movement aktualisieren. Sie können dies tun, indem Sie die Bewegung an bestimmte Tasten oder Schaltflächen binden und die X-Geschwindigkeit des Spielers in der Ereignisschleife aktualisieren, zum Beispiel:

BESCHLEUNIGUNG = 0.5
player_movement = 0
Wenn event.type == Pygame. TASTE NACH UNTEN:
Wenn event.key == Pygame. K_LINKS:
 player_movement = -1
elf event.key == Pygame. K_RECHTS:
 player_movement = 1
elf event.type == Pygame. TASTE AUF:
Wenn event.key In (Pygame. K_LINKS, Pygame. K_RECHTS):
 player_movement = 0

player.x_velocity += player_movement * BESCHLEUNIGUNG

Durch die Verwendung dieser Techniken können Sie ein einfaches, aber unterhaltsames Plattformspiel erstellen, indem Sie die integrierten Kollisionserkennungsfunktionen und die grundlegende Physik von Pygame verwenden. Mit ein wenig Kreativität und Experimentieren können Sie diese Techniken verwenden, um eine Vielzahl unterschiedlicher Spiele und Spielmechaniken zu erstellen.

Den vollständigen Code finden Sie in der GitHub-Repository.

Unten ist die Ausgabe:

Verbessern Sie die Benutzerinteraktion mit Kollisionen

Viele Spiele erfordern eine Art Kollisionserkennung. Sie können Kollisionen verwenden, um eine breite Palette von Spielmechaniken zu erstellen, von einfachen Plattformspielen bis hin zu komplexen physikbasierten Simulationen.

Die Implementierung grundlegender Physik wie Schwerkraft, Reibung und Beschleunigung kann auch die Benutzerbindung erheblich verbessern und Spielobjekten Realismus und ein Gefühl von Gewicht verleihen.