Czytelnicy tacy jak ty pomagają wspierać MUO. Kiedy dokonujesz zakupu za pomocą linków na naszej stronie, możemy otrzymać prowizję partnerską. Czytaj więcej.

Pygame zapewnia kilka wbudowanych funkcji do wykrywania kolizji między obiektami gry. Są one nieocenione, ponieważ dokładne ustalenie, kiedy i jak poruszające się obiekty zachodzą na siebie, może być skomplikowanym zadaniem.

Dowiedz się, jak dodać podstawową fizykę i kolizje do swojej gry za pomocą modułu pygame.

Wbudowane funkcje wykrywania kolizji Pygame

Najbardziej podstawową wbudowaną funkcją wykrywania kolizji jest spritecollide. Przyjmuje duszka, grupę duszków i wartość logiczną wskazującą, czy duszki powinny „umrzeć” (zostać usunięte), gdy się zderzą. Ta funkcja zwraca listę duszków, które się zderzyły. Oto przykład, jak go używać:

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

Inną użyteczną funkcją wykrywania kolizji jest groupcollide, która pobiera dwie grupy sprite'ów oraz wartość logiczną. Ta funkcja zwraca słownik ze zderzonymi sprite'ami jako kluczami i sprite'ami, z którymi się zderzyły jako wartościami. Oto przykład, jak go używać:

instagram viewer 

kolizja_dykt = pygame.sprite.groupcollide (grupa1, grupa2, PRAWDA, PRAWDA)

Tworzenie podstawowej gry platformowej przy użyciu funkcji spritecollide

Aby stworzyć podstawową grę platformową za pomocą Pygame, musisz stworzyć sprite'a gracza, którego użytkownik może kontrolować, oraz sprite'a platformy, na którym gracz będzie mógł stanąć. Możesz użyć funkcji spritecollide, aby wykryć, kiedy duszek gracza zderza się z duszkiem platformy i zapobiec upadkowi gracza przez platformę.

Zacząć, zainstaluj moduł pygame za pomocą pip:

pip zainstaluj pygame

Po tym, tworzyć proste klasy dla Gracza i Platformy, z których oba powinny dziedziczyć po klasie Sprite Pygame. Klasa Player powinna mieć metodę aktualizacji do obsługi pozycji gracza na podstawie prędkości. Powinien również mieć zmienną y_velocity, aby zastosować efekt grawitacji. Klasa Platform powinna mieć metodę __init__, która pobiera współrzędne platformy i tworzy powierzchnię o takim rozmiarze.

Klasa gracza

Możesz utworzyć klasę gracza za pomocą pliku pygame.sprite. Moduł Sprite'a. Ta klasa zainicjuje gracza z podanymi współrzędnymi x i y. Następnie metoda update zaktualizuje pozycję gracza poprzez zwiększenie wartości y_velocity.

import pygame
klasaGracz(pygame.sprite. Krasnoludek):
pok__w tym__(ja, x, y):
 super().__init__()
 self.image = pygame. Powierzchnia((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 własny.y_prędkość = 0
pokaktualizacja(samego siebie):
 self.rect.y += self.y_velocity

Klasa platformy

Klasa Platform również używa pliku pygame.sprite. Moduł Sprite'a. Ta klasa zainicjuje platformę z podanymi współrzędnymi x i y, a także szerokością i wysokością.

klasaPlatforma(pygame.sprite. Krasnoludek):
pok__w tym__(ja, x, y, szerokość, wysokość):
 super().__init__()
 self.image = pygame. Powierzchnia((szerokość, wysokość))
 self.rect = self.image.get_rect (topleft=(x, y))

Pętla gry

Pętla gry pozwoli Ci stworzyć okno o rozmiarze 640x480. Następnie uruchomi pętlę, która sprawdzi wszelkie zdarzenia, takie jak polecenie wyjścia. Sprawdzi również, czy nie ma kolizji między graczem a platformą. Na koniec wypełni ekran białym kolorem, narysuje gracza i platformę, a następnie odwróci wyświetlacz.

gracz = gracz(100, 300)
player_group = pygame.sprite. Grupa()
player_group.add (gracz)
platforma = platforma (50, 400, 100, 20)
platforma_grupa = pygame.sprite. Grupa()
platform_group.add (platforma)


# Zainicjuj pygame i utwórz okno
pygame.init()
ekran = pygame.display.set_mode((640, 480))


# Główna pętla gry
bieganie = PRAWDA


chwila działanie:
Do wydarzenie W pygame.event.get():
Jeśli event.type == pygame. ZREZYGNOWAĆ:
 bieganie = FAŁSZ

 player_group.update()
 zderzył się = pygame.sprite.spritecollide (gracz, platforma_grupa, FAŁSZ)


Jeśli zderzył się:
 gracz.y_prędkość = 0
 ekran.wypełnienie((255, 255, 255))
 player_group.draw (ekran)
 platform_group.draw (ekran)
 pygame.display.flip()
pygame.quit()

Poniżej znajduje się wyjście:

Wdrażanie grawitacji i skakania

Aby zaimplementować zachowanie grawitacji i skakania w grze platformowej, musisz dodać prędkość y do duszka gracza i zaktualizować jego pozycję y w każdej klatce. Aby to zrobić, możesz użyć metody update wewnątrz klasy Player i dodać następujący fragment kodu:

klasaGracz(pygame.sprite. Krasnoludek):
pok__w tym__(ja, x, y):
 super().__init__()
 self.image = pygame. Powierzchnia((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 własny.y_prędkość = 0
pokaktualizacja(samego siebie):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAWITACJA # Zastosuj grawitację do prędkości y

Teraz za każdym razem, gdy wywołasz metodę aktualizacji, zaktualizuje ona pozycję gracza zgodnie z jego prędkością i grawitacją.

Aby duszek gracza skakał, możesz powiązać akcję skakania z określonym klawiszem lub przyciskiem i zaktualizować prędkość y gracza o wartość ujemną. Poniższy fragment kodu jest przykładem skoku, gdy gracz naciśnie spację.

PRĘDKOŚĆ_SKOKU = -10
# wewnątrz pętli gry
Jeśli event.type == pygame. KLAWISZ W DÓŁ I event.key == pygame. K_SPACE:
 gracz.y_prędkość = PRĘDKOŚĆ_SKOKU

Pamiętaj, że przed sprawdzeniem wartości klucza będziesz musiał sprawdzić event.type, aby upewnić się, że zdarzenie jest zdarzeniem KEYDOWN.

Dodawanie podstaw fizyki, takich jak tarcie i przyspieszenie

Aby dodać podstawową fizykę, taką jak tarcie i przyspieszenie, do swojej gry platformowej, musisz zaktualizować prędkość x swojego duszka gracza w każdej klatce. Możesz dodać prędkość x do klasy gracza i zaktualizować ją w taki sam sposób, jak prędkość y. Aby zaimplementować tarcie, możesz zmniejszyć prędkość x duszka gracza o niewielką wartość w każdej klatce. Na przykład możesz dodać następujący fragment kodu do metody aktualizacji klasy Player:

TARCIE = 0.9
klasaGracz(pygame.sprite. Krasnoludek):
pok__w tym__(ja, x, y):
 super().__init__()
 self.image = pygame. Powierzchnia((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 własny.y_prędkość = 0
 własny.x_prędkość = 0
pokaktualizacja(samego siebie):
 self.rect.y += self.y_velocity
 własny.prost.x += własny.x_prędkość
 self.y_velocity += GRAWITACJA # Zastosuj grawitację do prędkości y
 własny.x_prędkość *= TARCIE # Zastosuj tarcie do prędkości x

Aby zaimplementować przyspieszenie, możesz ustawić zmienną player_movement dla ruchu poziomego i zaktualizować prędkość x duszka gracza zgodnie z wartością player_movement. Możesz to zrobić, powiązując ruch z określonymi klawiszami lub przyciskami i aktualizując prędkość x gracza w pętli zdarzeń, na przykład:

PRZYSPIESZENIE = 0.5
ruch_gracza = 0
Jeśli event.type == pygame. KLAWIATURA:
Jeśli event.key == pygame. K_LEWO:
 ruch_gracza = -1
Elif event.key == pygame. K_PRAWO:
 ruch_gracza = 1
Elif event.type == pygame. KLUCZ:
Jeśli zdarzenie.klucz W (gry. K_LEFT, pygame. K_PRAWY):
 ruch_gracza = 0

gracz.x_prędkość += ruch_gracza * PRZYSPIESZENIE

Korzystając z tych technik, możesz stworzyć prostą, ale zabawną grę platformową, korzystając z wbudowanych funkcji wykrywania kolizji i podstawowej fizyki Pygame. Przy odrobinie kreatywności i eksperymentowania możesz użyć tych technik do stworzenia wielu różnych gier i mechanizmów gry.

Cały kod można znaleźć w Repozytorium GitHub.

Poniżej znajduje się wyjście:

Popraw zaangażowanie użytkowników dzięki kolizjom

Wiele gier wymaga jakiejś formy wykrywania kolizji. Możesz używać kolizji do tworzenia szerokiej gamy mechanizmów gry, od prostych platformówek po złożone symulacje oparte na fizyce.

Wdrożenie podstawowych fizyki, takich jak grawitacja, tarcie i przyspieszenie, może również znacznie poprawić zaangażowanie użytkownika, dodając realizmu i poczucia wagi obiektom gry.